72#include "XrdVersion.hh"
75#define ENODATA ENOATTR
79#define ETIME ETIMEDOUT
108static const int op_isOpen = 0x00010000;
109static const int op_isRead = 0x00020000;
118 if (gettimeofday(&tv, 0))
119 {perror(
"gettimeofday");
122 tmp = localtime(&tv.tv_sec);
124 {perror(
"localtime");
128 if (strftime(buff,
sizeof(buff),
"%y%m%d:%H%M%S. ", tmp) <= 0)
134 snprintf(tuff,
sizeof(tuff),
"%d",
static_cast<int>(tv.tv_usec/100000));
155static const char *startUP = getTime();
162int XrdXrootdProtocol::do_Auth()
191 {eText =
eMsg.getErrText(rc);
192 eDest.
Emsg(
"Xeq",
"User authentication failed;", eText);
209 if (!logLogin(
true))
return -1;
216 {
TRACEP(LOGIN,
"more auth requested; sz=" <<(parm ? parm->
size : 0));
221 eDest.
Emsg(
"Xeq",
"Security requested additional auth w/o parms!");
236 eText =
eMsg.getErrText(rc);
237 eDest.
Emsg(
"Xeq",
"User authentication failed;", eText);
245int XrdXrootdProtocol::do_Bind()
251 char buff[64], *cp, *dp;
325 if ( (dp = rindex(cp,
'@'))) *dp =
'\0';
326 if (!(dp = rindex(cp,
'.'))) pPid = 0;
327 else {*dp++ =
'\0'; pPid = strtol(dp, (
char **)NULL, 10);}
345 sprintf(buff,
"FD %d#%d bound",
Link->
FDnum(), i);
354 buff[0] =
static_cast<char>(i);
373int XrdXrootdProtocol::do_Chmod()
404int XrdXrootdProtocol::do_CKsum(
int canit)
407 char *algT =
JobCKT, *args[6];
421 if (rpCheck(
argp->
buff, &opaque))
return rpEmsg(
"Check summing",
argp->
buff);
435 algT = getCksType(opaque, cksT,
sizeof(cksT));
438 snprintf(ebuf,
sizeof(ebuf),
"%s checksum not supported.", cksT);
445 if (
JobLCL && (rc = do_CKsum(algT,
argp->
buff, opaque)) <= 0)
return rc;
462 if (
Client->
eaAPI->
Get(std::string(
"request.name"), keyval) && !keyval.empty())
463 args[4] =
const_cast<char *
>(keyval.c_str());
481int XrdXrootdProtocol::do_CKsum(
char *algT,
const char *
Path,
char *Opaque)
483 static char Space =
' ';
485 int CKTLen = strlen(algT);
487 myError,
CRED, Opaque);
488 const char *csData = myError.getErrText(
ec);
492 if (rc)
return fsError(rc, 0, myError,
Path, Opaque);
498 struct iovec
iov[4] = {{0,0}, {algT, (size_t)CKTLen}, {&Space, 1},
499 {(
char *)csData, strlen(csData)+1}};
506 {
const char *eTxt[2] = {
JobCKT,
" checksum not available."};
507 myError.setErrInfo(0, eTxt, 2);
520int XrdXrootdProtocol::do_Close()
536 "close does not refer to an open file");
546 if (fp->
pgwFob && !do_PgClose(fp, rc))
571 rc = fp->XrdSfsp->close();
572 TRACEP(FS,
" fh=" <<fh.handle <<
" close rc=" <<rc);
576 return fsError(rc, 0, fp->XrdSfsp->error, 0, 0);
585 if (
SFS_OK != rc) retval = fsError(rc, 0, fp->XrdSfsp->error, 0, 0);
592 if (!doDel) fp->
Ref(-1);
604int XrdXrootdProtocol::do_Dirlist()
606 int bleft, rc = 0, dlen, cnt = 0;
607 char *opaque, *buff, ebuff[4096];
633 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s",
argp->
buff);
650 return do_DirStat(dp, ebuff, opaque);
660 do {buff = ebuff; bleft =
sizeof(ebuff);
661 while(dname || (dname = dp->
nextEntry()))
662 {dlen = strlen(dname);
663 if (dlen > 2 || dname[0] !=
'.' || (dlen == 2 && dname[1] !=
'.'))
664 {
if ((bleft -= (dlen+1)) < 0)
break;
665 strcpy(buff, dname); buff += dlen; *buff =
'\n'; buff++; cnt++;
670 }
while(!rc && dname);
676 else {*(buff-1) =
'\0';
685 if (!rc) {
TRACEP(FS,
"dirlist entries=" <<cnt <<
" path=" <<
argp->
buff);}
698 char *buff, *dLoc, *algT = 0;
699 const char *csData, *dname;
700 int bleft, rc = 0, dlen, cnt = 0, statSz = 160;
702 struct {
char ebuff[8192];
char epad[512];} XB;
709 algT = getCksType(opaque, cksT,
sizeof(cksT));
712 snprintf(ebuf,
sizeof(ebuf),
"%s checksum not supported.", cksT);
727 dlen = strlen(pbuff);
728 if (pbuff[dlen-1] !=
'/') {pbuff[dlen] =
'/'; dlen++;}
737 strcpy(XB.ebuff,
".\n0 0 0 0\n");
738 buff = XB.ebuff+10; bleft =
sizeof(XB.ebuff)-10;
748 do {
while(dname || (dname = dp->
nextEntry()))
749 {dlen = strlen(dname);
750 if (dlen > 2 || dname[0] !=
'.' || (dlen == 2 && dname[1] !=
'.'))
751 {
if ((bleft -= (dlen+1)) < 0 || bleft < statSz)
break;
752 if (dLoc) strcpy(dLoc, dname);
755 if (rc ==
SFS_ERROR && myError.getErrInfo() == ENOENT)
756 {dname = 0;
continue;}
761 strcpy(buff, dname); buff += dlen; *buff =
'\n'; buff++; cnt++;
762 dlen = StatGen(
Stat, buff,
sizeof(XB.epad));
763 bleft -= dlen; buff += (dlen-1);
766 pbuff, myError,
CRED, opaque);
767 csData = myError.getErrText();
768 if (
ec !=
SFS_OK || !(*csData) || *csData ==
'!')
770 int n = snprintf(buff,
sizeof(XB.epad),
" [ %s:%s ]",
772 buff += n; bleft -= n;
774 *buff =
'\n'; buff++;
780 buff = XB.ebuff; bleft =
sizeof(XB.ebuff);
783 }
while(!rc && dname);
789 else {*(buff-1) =
'\0';
798 if (!rc) {
TRACEP(FS,
"dirstat entries=" <<cnt <<
" path=" <<
argp->
buff);}
806int XrdXrootdProtocol::do_Endsess()
818 memcpy((
void *)&sessID.
Pid, &sp->
Pid,
sizeof(sessID.
Pid));
819 memcpy((
void *)&sessID.
FD, &sp->
FD,
sizeof(sessID.
FD));
820 memcpy((
void *)&sessID.
Inst, &sp->
Inst,
sizeof(sessID.
Inst));
824 TRACEP(LOGIN,
"endsess " <<sessID.
Pid <<
':' <<sessID.
FD <<
'.' <<sessID.
Inst);
832 if ((sessID.
FD == 0 && sessID.
Inst == 0)
837 TRACEP(LOGIN,
"endsess " <<sessID.
Pid <<
':' <<sessID.
FD <<
'.' <<sessID.
Inst
838 <<
" rc=" <<rc <<
" (" <<
XrdSysE2T(rc < 0 ? -rc : EAGAIN) <<
")");
861int XrdXrootdProtocol::do_gpFile()
882int XrdXrootdProtocol::do_Locate()
886 char *opaque = 0, *
Path, *fn =
argp->
buff, opt[8], *op=opt;
903 TRACEP(FS,
"locate " <<opt <<
' ' <<fn);
907 if (*fn !=
'*'){
Path = fn;
910 else if (*(fn+1)) {
Path = fn+1;
925 {
if (rpCheck(
Path, &opaque))
return rpEmsg(
"Locating",
Path);
926 if (!doDig && !Squash(
Path))
return vpEmsg(
"Locating",
Path);
935 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
939 TRACEP(FS,
"rc=" <<rc <<
" locate " <<fn);
947int XrdXrootdProtocol::do_Login()
951 int i, pid, rc, sendSID = 0;
961 {
const char *
emsg =
"login requires TLS be enabled";
963 {
emsg =
"login requires TLS support";
973 uname[
sizeof(uname)-1] = 0;
979 "duplicate login; already logged in");
1046 if (pp && i ) {
if (!sendSID) rc =
Response.
Send((
void *)pp, i);
1047 else {
struct iovec
iov[3];
1048 iov[1].iov_base = (
char *)&sessID;
1049 iov[1].iov_len =
sizeof(sessID);
1050 iov[2].iov_base = (
char *)pp;
1056 else {rc = (sendSID ?
Response.
Send((
void *)&sessID,
sizeof(sessID))
1061 else {rc = (sendSID ?
Response.
Send((
void *)&sessID,
sizeof(sessID))
1079 char *rnumb = loginEnv.Get(
"xrd.rn");
1080 char *cCode = loginEnv.Get(
"xrd.cc");
1081 char *tzVal = loginEnv.Get(
"xrd.tz");
1082 char *appXQ = loginEnv.Get(
"xrd.appname");
1083 char *aInfo = loginEnv.Get(
"xrd.info");
1084 int tzNum = (tzVal ? atoi(tzVal) : 0);
1085 if (cCode && *cCode && tzNum >= -12 && tzNum <= 14)
1093 snprintf(apBuff,
sizeof(apBuff),
"&R=%s&x=%s&y=%s&I=%c",
1094 (rnumb ? rnumb :
""),
1095 (appXQ ? appXQ :
""), (aInfo ? aInfo :
""),
1101 {
int majr, minr, pchr;
1102 if (sscanf(rnumb,
"v%d.%d.%d", &majr, &minr, &pchr) == 3)
1103 clientRN = (majr<<16) | ((minr<<8) | pchr);
1104 else if (sscanf(rnumb,
"v%d-%*x", &majr) == 1)
clientRN = -1;
1106 if (appXQ)
AppName = strdup(appXQ);
1134int XrdXrootdProtocol::do_Mkdir()
1167int XrdXrootdProtocol::do_Mv()
1170 char *oldp, *newp, *Opaque, *Npaque;
1187 while(*newp && *newp !=
' ') newp++;
1188 if (*newp) {*newp =
'\0'; newp++;
1189 while(*newp && *newp ==
' ') newp++;
1195 if (rpCheck(oldp, &Opaque))
return rpEmsg(
"Renaming", oldp);
1196 if (rpCheck(newp, &Npaque))
return rpEmsg(
"Renaming to", newp);
1197 if (!Squash(oldp))
return vpEmsg(
"Renaming", oldp);
1198 if (!Squash(newp))
return vpEmsg(
"Renaming to", newp);
1208 TRACEP(FS,
"rc=" <<rc <<
" mv " <<oldp <<
' ' <<newp);
1230 if (!(pp = VerifyStream(rc, pathID)))
return rc;
1243 pp->
Resume = &XrdXrootdProtocol::do_OffloadIO;
1247 pp->
reTry = &isAvail;
1257 if ((pioP = pp->
pioFree))
break;
1258 pp->
reTry = &isAvail;
1260 TRACEP(FSZIO,
"busy path " <<pathID <<
" offs=" <<IO.Offset);
1262 TRACEP(FSZIO,
"retry path " <<pathID <<
" offs=" <<IO.Offset);
1266 return Response.Send(
kXR_ArgInvalid,
"path ID is not connected");
1273 pioP->
Set(Invoke, IO, streamID);
1286int XrdXrootdProtocol::do_OffloadIO()
1299 TRACEP(FSZIO,
"dispatch new I/O path " <<
PathID <<
" offs=" <<
IO.Offset);
1309 if (rc > 0 && !
isNOP)
1311 Resume = &XrdXrootdProtocol::do_OffloadIO;
1331 if (rc)
isNOP =
true;
1337 TRACEP(FSZIO,
"offload complete path "<<
PathID<<
" virt rc=" <<rc);
1338 return (rc ? rc : -EINPROGRESS);
1356 : fp(0), xp(0), Locker(lkP), path(fn), mode(0),
1362 else {
if (fp)
delete fp;
1363 if (mode) Locker->
Unlock(path,mode);
1370int XrdXrootdProtocol::do_Open()
1374 int rc, mode,
opts, openopts, compchk = 0;
1375 int popt, retStat = 0;
1376 char *opaque,
usage, ebuff[2048], opC;
1377 bool doDig, doforce =
false, isAsync =
false;
1378 char *fn =
argp->
buff, opt[16], *op=opt;
1381 struct stat statbuf;
1383 int resplen =
sizeof(myResp.fhandle);
1384 struct iovec IOResp[3];
1397 mode = mapMode(mode) | S_IRUSR | S_IWUSR;
usage =
'r';
1432 {openopts |=
SFS_O_RAWIO; *op++ =
'c'; compchk = 1;}
1435 {*op++ =
'a'; isAsync =
true;}
1447 {
char* cgiP = index(fn,
'?');
1448 if (cgiP) *cgiP = 0;
1449 TRACEP(FS,
"open " <<opt <<
' ' <<fn);
1450 if (cgiP) *cgiP =
'?';
1455 if (rpCheck(fn, &opaque))
return rpEmsg(
"Opening", fn);
1465 if (!(popt = Squash(fn)))
return vpEmsg(
"Opening", fn);
1477 OpenHelper oHelp(
Locker, fn);
1484 if (rc > 0) who = (rc > 1 ?
"readers" :
"reader");
1486 who = (rc > 1 ?
"writers" :
"writer");
1488 snprintf(ebuff,
sizeof(ebuff)-1,
1489 "%s file %s is already opened by %d %s; open denied.",
1490 (
'r' ==
usage ?
"Input" :
"Output"), fn, rc, who);
1493 }
else oHelp.mode =
usage;
1504 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s",fn);
1523 (mode_t)mode,
CRED, opaque)))
1524 {rc = fsError(rc, opC, fp->
error, fn, opaque);
return rc;}
1530 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1548 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1562 if ((
'r' ==
usage && wrtrs) || (
'w' ==
usage && rdrs) || wrtrs > 1)
1563 {snprintf(ebuff,
sizeof(ebuff)-1,
1564 "%s file %s forced opened with %d reader(s) and %d writer(s).",
1565 (
'r' ==
usage ?
"Input" :
"Output"), fn, rdrs, wrtrs);
1572 memset(&myResp, 0,
sizeof(myResp));
1573 if (!compchk) resplen =
sizeof(myResp.fhandle);
1575 fp->
getCXinfo((
char *)myResp.cptype, cpsize);
1576 myResp.cpsize =
static_cast<kXR_int32>(htonl(cpsize));
1577 resplen =
sizeof(myResp);
1583 {retStat = StatGen(statbuf, ebuff,
sizeof(ebuff));
1584 IOResp[1].iov_base = (
char *)&myResp; IOResp[1].iov_len =
sizeof(myResp);
1585 IOResp[2].iov_base = ebuff; IOResp[2].iov_len = retStat;
1586 resplen =
sizeof(myResp) + retStat;
1605 memcpy((
void *)myResp.fhandle,(
const void *)&fhandle,
sizeof(myResp.fhandle));
1645int XrdXrootdProtocol::do_Ping()
1661int XrdXrootdProtocol::do_Prepare(
bool isQuery)
1674 int rc, pathnum = 0;
1675 char reqid[128], nidbuff[512], *path, *opaque, *prpid = 0;
1678 bool isCancel, isEvict, isPrepare;
1698 isPrepare = !(isCancel || isQuery);
1705 "Surpassed this connection's prepare limit.");
1723 if (isCancel || isQuery)
1724 {
if (!(prpid = pathlist.GetLine()))
1726 fsprep.
reqid = prpid;
1731 prpid =
PrepID->
isMine(prpid, hport, hname,
sizeof(hname));
1734 "Prepare requestid owned by an unknown server");
1736 << hname <<
':' <<hport);
1742 {prpid =
PrepID->
ID(reqid,
sizeof(reqid));
1743 fsprep.
reqid = reqid;
1746 reqid[0]=
'*'; reqid[1]=
'\0';
1747 fsprep.
reqid = prpid = reqid;
1760 while((path = pathlist.GetLine()))
1761 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Preparing", path);
1762 if (!Squash(path))
return vpEmsg(
"Preparing", path);
1764 (pLast ? (pLast->next = pP) : (pFirst = pP)); pLast = pP;
1766 (oLast ? (oLast->next = oP) : (oFirst = oP)); oLast = oP;
1769 fsprep.
paths = pFirst;
1770 fsprep.
oinfo = oFirst;
1794 char *mBuff = myError.getMsgBuff(rc);
1795 pargs.reqid = prpid;
1797 pargs.paths = pFirst;
1799 if (rc < 0) rc =
Response.
Send(
"No information found.");
1827 else snprintf(nidbuff,
sizeof(nidbuff),
"%s://%s:%d/",
1861 {pargs.reqid = prpid;
1863 pargs.paths = pFirst;
1880int XrdXrootdProtocol::do_Protocol()
1891 bool wantTLS =
false;
1916 ioVec[iovN ].iov_base = (
void *)&theResp.
secreq;
1917 ioVec[iovN++].iov_len = n;
1943 theResp.
flags = (wantTLS ? theRlt : theRle);
1945 theResp.
flags = theRlf;
1951 theResp.
pval = verNum;
1959 if (rc == 0 && wantTLS)
1975int XrdXrootdProtocol::do_Qconf()
1979 char *val, buff[4096], *bp=buff;
1980 int n, bleft =
sizeof(buff);
1984 if (!qcargs.GetLine() || !(val = qcargs.GetToken()))
1989 if (!strcmp(val,
"cmsd") || !strcmp(val,
"xrootd"))
1990 return do_QconfCX(qcargs, val);
1998 if (!strcmp(
"bind_max", val))
1999 {n = snprintf(bp, bleft,
"%d\n",
maxStreams-1);
2000 bp += n; bleft -= n;
2002 else if (!strcmp(
"chksum", val))
2003 {
const char *csList = getenv(
"XRD_CSLIST");
2005 {n = snprintf(bp, bleft,
"chksum\n");
2006 bp += n; bleft -= n;
2009 n = snprintf(bp, bleft,
"%s\n", csList);
2010 bp += n; bleft -= n;
2012 else if (!strcmp(
"cid", val))
2013 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2014 if (!cidval || !(*cidval)) cidval =
"cid";
2015 n = snprintf(bp, bleft,
"%s\n", cidval);
2016 bp += n; bleft -= n;
2018 else if (!strcmp(
"cms", val))
2021 n = snprintf(bp, bleft,
"%s\n", myError.getErrText());
2022 else n = snprintf(bp, bleft,
"%s\n",
"cms");
2023 bp += n; bleft -= n;
2025 else if (!strcmp(
"pio_max", val))
2026 {n = snprintf(bp, bleft,
"%d\n",
maxPio+1);
2027 bp += n; bleft -= n;
2029 else if (!strcmp(
"readv_ior_max", val))
2031 bp += n; bleft -= n;
2033 else if (!strcmp(
"readv_iov_max", val))
2035 bp += n; bleft -= n;
2037 else if (!strcmp(
"role", val))
2038 {
const char *theRole = getenv(
"XRDROLE");
2039 n = snprintf(bp, bleft,
"%s\n", (theRole ? theRole :
"none"));
2040 bp += n; bleft -= n;
2042 else if (!strcmp(
"sitename", val))
2043 {
const char *siteName = getenv(
"XRDSITE");
2044 n = snprintf(bp, bleft,
"%s\n", (siteName ? siteName :
"sitename"));
2045 bp += n; bleft -= n;
2047 else if (!strcmp(
"start", val))
2048 {n = snprintf(bp, bleft,
"%s\n", startUP);
2049 bp += n; bleft -= n;
2051 else if (!strcmp(
"sysid", val))
2052 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2053 const char *nidval = getenv(
"XRDCMSVNID");
2054 if (!cidval || !(*cidval) || !nidval || !(*nidval))
2055 {cidval =
"sysid"; nidval =
"";}
2056 n = snprintf(bp, bleft,
"%s %s\n", nidval, cidval);
2057 bp += n; bleft -= n;
2059 else if (!strcmp(
"tpc", val))
2060 {
char *tpcval = getenv(
"XRDTPC");
2061 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpc"));
2062 bp += n; bleft -= n;
2064 else if (!strcmp(
"tpcdlg", val))
2065 {
char *tpcval = getenv(
"XRDTPCDLG");
2066 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpcdlg"));
2067 bp += n; bleft -= n;
2069 else if (!strcmp(
"tls_port", val) &&
tlsPort)
2070 {n = snprintf(bp, bleft,
"%d\n",
tlsPort);
2071 bp += n; bleft -= n;
2073 else if (!strcmp(
"window", val) &&
Window)
2074 {n = snprintf(bp, bleft,
"%d\n",
Window);
2075 bp += n; bleft -= n;
2077 else if (!strcmp(
"version", val))
2078 {n = snprintf(bp, bleft,
"%s\n", XrdVSTRING);
2079 bp += n; bleft -= n;
2081 else if (!strcmp(
"vnid", val))
2082 {
const char *nidval = getenv(
"XRDCMSVNID");
2083 if (!nidval || !(*nidval)) nidval =
"vnid";
2084 n = snprintf(bp, bleft,
"%s\n", nidval);
2086 else if (!strcmp(
"fattr", val))
2087 {n = snprintf(bp, bleft,
"%s\n",
usxParms);
2088 bp += n; bleft -= n;
2090 else {n = strlen(val);
2091 if (bleft <= n)
break;
2092 strcpy(bp, val); bp +=n; *bp =
'\n'; bp++;
2095 }
while(bleft > 0 && (val = qcargs.GetToken()));
2114 bool isCMSD = (*val ==
'c');
2139int XrdXrootdProtocol::do_Qfh()
2144 const char *fArg = 0, *qType =
"";
2156 "query does not refer to an open file");
2176 "Required query argument not present");
2181 TRACEP(FS,
"fh=" <<fh.handle <<
" query " <<qType <<
" rc=" <<rc);
2194int XrdXrootdProtocol::do_Qopaque(
short qopt)
2199 const char *Act, *AData;
2207 myData.Arg2 = 0; myData.
Arg2Len = 0;
2209 Act =
" qopaque '"; AData =
"...";
2224 myData.Arg2 = opaque;
2227 Act =
" qopaquf '"; AData =
argp->
buff;
2236 TRACEP(FS,
"rc=" <<rc <<Act <<AData <<
"'");
2238 return fsError(rc, 0, myError, 0, 0);
2245int XrdXrootdProtocol::do_Qspace()
2266 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2281int XrdXrootdProtocol::do_Query()
2298 case kXR_QPrep:
return do_Prepare(
true);
2305 "Invalid information query type code");
2312int XrdXrootdProtocol::do_Qxattr()
2334 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2348int XrdXrootdProtocol::do_Read()
2359 else if (do_ReadNone(retc, pathID))
return retc;
2370 "read does not refer to an open file");
2374 TRACEP(FSIO, pathID <<
" fh=" <<fh.handle <<
" read " <<
IO.
IOLen
2377 "Read length is negative");
2402 if (!pathID) pP =
this;
2403 else {
if (!(pP =
VerifyStream(retc, pathID,
false)))
return retc;
2418 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_ReadAll, pathID);
2422 return do_ReadAll();
2433int XrdXrootdProtocol::do_ReadAll()
2468 {
if ((rc = getBuff(1, Quantum)) <= 0)
return rc;}
2479 IO.Offset += xframt;
IO.
IOLen -= xframt;
2493int XrdXrootdProtocol::do_ReadNone(
int &retc,
int &pathID)
2502 pathID =
static_cast<int>(rargs->
pathid);
2503 if ((ralsz -=
sizeof(
read_args)) <= 0)
return 0;
2522 "preread does not refer to an open file");
2540int XrdXrootdProtocol::do_ReadV()
2554 int rdVBeg, rdVBreak, rdVNow, rdVNum, rdVecNum;
2555 int currFH, i, k, Quantum, Qleft, rdVecLen =
Request.header.dlen;
2557 int ioMon = (rvMon > 1);
2558 char *buffp, vType = (ioMon ? XROOTD_MON_READU : XROOTD_MON_READV);
2563 rdVecNum = rdVecLen / sizeof(readahead_list);
2564 if ( (rdVecNum <= 0) || (rdVecNum*hdrSZ != rdVecLen) )
2565 return Response.Send(kXR_ArgInvalid, "Read vector is invalid");
2571 if (rdVecNum > XrdProto::maxRvecsz)
2572 return
Response.
Send(kXR_ArgTooLong, "Read vector is too long");
2582 raVec = (readahead_list *)
argp->buff;
2584 for (i = 0; i < rdVecNum; i++)
2585 {totSZ += (rdVec[i].size = ntohl(raVec[i].rlen));
2586 if (rdVec[i].size < 0) return Response.Send(kXR_ArgInvalid,
2587 "Readv length is negative");
2588 if (rdVec[i].size > Quantum) return Response.Send(kXR_NoMemory,
2589 "Single readv transfer is too large");
2590 rdVec[i].offset = ntohll(raVec[i].offset);
2591 memcpy(&rdVec[i].info, raVec[i].fhandle, sizeof(int));
2596 rdVec[i].offset = -1;
2599 rdVBreak = rdVecNum;
2604 if (totSZ > 0x7fffffffLL)
2605 return
Response.
Send(kXR_NoMemory, "Total readv transfer is too large");
2614 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->bsize)
2615 {
if ((k = getBuff(1, Quantum)) <= 0)
return k;}
2622 "readv does not refer to an open file");
2627 currFH = rdVec[0].info;
2628 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2630 "readv does not refer to an open file");
2635 rdVBeg = rdVNow = 0; rdVXfr = rdVAmt = 0;
2639 for (i = 0; i < rdVecNum; i++)
2640 {
if (rdVec[i].info != currFH)
2642 if (xfrSZ != rdVAmt)
break;
2643 rdVNum = i - rdVBeg; rdVXfr += rdVAmt;
2647 htons(rdVNum),
rvSeq, vType);
2648 if (ioMon)
for (k = rdVBeg; k < i; k++)
2650 htonl(rdVec[k].size), htonll(rdVec[k].offset));
2652 rdVXfr = rdVAmt = 0;
2653 if (i == rdVBreak)
break;
2654 rdVBeg = rdVNow = i; currFH = rdVec[i].info;
2655 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2658 "readv does not refer to an open file");
2661 if (Qleft < (rdVec[i].size + hdrSZ))
2664 if (xfrSZ != rdVAmt)
break;
2670 rdVNow = i; rdVXfr += rdVAmt; rdVAmt = 0;
2673 xfrSZ = rdVec[i].size; rdVAmt += xfrSZ;
2674 respHdr.rlen = htonl(xfrSZ);
2675 respHdr.offset = htonll(rdVec[i].offset);
2676 memcpy(buffp, &respHdr, hdrSZ);
2677 rdVec[i].data = buffp + hdrSZ;
2678 buffp += (xfrSZ+hdrSZ); Qleft -= (xfrSZ+hdrSZ);
2679 TRACEP(FSIO,
"fh=" <<currFH<<
" readV "<< xfrSZ <<
'@'<<rdVec[i].offset);
2701int XrdXrootdProtocol::do_Rm()
2731int XrdXrootdProtocol::do_Rmdir()
2761int XrdXrootdProtocol::do_Set()
2768 if (!setargs.GetLine() || !(val = setargs.GetToken(&rest)))
2777 if (!strcmp(
"appid", val))
2778 {
while(*rest && *rest ==
' ') rest++;
2782 else if (!strcmp(
"monitor", val))
return do_Set_Mon(setargs);
2783 else if (!strcmp(
"cache", val))
return do_Set_Cache(setargs);
2800 char *cmd, *cargs, *opaque;
2801 const char *myArgs[2];
2810 if (!(cmd = setargs.
GetToken(&cargs)))
2815 if (cargs && *cargs ==
'/')
2816 {
if (rpCheck(cargs, &opaque))
return rpEmsg(
"Setting", cargs);
2817 if (!Squash(cargs))
return vpEmsg(
"Setting", cargs);
2818 myData.ArgP = myArgs; myData.
Arg2Len = -2;
2822 myData.Arg2 = opaque; myData.
Arg2Len = (opaque ? strlen(opaque) : 0);
2829 TRACEP(FS,
"rc=" <<rc <<
"set cache " <<myData.
Arg1 <<
' ' <<cargs);
2831 return fsError(rc, 0, myError, 0, 0);
2847 if (!(val = setargs.
GetToken(&appid)))
2854 if (!strcmp(val,
"info"))
2856 {
while(*appid && *appid ==
' ') appid++;
2857 if (strlen(appid) > 1024) appid[1024] =
'\0';
2865 if (!strcmp(val,
"on"))
2868 {
while(*appid && *appid ==
' ') appid++;
2877 if (!strcmp(val,
"off"))
2879 {
while(*appid && *appid ==
' ') appid++;
2895int XrdXrootdProtocol::do_Stat()
2901 char *opaque, xxBuff[1024];
2920 "stat does not refer to an open file");
2924 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2947 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2957 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2966int XrdXrootdProtocol::do_Statx()
2970 char *path, *opaque, *respinfo =
argp->
buff;
2981 while((path = pathlist.GetLine()))
2982 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Stating", path);
2983 if (!Squash(path))
return vpEmsg(
"Stating", path);
2985 TRACEP(FS,
"rc=" <<rc <<
" stat " <<path);
2988 else {
if (mode == (mode_t)-1) *respinfo = (char)
kXR_offline;
2989 else if (S_ISDIR(mode)) *respinfo = (
char)
kXR_isDir;
3004int XrdXrootdProtocol::do_Sync()
3039int XrdXrootdProtocol::do_Truncate()
3044 long long theOffset;
3063 "trunc does not refer to an open file");
3069 TRACEP(FS,
"fh=" <<fh.
handle <<
" trunc rc=" <<rc <<
" sz=" <<theOffset);
3090 TRACEP(FS,
"rc=" <<rc <<
" trunc " <<theOffset <<
' ' <<
argp->
buff);
3104int XrdXrootdProtocol::do_Write()
3120 return do_WriteNone(pathID);
3127 "Write length is negative");
3146 {
if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAio,pathID);
3147 return do_WriteAio();
3155 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAll, pathID);
3159 return do_WriteAll();
3170int XrdXrootdProtocol::do_WriteAio()
3180 return do_WriteAll();
3196int XrdXrootdProtocol::do_WriteAll()
3203 {
if ((rc = getBuff(0, Quantum)) <= 0)
return rc;}
3211 {
Resume = &XrdXrootdProtocol::do_WriteCont;
3218 return do_WriteNone();
3220 IO.Offset += Quantum;
IO.
IOLen -= Quantum;
3238int XrdXrootdProtocol::do_WriteCont()
3246 return do_WriteNone();
3252 if (
IO.
IOLen > 0)
return do_WriteAll();
3260int XrdXrootdProtocol::do_WriteNone()
3262 char *buff, dbuff[4096];
3272 blen =
sizeof(dbuff);
3281 if (rlen < 0)
return Link->
setEtext(
"link read error");
3285 Resume = &XrdXrootdProtocol::do_WriteNone;
3293 return do_WriteNoneMsg();
3298int XrdXrootdProtocol::do_WriteNone(
int pathID,
XErrorCode ec,
3306 else do_WriteNoneMsg();
3322 return do_WriteNone();
3329int XrdXrootdProtocol::do_WriteNoneMsg()
3382 return do_WriteNone();
3388 if (
IO.
IOLen > 0)
return do_WriteAll();
3396int XrdXrootdProtocol::do_WriteV()
3409 ~trackInfo() {
if (doit && *wvInfo) {free(*wvInfo); *wvInfo = 0;}}
3414 long long totSZ, maxSZ;
3420 wrVecNum = wrVecLen / wveSZ;
3421 if ( (wrVecLen <= 0) || (wrVecNum*wveSZ != wrVecLen) )
3447 totSZ = 0; maxSZ = 0; k = 0; Quantum =
maxTransz; curFH = 0;
3448 for (
int i = 0; i < wrVecNum; i++)
3449 {
if (wrLst[i].wlen == 0)
continue;
3450 memcpy(&wrVec[k].info, wrLst[i].fhandle,
sizeof(
int));
3451 wrVec[k].
size = ntohl(wrLst[i].wlen);
3452 if (wrVec[k].size < 0)
3456 if (wrVec[k].size > Quantum)
3460 wrVec[k].
offset = ntohll(wrLst[i].offset);
3461 if (wrVec[k].info == curFH) totSZ += wrVec[k].
size;
3462 else {
if (maxSZ < totSZ) maxSZ = totSZ;
3463 totSZ = wrVec[k].
size;
3470 if (maxSZ < totSZ) maxSZ = totSZ;
3481 else Quantum =
static_cast<int>(maxSZ);
3485 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->
bsize)
3486 {
if (getBuff(0, Quantum) <= 0)
return -1;}
3515 freeInfo.doit =
false;
3524int XrdXrootdProtocol::do_WriteVec()
3537 {
if (rc < 0)
return rc;
3539 Resume = &XrdXrootdProtocol::do_WriteVec;
3547 done = newfile =
false;
3567 if (done || newfile)
3584 if (xfrSZ< 0)
break;
3650 for (i = 1; i < sfvnum; i++) xframt += sfvec[i].sendsz;
3651 if (xframt >
IO.
IOLen)
return 1;
3667 else IO.
File->fdNum = fildes;
3677int XrdXrootdProtocol::fsError(
int rc,
char opC,
XrdOucErrInfo &myError,
3678 const char *
Path,
char *Cgi)
3680 int ecode, popt, rs;
3692 return fsOvrld(opC,
Path, Cgi);
3702 if (Cgi) rs = fsRedirNoEnt(
eMsg, Cgi, popt);
3725 <<
eMsg <<
':' <<ecode);
3740 if (ecode <= 0) ecode = 1800;
3745 return (rc ? rc : 1);
3781 sprintf(buff,
"%d", rc);
3793int XrdXrootdProtocol::fsOvrld(
char opC,
const char *
Path,
char *Cgi)
3795 static const char *prot =
"root://";
3796 static int negOne = -1;
3797 static char quest =
'?', slash =
'/';
3799 struct iovec rdrResp[8];
3800 char *destP=0, dest[512];
3801 int iovNum=0, pOff, port;
3809 { rdrResp[1].iov_base = (
char *)&negOne;
3810 rdrResp[1].iov_len =
sizeof(negOne);
3811 rdrResp[2].iov_base = (
char *)prot;
3812 rdrResp[2].iov_len = 7;
3813 rdrResp[3].iov_base = (
char *)dest;
3814 rdrResp[3].iov_len = strlen(dest);
3815 rdrResp[4].iov_base = (
char *)&slash;
3816 rdrResp[4].iov_len = (*
Path ==
'/' ? 1 : 0);
3817 rdrResp[5].iov_base = (
char *)(
Path+pOff);
3818 rdrResp[5].iov_len = strlen(
Path+pOff);
3820 {rdrResp[6].iov_base = (
char *)?
3821 rdrResp[6].iov_len =
sizeof(quest);
3822 rdrResp[7].iov_base = (
char *)Cgi;
3823 rdrResp[7].iov_len = strlen(Cgi);
3863int XrdXrootdProtocol::fsRedirNoEnt(
const char *
eMsg,
char *Cgi,
int popt)
3865 struct iovec ioV[4];
3866 char *tried, *trend, *ptried = 0;
3873 {
do {
if (!(tried = strstr(Cgi,
"tried=")))
break;
3874 if (tried == trend || *(tried-1) ==
'&')
3875 {
if (!ptried || (*(tried+6) && *(tried+6) !=
'&')) ptried=tried;}
3876 Cgi = index(tried+6,
'&');
3883 if ((tried = ptried))
3885 while(*(tried+1) && *(tried+1) ==
',') tried++;
3886 trend = index(tried,
'&');
3887 if (trend) {tlen = trend - tried; *trend = 0;}
3888 else tlen = strlen(tried);
3895 if ((trend = tried) &&
eMsg)
3896 do {
if ((trend = strstr(trend,
myCName)))
3899 trend = index(trend+
myCNlen,
',');
3907 if (!tried || !tlen || tlen > 16384)
3915 ioV[1].iov_base = (
char *)&pnum;
3916 ioV[1].iov_len =
sizeof(pnum);
3919 ioV[3].iov_base = tried;
3920 ioV[3].iov_len = tlen;
3935int XrdXrootdProtocol::getBuff(
const int isRead,
int Quantum)
3954 "insufficient memory to read file" :
3955 "insufficient memory to write file"));
3966char *XrdXrootdProtocol::getCksType(
char *opaque,
char *cspec,
int cslen)
3972 if (opaque && *opaque)
3974 if ((cksT = jobEnv.Get(
"cks.type")))
3976 while(tP && strcasecmp(tP->
text, cksT)) tP = tP->
next;
3977 if (!tP && cspec) snprintf(cspec, cslen,
"%s", cksT);
3978 return (tP ? tP->
text : 0);
3991bool XrdXrootdProtocol::logLogin(
bool xauth)
3993 const char *uName, *ipName, *tMsg, *zMsg =
"";
3994 char lBuff[512], pBuff[512];
4010 if (*tMsg) zMsg =
" ";
4014 snprintf(lBuff,
sizeof(lBuff),
"%s %s %s%slogin%s%s",
4017 (xauth ?
" as " :
""),
4018 (uName ? uName :
""));
4023 {snprintf(pBuff,
sizeof(pBuff),
"via %s auth for %s",
4041 eDest.
Emsg(
"Xeq",
"session requires TLS but",
Link->
ID,
"is incapable.");
4065#define Map_Mode(x,y) if (Mode & kXR_ ## x) newmode |= S_I ## y
4067int XrdXrootdProtocol::mapMode(
int Mode)
4089 const char *bP = Buff;
4092 else {snprintf(Buff,
sizeof(Buff),
4093 "&p=%s&n=%s&h=%s&o=%s&r=%s&g=%s&m=%s%s&I=%c",
4115int XrdXrootdProtocol::rpCheck(
char *fn,
char **opaque)
4124 if (!(cp = index(fn,
'?'))) *opaque = 0;
4125 else {*cp =
'\0'; *opaque = cp+1;
4126 if (!**opaque) *opaque = 0;
4129 if (*fn !=
'/')
return 0;
4131 while ((cp = index(fn,
'/')))
4133 if (fn[0] ==
'.' && fn[1] ==
'.' && fn[2] ==
'/')
return 1;
4142int XrdXrootdProtocol::rpEmsg(
const char *op,
char *fn)
4145 snprintf(buff,
sizeof(buff)-1,
"%s relative path '%s' is disallowed.",op,fn);
4146 buff[
sizeof(buff)-1] =
'\0';
4164 else if (theFile->fdNum >= 0) theFile->
sfEnabled = 1;
4175int XrdXrootdProtocol::Squash(
char *fn)
4177 char *ofn, *ifn = fn;
4184 || (*(ifn+1) ==
'.' && *(ifn+1) && *(ifn+2) ==
'/'))
break;
4191 while(*ifn) {*ofn = *ifn++;
4193 {
while(*ifn ==
'/') ifn++;
4194 if (ifn[0] ==
'.' && ifn[1] ==
'/') ifn += 2;
4208int XrdXrootdProtocol::vpEmsg(
const char *op,
char *fn)
4211 snprintf(buff,
sizeof(buff)-1,
"%s path '%s' is disallowed.",op,fn);
4212 buff[
sizeof(buff)-1] =
'\0';
struct ClientTruncateRequest truncate
#define kXR_ShortProtRespLen
struct ClientCloseRequest close
struct ClientMkdirRequest mkdir
struct ClientAuthRequest auth
#define kXR_PROTSIGNVERSION
struct ClientDirlistRequest dirlist
struct ClientOpenRequest open
struct ClientRequestHdr header
struct ClientWriteVRequest writev
struct ClientLoginRequest login
struct ClientChmodRequest chmod
struct ClientQueryRequest query
struct ClientReadRequest read
struct ClientMvRequest mv
struct ClientBindRequest bind
#define kXR_PROTOCOLVERSION
struct ClientEndsessRequest endsess
struct ClientSyncRequest sync
struct ClientPrepareRequest prepare
struct ClientStatRequest stat
struct ClientWriteRequest write
ServerResponseReqs_Protocol secreq
struct ClientProtocolRequest protocol
struct ClientLocateRequest locate
int emsg(int rc, char *msg)
const char * Arg1
PLUGINO, PLUGION, PLUGXC.
int Arg2Len
Length or -count of args in extension.
char * notify
Notification path or 0.
XrdOucTList * paths
List of paths.
XrdOucTList * oinfo
1-to-1 correspondence of opaque info
long long XrdSfsFileOffset
< SFS_FSCTL_PLUGIN/PLUGIO/PLUGXC parms
const char * XrdSysE2T(int errcode)
XrdOucString * XrdXrootdCF
const kXR_char XROOTD_MON_OPENW
const kXR_char XROOTD_MON_STAT
const kXR_char XROOTD_MON_REDLOCAL
const kXR_char XROOTD_MON_PREP
const kXR_char XROOTD_MON_OPENC
const kXR_char XROOTD_MON_TRUNC
const kXR_char XROOTD_MON_CLOSE
const kXR_char XROOTD_MON_CHMOD
const kXR_char XROOTD_MON_LOCATE
const kXR_char XROOTD_MON_OPENR
const kXR_char XROOTD_MON_MV
const kXR_char XROOTD_MON_RMDIR
const kXR_char XROOTD_MON_RM
const kXR_char XROOTD_MON_OPENDIR
const kXR_char XROOTD_MON_QUERY
const kXR_char XROOTD_MON_MKDIR
XrdSysTrace XrdXrootdTrace
#define STATIC_REDIRECT(xfnc)
static const char * errName(kXR_int32 errCode)
static int mapError(int rc)
void Release(XrdBuffer *bp)
XrdBuffer * Obtain(int bsz)
static const int ValuSize
static const int NameSize
static bool GetAssumeV4()
static XrdLink * fd2link(int fd)
void Serialize()
Wait for all outstanding requests to be completed on the link.
int setEtext(const char *text)
bool setTLS(bool enable, XrdTlsContext *ctx=0)
Enable or disable TLS on the link.
int Recv(char *buff, int blen)
int Terminate(const char *owner, int fdnum, unsigned int inst)
void setID(const char *userid, int procid)
XrdNetAddrInfo * AddrInfo()
char * ID
Pointer to the client's link identity.
void setProtName(const char *name)
void setLocation(XrdNetAddrInfo::LocInfo &loc)
XrdProtocol * getProtocol()
Obtain current protocol object pointer.
const char * Host() const
unsigned int Inst() const
bool isIPType(IPType ipType) const
bool getEA(int &ec, int &ac)
static bool getEA(const char *cgi, int &ecode, int &acode)
virtual Handle * Begin(XrdSecEntity &Client, const char *path=0, const char *cgi=0, const char *app=0)=0
virtual void Done(int &Result, XrdOucErrInfo *eInfo, const char *Path=0)=0
void setErrCB(XrdOucEICB *cb, unsigned long long cbarg=0)
const char * getErrText()
int setErrInfo(int code, const char *emsg)
void setUCap(int ucval)
Set user capabilties.
void Reset()
Reset object to no message state. Call this method to release appendages.
char * ID(char *buff, int blen)
char * isMine(char *reqid, int &hport, char *hname, int hlen)
const char * c_str() const
char * GetToken(char **rest=0, int lowcase=0)
static void Sanitize(char *instr, char subc='_')
static int isFWD(const char *path, int *port=0, char *hBuff=0, int hBLen=0, bool pTrim=false)
void Schedule(XrdJob *jp)
bool Add(XrdSecAttr &attr)
XrdSecAttr * Get(const void *sigkey)
char * vorg
Entity's virtual organization(s)
const char * pident
Trace identifier (originator)
XrdNetAddrInfo * addrInfo
Entity's connection details.
XrdSecEntityAttr * eaAPI
non-const API to attributes
const char * tident
Trace identifier always preset.
char prot[XrdSecPROTOIDSIZE]
Auth protocol used (e.g. krb5)
XrdSecMonitor * secMon
If !0 security monitoring enabled.
char * grps
Entity's group name(s)
char * name
Entity's name.
unsigned int ueid
Unique ID of entity instance.
char * role
Entity's role(s)
void Display(XrdSysError &mDest)
char * moninfo
Information for monitoring.
char * host
Entity's host name dnr dependent.
virtual XrdSecProtect * New4Server(XrdSecProtocol &aprot, int plvl)
virtual int ProtResp(ServerResponseReqs_Protocol &resp, XrdNetAddrInfo &nai, int pver)
virtual void Delete()=0
Delete the protocol object. DO NOT use C++ delete() on this object.
virtual int Authenticate(XrdSecCredentials *cred, XrdSecParameters **parms, XrdOucErrInfo *einfo=0)=0
virtual XrdSecProtocol * getProtocol(const char *host, XrdNetAddrInfo &endPoint, const XrdSecCredentials *cred, XrdOucErrInfo &einfo)=0
virtual bool PostProcess(XrdSecEntity &entity, XrdOucErrInfo &einfo)
virtual const char * getParms(int &size, XrdNetAddrInfo *endPoint=0)=0
virtual int autoStat(struct stat *buf)
virtual int open(const char *path, const XrdSecEntity *client=0, const char *opaque=0)=0
virtual const char * nextEntry()=0
virtual void Connect(const XrdSecEntity *client=0)
virtual int chmod(const char *path, XrdSfsMode mode, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0, const char *opaque=0)=0
virtual int fsctl(const int cmd, const char *args, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0)=0
virtual int rename(const char *oPath, const char *nPath, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0, const char *opaqueO=0, const char *opaqueN=0)=0
virtual int mkdir(const char *path, XrdSfsMode mode, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0, const char *opaque=0)=0
virtual int FSctl(const int cmd, XrdSfsFSctl &args, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0)
virtual XrdSfsFile * newFile(char *user=0, int MonID=0)=0
virtual int truncate(const char *path, XrdSfsFileOffset fsize, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0, const char *opaque=0)=0
virtual int chksum(csFunc Func, const char *csName, const char *path, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0, const char *opaque=0)
virtual int remdir(const char *path, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0, const char *opaque=0)=0
virtual int prepare(XrdSfsPrep &pargs, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0)=0
virtual int stat(const char *Name, struct stat *buf, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0, const char *opaque=0)=0
virtual int rem(const char *path, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0, const char *opaque=0)=0
virtual XrdSfsDirectory * newDir(char *user=0, int MonID=0)=0
virtual XrdSfsXferSize writev(XrdOucIOVec *writeV, int wdvCnt)
virtual int SendData(XrdSfsDio *sfDio, XrdSfsFileOffset offset, XrdSfsXferSize size)
virtual int open(const char *fileName, XrdSfsFileOpenMode openMode, mode_t createMode, const XrdSecEntity *client=0, const char *opaque=0)=0
virtual XrdSfsXferSize read(XrdSfsFileOffset offset, XrdSfsXferSize size)=0
virtual XrdSfsXferSize readv(XrdOucIOVec *readV, int rdvCnt)
virtual int truncate(XrdSfsFileOffset fsize)=0
virtual int getCXinfo(char cxtype[4], int &cxrsz)=0
virtual int stat(struct stat *buf)=0
virtual void setXio(XrdSfsXio *xioP)
virtual int fctl(const int cmd, const char *args, XrdOucErrInfo &eInfo)=0
virtual XrdSfsXferSize write(XrdSfsFileOffset offset, const char *buffer, XrdSfsXferSize size)=0
int Emsg(const char *esfx, int ecode, const char *text1, const char *text2=0)
void Log(int mask, const char *esfx, const char *text1, const char *text2=0, const char *text3=0)
static void Snooze(int seconds)
virtual void numLocks(const char *path, int &rcnt, int &wcnt)=0
virtual int Unlock(const char *path, char mode)=0
virtual int Lock(const char *path, char mode, bool force)=0
void rvOps(int rsz, int ssz)
void wvOps(int wsz, int ssz)
int Add(XrdXrootdFile *fp)
XrdXrootdFile * Get(int fnum)
XrdXrootdFile * Del(XrdXrootdMonitor *monP, int fnum, bool dodel=true)
int Schedule(const char *jkey, const char **args, XrdXrootdResponse *resp, int Opts=0)
int Cancel(const char *jkey=0, XrdXrootdResponse *resp=0)
static void Open(XrdXrootdFileStats *fsP, const char *Path, unsigned int uDID, bool isRW)
kXR_unt32 MapInfo(const char *Info)
kXR_unt32 MapPath(const char *Path)
void Register(const char *Uname, const char *Hname, const char *Pname, unsigned int xSID=0)
void Report(const char *Info)
void Add_rv(kXR_unt32 dictid, kXR_int32 rlen, kXR_int16 vcnt, kXR_char vseq, kXR_char vtype)
void Add_rd(kXR_unt32 dictid, kXR_int32 rlen, kXR_int64 offset)
void Add_wr(kXR_unt32 dictid, kXR_int32 wlen, kXR_int64 offset)
void Open(kXR_unt32 dictid, off_t fsize)
int Write(long long offs, int dlen) override
void Read(long long offs, int dlen) override
static XrdXrootdNormAio * Alloc(XrdXrootdProtocol *protP, XrdXrootdResponse &resp, XrdXrootdFile *fP)
int(XrdXrootdProtocol::* ResumePio)()
static XrdXrootdPio * Alloc(int n=1)
void Set(int(XrdXrootdProtocol::*Invoke)(), XrdXrootd::IOParms &io, const kXR_char *theSID)
static int List(XrdXrootdPrepArgs &pargs, char *resp, int resplen)
static void Log(XrdXrootdPrepArgs &pargs)
static void Logdel(char *reqid)
static XrdXrootdStats * SI
int SendFile(int fildes) override
XrdXrootdProtocol * VerifyStream(int &rc, int pID, bool lok=true)
static XrdSfsFileSystem * digFS
int SetSF(kXR_char *fhandle, bool seton=false)
XrdNetPMark::Handle * pmHandle
static XrdNetPMark * PMark
XrdXrootdProtocol * Stream[maxStreams]
static XrdXrootdXPath RPList
static const char Req_TLSGPFile
void SetFD(int fildes) override
static const char Req_TLSSess
XrdXrootdFileTable * FTab
static XrdXrootdJob * JobCKS
static XrdSysError & eDest
static unsigned int getSID()
XrdSecProtocol * AuthProt
int getData(gdCallBack *gdcbP, const char *dtype, char *buff, int blen)
XrdXrootdMonitor::User Monitor
static const char * myCName
static const char Req_TLSData
static XrdXrootdFileLock * Locker
int(XrdXrootdProtocol::* Resume)()
static const char Req_TLSTPC
static XrdTlsContext * tlsCtx
static XrdXrootdXPath XPList
static const char Req_TLSLogin
XrdXrootdResponse Response
int(XrdXrootdProtocol::* ResumePio)()
static const int maxStreams
static XrdOucTList * JobCKTLST
static XrdXrootdXPath RQList
static XrdSecProtector * DHS
static XrdBuffManager * BPool
static XrdSecService * CIA
static RAtomic_int srvrAioOps
static uint64_t fsFeatures
static XrdOucReqID * PrepID
static struct XrdXrootdProtocol::RD_Table Route[RD_Num]
static XrdSfsFileSystem * osFS
void setID(unsigned long long id)
unsigned long long getID()
int Stats(char *buff, int blen, int do_sync=0)
int Validate(const char *pd, const int pl=0)
static const int maxRvecsz
static const int maxWvecsz
static const uint64_t hasCACH
Feature: Implements a data cache.
static const uint64_t hasSXIO
Feature: Supports SfsXio.
ssize_t Send(int fd, KernelBuffer &buffer)
static const kXR_int32 doSync
char TimeZone
+/- hours from GMT (-128 if not set)
unsigned char Country[2]
Two letter TLD country code.
static const int uRedirFlgs
ucap: Client supports "file://"
static const int uUrlOK
ucap: Supports async responses
static const int uIPv64
ucap: Supports only IPv4 info
static const int uReadR
ucap: Supports multiple protocols
static const int uEcRedir
ucap: Client supports redirect flags
static const int uMProt
ucap: Supports url redirects
static const int uLclF
ucap: Client is on a private net
static const int uAsync
ucap: Extract protocol version
static const int uIPv4
ucap: Supports read redirects
Generic structure to pass security information back and forth.
char * buffer
Pointer to the buffer.
int size
Size of the buffer or length of data in the buffer.
static const int useBasic