72 #include "XrdVersion.hh"
75 #define ENODATA ENOATTR
79 #define ETIME ETIMEDOUT
108 static const int op_isOpen = 0x00010000;
109 static const int op_isRead = 0x00020000;
111 const char *getTime()
113 static char buff[16];
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));
155 static const char *startUP = getTime();
162 int 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);
245 int XrdXrootdProtocol::do_Bind()
251 char buff[64], *cp, *dp;
298 if (strcmp(
Link->
Host(), lp->Host()))
310 for (i = 1; i <
maxStreams && pp->Stream[i]; i++) {}
318 pp->Stream[i] =
this;
325 if ( (dp = rindex(cp,
'@'))) *dp =
'\0';
326 if (!(dp = rindex(cp,
'.'))) pPid = 0;
327 else {*dp++ =
'\0'; pPid = strtol(dp, (
char **)NULL, 10);}
339 *(pp->pmHandle),
Link->
ID);
345 sprintf(buff,
"FD %d#%d bound",
Link->
FDnum(), i);
354 buff[0] =
static_cast<char>(i);
373 int XrdXrootdProtocol::do_Chmod()
404 int 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());
481 int 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);
520 int 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);
604 int 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);}
806 int 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) <<
")");
861 int XrdXrootdProtocol::do_gpFile()
882 int 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);
947 int 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);
1134 int XrdXrootdProtocol::do_Mkdir()
1167 int 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);
1220 int XrdXrootdProtocol::do_Offload(
int (
XrdXrootdProtocol::*Invoke)(),
int pathID)
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);
1273 pioP->
Set(Invoke,
IO, streamID);
1286 int 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);
1370 int 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';
1433 {openopts |=
SFS_O_RAWIO; *op++ =
'c'; compchk = 1;}
1436 {*op++ =
'a'; isAsync =
true;}
1448 {
char* cgiP = index(fn,
'?');
1449 if (cgiP) *cgiP = 0;
1450 TRACEP(FS,
"open " <<opt <<
' ' <<fn);
1451 if (cgiP) *cgiP =
'?';
1456 if (rpCheck(fn, &opaque))
return rpEmsg(
"Opening", fn);
1466 if (!(popt = Squash(fn)))
return vpEmsg(
"Opening", fn);
1478 OpenHelper oHelp(
Locker, fn);
1485 if (rc > 0) who = (rc > 1 ?
"readers" :
"reader");
1487 who = (rc > 1 ?
"writers" :
"writer");
1489 snprintf(ebuff,
sizeof(ebuff)-1,
1490 "%s file %s is already opened by %d %s; open denied.",
1491 (
'r' ==
usage ?
"Input" :
"Output"), fn, rc, who);
1494 }
else oHelp.mode =
usage;
1505 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s",fn);
1524 (mode_t)mode,
CRED, opaque)))
1525 {rc = fsError(rc, opC, fp->
error, fn, opaque);
return rc;}
1531 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1549 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1563 if ((
'r' ==
usage && wrtrs) || (
'w' ==
usage && rdrs) || wrtrs > 1)
1564 {snprintf(ebuff,
sizeof(ebuff)-1,
1565 "%s file %s forced opened with %d reader(s) and %d writer(s).",
1566 (
'r' ==
usage ?
"Input" :
"Output"), fn, rdrs, wrtrs);
1573 memset(&myResp, 0,
sizeof(myResp));
1574 if (!compchk) resplen =
sizeof(myResp.fhandle);
1576 fp->
getCXinfo((
char *)myResp.cptype, cpsize);
1577 myResp.cpsize =
static_cast<kXR_int32>(htonl(cpsize));
1578 resplen =
sizeof(myResp);
1584 {retStat = StatGen(statbuf, ebuff,
sizeof(ebuff));
1585 IOResp[1].iov_base = (
char *)&myResp; IOResp[1].iov_len =
sizeof(myResp);
1586 IOResp[2].iov_base = ebuff; IOResp[2].iov_len = retStat;
1587 resplen =
sizeof(myResp) + retStat;
1606 memcpy((
void *)myResp.fhandle,(
const void *)&fhandle,
sizeof(myResp.fhandle));
1646 int XrdXrootdProtocol::do_Ping()
1662 int XrdXrootdProtocol::do_Prepare(
bool isQuery)
1675 int rc, pathnum = 0;
1676 char reqid[128], nidbuff[512], *path, *opaque, *prpid = 0;
1679 bool isCancel, isEvict, isPrepare;
1699 isPrepare = !(isCancel || isQuery);
1706 "Surpassed this connection's prepare limit.");
1724 if (isCancel || isQuery)
1725 {
if (!(prpid = pathlist.GetLine()))
1727 fsprep.
reqid = prpid;
1732 prpid =
PrepID->
isMine(prpid, hport, hname,
sizeof(hname));
1735 "Prepare requestid owned by an unknown server");
1737 << hname <<
':' <<hport);
1743 {prpid =
PrepID->
ID(reqid,
sizeof(reqid));
1744 fsprep.
reqid = reqid;
1747 reqid[0]=
'*'; reqid[1]=
'\0';
1748 fsprep.
reqid = prpid = reqid;
1761 while((path = pathlist.GetLine()))
1762 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Preparing", path);
1763 if (!Squash(path))
return vpEmsg(
"Preparing", path);
1765 (pLast ? (pLast->next = pP) : (pFirst = pP)); pLast = pP;
1767 (oLast ? (oLast->next = oP) : (oFirst = oP)); oLast = oP;
1770 fsprep.
paths = pFirst;
1771 fsprep.
oinfo = oFirst;
1795 char *mBuff = myError.getMsgBuff(rc);
1796 pargs.reqid = prpid;
1798 pargs.paths = pFirst;
1800 if (rc < 0) rc =
Response.
Send(
"No information found.");
1828 else snprintf(nidbuff,
sizeof(nidbuff),
"%s://%s:%d/",
1862 {pargs.reqid = prpid;
1864 pargs.paths = pFirst;
1881 int XrdXrootdProtocol::do_Protocol()
1892 bool wantTLS =
false;
1917 ioVec[iovN ].iov_base = (
void *)&theResp.
secreq;
1918 ioVec[iovN++].iov_len = n;
1944 theResp.
flags = (wantTLS ? theRlt : theRle);
1946 theResp.
flags = theRlf;
1952 theResp.
pval = verNum;
1960 if (rc == 0 && wantTLS)
1976 int XrdXrootdProtocol::do_Qconf()
1980 char *val, buff[4096], *bp=buff;
1981 int n, bleft =
sizeof(buff);
1985 if (!qcargs.GetLine() || !(val = qcargs.GetToken()))
1990 if (!strcmp(val,
"cmsd") || !strcmp(val,
"xrootd"))
1991 return do_QconfCX(qcargs, val);
1999 if (!strcmp(
"bind_max", val))
2000 {n = snprintf(bp, bleft,
"%d\n",
maxStreams-1);
2001 bp += n; bleft -= n;
2003 else if (!strcmp(
"chksum", val))
2004 {
const char *csList = getenv(
"XRD_CSLIST");
2006 {n = snprintf(bp, bleft,
"chksum\n");
2007 bp += n; bleft -= n;
2010 n = snprintf(bp, bleft,
"%s\n", csList);
2011 bp += n; bleft -= n;
2013 else if (!strcmp(
"cid", val))
2014 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2015 if (!cidval || !(*cidval)) cidval =
"cid";
2016 n = snprintf(bp, bleft,
"%s\n", cidval);
2017 bp += n; bleft -= n;
2019 else if (!strcmp(
"cms", val))
2022 n = snprintf(bp, bleft,
"%s\n", myError.getErrText());
2023 else n = snprintf(bp, bleft,
"%s\n",
"cms");
2024 bp += n; bleft -= n;
2026 else if (!strcmp(
"pio_max", val))
2027 {n = snprintf(bp, bleft,
"%d\n",
maxPio+1);
2028 bp += n; bleft -= n;
2030 else if (!strcmp(
"proxy", val))
2031 {
const char* pxyOrigin =
"proxy";
2033 {pxyOrigin = getenv(
"XRDXROOTD_PROXY");
2034 if (!pxyOrigin) pxyOrigin =
"proxy";
2036 n = snprintf(bp,bleft,
"%s\n",pxyOrigin);
2037 bp += n; bleft -= n;
2039 else if (!strcmp(
"readv_ior_max", val))
2041 bp += n; bleft -= n;
2043 else if (!strcmp(
"readv_iov_max", val))
2045 bp += n; bleft -= n;
2047 else if (!strcmp(
"role", val))
2048 {
const char *theRole = getenv(
"XRDROLE");
2049 n = snprintf(bp, bleft,
"%s\n", (theRole ? theRole :
"none"));
2050 bp += n; bleft -= n;
2052 else if (!strcmp(
"sitename", val))
2053 {
const char *siteName = getenv(
"XRDSITE");
2054 n = snprintf(bp, bleft,
"%s\n", (siteName ? siteName :
"sitename"));
2055 bp += n; bleft -= n;
2057 else if (!strcmp(
"start", val))
2058 {n = snprintf(bp, bleft,
"%s\n", startUP);
2059 bp += n; bleft -= n;
2061 else if (!strcmp(
"sysid", val))
2062 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2063 const char *nidval = getenv(
"XRDCMSVNID");
2064 if (!cidval || !(*cidval) || !nidval || !(*nidval))
2065 {cidval =
"sysid"; nidval =
"";}
2066 n = snprintf(bp, bleft,
"%s %s\n", nidval, cidval);
2067 bp += n; bleft -= n;
2069 else if (!strcmp(
"tpc", val))
2070 {
char *tpcval = getenv(
"XRDTPC");
2071 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpc"));
2072 bp += n; bleft -= n;
2074 else if (!strcmp(
"tpcdlg", val))
2075 {
char *tpcval = getenv(
"XRDTPCDLG");
2076 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpcdlg"));
2077 bp += n; bleft -= n;
2079 else if (!strcmp(
"tls_port", val) &&
tlsPort)
2080 {n = snprintf(bp, bleft,
"%d\n",
tlsPort);
2081 bp += n; bleft -= n;
2083 else if (!strcmp(
"window", val) &&
Window)
2084 {n = snprintf(bp, bleft,
"%d\n",
Window);
2085 bp += n; bleft -= n;
2087 else if (!strcmp(
"version", val))
2088 {n = snprintf(bp, bleft,
"%s\n", XrdVSTRING);
2089 bp += n; bleft -= n;
2091 else if (!strcmp(
"vnid", val))
2092 {
const char *nidval = getenv(
"XRDCMSVNID");
2093 if (!nidval || !(*nidval)) nidval =
"vnid";
2094 n = snprintf(bp, bleft,
"%s\n", nidval);
2096 else if (!strcmp(
"fattr", val))
2097 {n = snprintf(bp, bleft,
"%s\n",
usxParms);
2098 bp += n; bleft -= n;
2100 else {n = strlen(val);
2101 if (bleft <= n)
break;
2102 strcpy(bp, val); bp +=n; *bp =
'\n'; bp++;
2105 }
while(bleft > 0 && (val = qcargs.GetToken()));
2124 bool isCMSD = (*val ==
'c');
2149 int XrdXrootdProtocol::do_Qfh()
2154 const char *fArg = 0, *qType =
"";
2166 "query does not refer to an open file");
2186 "Required query argument not present");
2191 TRACEP(FS,
"fh=" <<fh.handle <<
" query " <<qType <<
" rc=" <<rc);
2204 int XrdXrootdProtocol::do_Qopaque(
short qopt)
2209 const char *Act, *AData;
2217 myData.Arg2 = 0; myData.
Arg2Len = 0;
2219 Act =
" qopaque '"; AData =
"...";
2234 myData.Arg2 = opaque;
2237 Act =
" qopaquf '"; AData =
argp->
buff;
2246 TRACEP(FS,
"rc=" <<rc <<Act <<AData <<
"'");
2248 return fsError(rc, 0, myError, 0, 0);
2255 int XrdXrootdProtocol::do_Qspace()
2276 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2291 int XrdXrootdProtocol::do_Query()
2308 case kXR_QPrep:
return do_Prepare(
true);
2315 "Invalid information query type code");
2322 int XrdXrootdProtocol::do_Qxattr()
2344 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2358 int XrdXrootdProtocol::do_Read()
2369 else if (do_ReadNone(retc, pathID))
return retc;
2380 "read does not refer to an open file");
2384 TRACEP(FSIO, pathID <<
" fh=" <<fh.handle <<
" read " <<
IO.
IOLen
2387 "Read length is negative");
2412 if (!pathID) pP =
this;
2413 else {
if (!(pP =
VerifyStream(retc, pathID,
false)))
return retc;
2428 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_ReadAll, pathID);
2432 return do_ReadAll();
2443 int XrdXrootdProtocol::do_ReadAll()
2478 {
if ((rc = getBuff(1, Quantum)) <= 0)
return rc;}
2489 IO.Offset += xframt;
IO.
IOLen -= xframt;
2503 int XrdXrootdProtocol::do_ReadNone(
int &retc,
int &pathID)
2512 pathID =
static_cast<int>(rargs->
pathid);
2513 if ((ralsz -=
sizeof(
read_args)) <= 0)
return 0;
2532 "preread does not refer to an open file");
2550 int XrdXrootdProtocol::do_ReadV()
2564 int rdVBeg, rdVBreak, rdVNow, rdVNum, rdVecNum;
2565 int currFH, i, k, Quantum, Qleft, rdVecLen =
Request.header.dlen;
2567 int ioMon = (rvMon > 1);
2568 char *buffp, vType = (ioMon ? XROOTD_MON_READU : XROOTD_MON_READV);
2573 rdVecNum = rdVecLen / sizeof(readahead_list);
2574 if ( (rdVecNum <= 0) || (rdVecNum*hdrSZ != rdVecLen) )
2575 return Response.Send(kXR_ArgInvalid, "Read vector is invalid");
2581 if (rdVecNum > XrdProto::maxRvecsz)
2582 return
Response.
Send(kXR_ArgTooLong, "Read vector is too long");
2592 raVec = (readahead_list *)
argp->buff;
2594 for (i = 0; i < rdVecNum; i++)
2595 {totSZ += (rdVec[i].size = ntohl(raVec[i].rlen));
2596 if (rdVec[i].size < 0) return Response.Send(kXR_ArgInvalid,
2597 "Readv length is negative");
2598 if (rdVec[i].size > Quantum) return Response.Send(kXR_NoMemory,
2599 "Single readv transfer is too large");
2600 rdVec[i].offset = ntohll(raVec[i].offset);
2601 memcpy(&rdVec[i].info, raVec[i].fhandle, sizeof(int));
2606 rdVec[i].offset = -1;
2609 rdVBreak = rdVecNum;
2614 if (totSZ > 0x7fffffffLL)
2615 return
Response.
Send(kXR_NoMemory, "Total readv transfer is too large");
2624 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->bsize)
2625 {
if ((k = getBuff(1, Quantum)) <= 0)
return k;}
2632 "readv does not refer to an open file");
2637 currFH = rdVec[0].info;
2638 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2640 "readv does not refer to an open file");
2645 rdVBeg = rdVNow = 0; rdVXfr = rdVAmt = 0;
2649 for (i = 0; i < rdVecNum; i++)
2650 {
if (rdVec[i].info != currFH)
2652 if (xfrSZ != rdVAmt)
break;
2653 rdVNum = i - rdVBeg; rdVXfr += rdVAmt;
2657 htons(rdVNum),
rvSeq, vType);
2658 if (ioMon)
for (k = rdVBeg; k < i; k++)
2660 htonl(rdVec[k].size), htonll(rdVec[k].offset));
2662 rdVXfr = rdVAmt = 0;
2663 if (i == rdVBreak)
break;
2664 rdVBeg = rdVNow = i; currFH = rdVec[i].info;
2665 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2668 "readv does not refer to an open file");
2671 if (Qleft < (rdVec[i].size + hdrSZ))
2674 if (xfrSZ != rdVAmt)
break;
2680 rdVNow = i; rdVXfr += rdVAmt; rdVAmt = 0;
2683 xfrSZ = rdVec[i].size; rdVAmt += xfrSZ;
2684 respHdr.rlen = htonl(xfrSZ);
2685 respHdr.offset = htonll(rdVec[i].offset);
2686 memcpy(buffp, &respHdr, hdrSZ);
2687 rdVec[i].data = buffp + hdrSZ;
2688 buffp += (xfrSZ+hdrSZ); Qleft -= (xfrSZ+hdrSZ);
2689 TRACEP(FSIO,
"fh=" <<currFH<<
" readV "<< xfrSZ <<
'@'<<rdVec[i].offset);
2711 int XrdXrootdProtocol::do_Rm()
2741 int XrdXrootdProtocol::do_Rmdir()
2771 int XrdXrootdProtocol::do_Set()
2778 if (!setargs.GetLine() || !(val = setargs.GetToken(&rest)))
2787 if (!strcmp(
"appid", val))
2788 {
while(*rest && *rest ==
' ') rest++;
2792 else if (!strcmp(
"monitor", val))
return do_Set_Mon(setargs);
2793 else if (!strcmp(
"cache", val))
return do_Set_Cache(setargs);
2810 char *cmd, *cargs, *opaque;
2811 const char *myArgs[2];
2820 if (!(cmd = setargs.
GetToken(&cargs)))
2825 if (cargs && *cargs ==
'/')
2826 {
if (rpCheck(cargs, &opaque))
return rpEmsg(
"Setting", cargs);
2827 if (!Squash(cargs))
return vpEmsg(
"Setting", cargs);
2828 myData.ArgP = myArgs; myData.
Arg2Len = -2;
2832 myData.Arg2 = opaque; myData.
Arg2Len = (opaque ? strlen(opaque) : 0);
2839 TRACEP(FS,
"rc=" <<rc <<
"set cache " <<myData.
Arg1 <<
' ' <<cargs);
2841 return fsError(rc, 0, myError, 0, 0);
2857 if (!(val = setargs.
GetToken(&appid)))
2864 if (!strcmp(val,
"info"))
2866 {
while(*appid && *appid ==
' ') appid++;
2867 if (strlen(appid) > 1024) appid[1024] =
'\0';
2875 if (!strcmp(val,
"on"))
2878 {
while(*appid && *appid ==
' ') appid++;
2887 if (!strcmp(val,
"off"))
2889 {
while(*appid && *appid ==
' ') appid++;
2905 int XrdXrootdProtocol::do_Stat()
2911 char *opaque, xxBuff[1024];
2930 "stat does not refer to an open file");
2934 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2957 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2967 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2976 int XrdXrootdProtocol::do_Statx()
2980 char *path, *opaque, *respinfo =
argp->
buff;
2991 while((path = pathlist.GetLine()))
2992 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Stating", path);
2993 if (!Squash(path))
return vpEmsg(
"Stating", path);
2995 TRACEP(FS,
"rc=" <<rc <<
" stat " <<path);
2998 else {
if (mode == (mode_t)-1) *respinfo = (char)
kXR_offline;
2999 else if (S_ISDIR(mode)) *respinfo = (
char)
kXR_isDir;
3014 int XrdXrootdProtocol::do_Sync()
3049 int XrdXrootdProtocol::do_Truncate()
3054 long long theOffset;
3073 "trunc does not refer to an open file");
3079 TRACEP(FS,
"fh=" <<fh.
handle <<
" trunc rc=" <<rc <<
" sz=" <<theOffset);
3100 TRACEP(FS,
"rc=" <<rc <<
" trunc " <<theOffset <<
' ' <<
argp->
buff);
3114 int XrdXrootdProtocol::do_Write()
3130 return do_WriteNone(pathID);
3137 "Write length is negative");
3156 {
if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAio,pathID);
3157 return do_WriteAio();
3165 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAll, pathID);
3169 return do_WriteAll();
3180 int XrdXrootdProtocol::do_WriteAio()
3190 return do_WriteAll();
3206 int XrdXrootdProtocol::do_WriteAll()
3213 {
if ((rc = getBuff(0, Quantum)) <= 0)
return rc;}
3221 {
Resume = &XrdXrootdProtocol::do_WriteCont;
3228 return do_WriteNone();
3230 IO.Offset += Quantum;
IO.
IOLen -= Quantum;
3248 int XrdXrootdProtocol::do_WriteCont()
3256 return do_WriteNone();
3262 if (
IO.
IOLen > 0)
return do_WriteAll();
3270 int XrdXrootdProtocol::do_WriteNone()
3272 char *buff, dbuff[4096];
3282 blen =
sizeof(dbuff);
3291 if (rlen < 0)
return Link->
setEtext(
"link read error");
3295 Resume = &XrdXrootdProtocol::do_WriteNone;
3303 return do_WriteNoneMsg();
3308 int XrdXrootdProtocol::do_WriteNone(
int pathID,
XErrorCode ec,
3316 else do_WriteNoneMsg();
3332 return do_WriteNone();
3339 int XrdXrootdProtocol::do_WriteNoneMsg()
3393 return do_WriteNone();
3399 if (
IO.
IOLen > 0)
return do_WriteAll();
3407 int XrdXrootdProtocol::do_WriteV()
3425 long long totSZ, maxSZ;
3431 wrVecNum = wrVecLen / wveSZ;
3432 if ( (wrVecLen <= 0) || (wrVecNum*wveSZ != wrVecLen) )
3458 totSZ = 0; maxSZ = 0; k = 0; Quantum =
maxTransz; curFH = 0;
3459 for (
int i = 0; i < wrVecNum; i++)
3460 {
if (wrLst[i].
wlen == 0)
continue;
3461 memcpy(&wrVec[k].info, wrLst[i].
fhandle,
sizeof(
int));
3462 wrVec[k].
size = ntohl(wrLst[i].
wlen);
3463 if (wrVec[k].size < 0)
3467 if (wrVec[k].size > Quantum)
3472 if (wrVec[k].info == curFH) totSZ += wrVec[k].
size;
3473 else {
if (maxSZ < totSZ) maxSZ = totSZ;
3474 totSZ = wrVec[k].
size;
3481 if (maxSZ < totSZ) maxSZ = totSZ;
3492 else Quantum =
static_cast<int>(maxSZ);
3496 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->
bsize)
3497 {
if (getBuff(0, Quantum) <= 0)
return -1;}
3526 freeInfo.doit =
false;
3535 int XrdXrootdProtocol::do_WriteVec()
3548 {
if (rc < 0)
return rc;
3550 Resume = &XrdXrootdProtocol::do_WriteVec;
3558 done = newfile =
false;
3578 if (done || newfile)
3595 if (xfrSZ< 0)
break;
3661 for (i = 1; i < sfvnum; i++) xframt += sfvec[i].sendsz;
3662 if (xframt >
IO.
IOLen)
return 1;
3678 else IO.
File->fdNum = fildes;
3688 int XrdXrootdProtocol::fsError(
int rc,
char opC,
XrdOucErrInfo &myError,
3689 const char *
Path,
char *Cgi)
3691 int ecode, popt, rs;
3703 return fsOvrld(opC,
Path, Cgi);
3713 if (Cgi) rs = fsRedirNoEnt(
eMsg, Cgi, popt);
3736 <<
eMsg <<
':' <<ecode);
3751 if (ecode <= 0) ecode = 1800;
3756 return (rc ? rc : 1);
3792 sprintf(buff,
"%d", rc);
3804 int XrdXrootdProtocol::fsOvrld(
char opC,
const char *
Path,
char *Cgi)
3806 static const char *prot =
"root://";
3807 static int negOne = -1;
3808 static char quest =
'?', slash =
'/';
3810 struct iovec rdrResp[8];
3811 char *destP=0, dest[512];
3812 int iovNum=0, pOff, port;
3820 { rdrResp[1].iov_base = (
char *)&negOne;
3821 rdrResp[1].iov_len =
sizeof(negOne);
3822 rdrResp[2].iov_base = (
char *)prot;
3823 rdrResp[2].iov_len = 7;
3824 rdrResp[3].iov_base = (
char *)dest;
3825 rdrResp[3].iov_len = strlen(dest);
3826 rdrResp[4].iov_base = (
char *)&slash;
3827 rdrResp[4].iov_len = (*
Path ==
'/' ? 1 : 0);
3828 rdrResp[5].iov_base = (
char *)(
Path+pOff);
3829 rdrResp[5].iov_len = strlen(
Path+pOff);
3831 {rdrResp[6].iov_base = (
char *)?
3832 rdrResp[6].iov_len =
sizeof(quest);
3833 rdrResp[7].iov_base = (
char *)Cgi;
3834 rdrResp[7].iov_len = strlen(Cgi);
3874 int XrdXrootdProtocol::fsRedirNoEnt(
const char *
eMsg,
char *Cgi,
int popt)
3876 struct iovec ioV[4];
3877 char *tried, *trend, *ptried = 0;
3884 {
do {
if (!(tried = strstr(Cgi,
"tried=")))
break;
3885 if (tried == trend || *(tried-1) ==
'&')
3886 {
if (!ptried || (*(tried+6) && *(tried+6) !=
'&')) ptried=tried;}
3887 Cgi = index(tried+6,
'&');
3894 if ((tried = ptried))
3896 while(*(tried+1) && *(tried+1) ==
',') tried++;
3897 trend = index(tried,
'&');
3898 if (trend) {tlen = trend - tried; *trend = 0;}
3899 else tlen = strlen(tried);
3906 if ((trend = tried) &&
eMsg)
3907 do {
if ((trend = strstr(trend,
myCName)))
3910 trend = index(trend+
myCNlen,
',');
3918 if (!tried || !tlen || tlen > 16384)
3926 ioV[1].iov_base = (
char *)&pnum;
3927 ioV[1].iov_len =
sizeof(pnum);
3930 ioV[3].iov_base = tried;
3931 ioV[3].iov_len = tlen;
3946 int XrdXrootdProtocol::getBuff(
const int isRead,
int Quantum)
3965 "insufficient memory to read file" :
3966 "insufficient memory to write file"));
3977 char *XrdXrootdProtocol::getCksType(
char *opaque,
char *cspec,
int cslen)
3983 if (opaque && *opaque)
3985 if ((cksT = jobEnv.Get(
"cks.type")))
3987 while(tP && strcasecmp(tP->
text, cksT)) tP = tP->
next;
3988 if (!tP && cspec) snprintf(cspec, cslen,
"%s", cksT);
3989 return (tP ? tP->
text : 0);
4002 bool XrdXrootdProtocol::logLogin(
bool xauth)
4004 const char *uName, *ipName, *tMsg, *zMsg =
"";
4005 char lBuff[512], pBuff[512];
4021 if (*tMsg) zMsg =
" ";
4025 snprintf(lBuff,
sizeof(lBuff),
"%s %s %s%slogin%s%s",
4028 (xauth ?
" as " :
""),
4029 (uName ? uName :
""));
4034 {snprintf(pBuff,
sizeof(pBuff),
"via %s auth for %s",
4052 eDest.
Emsg(
"Xeq",
"session requires TLS but",
Link->
ID,
"is incapable.");
4076 #define Map_Mode(x,y) if (Mode & kXR_ ## x) newmode |= S_I ## y
4078 int XrdXrootdProtocol::mapMode(
int Mode)
4100 const char *bP = Buff;
4103 else {snprintf(Buff,
sizeof(Buff),
4104 "&p=%s&n=%s&h=%s&o=%s&r=%s&g=%s&m=%s%s&I=%c",
4126 int XrdXrootdProtocol::rpCheck(
char *fn,
char **opaque)
4135 if (!(cp = index(fn,
'?'))) *opaque = 0;
4136 else {*cp =
'\0'; *opaque = cp+1;
4137 if (!**opaque) *opaque = 0;
4140 if (*fn !=
'/')
return 0;
4142 while ((cp = index(fn,
'/')))
4144 if (fn[0] ==
'.' && fn[1] ==
'.' && fn[2] ==
'/')
return 1;
4153 int XrdXrootdProtocol::rpEmsg(
const char *op,
char *fn)
4156 snprintf(buff,
sizeof(buff)-1,
"%s relative path '%s' is disallowed.",op,fn);
4157 buff[
sizeof(buff)-1] =
'\0';
4175 else if (theFile->fdNum >= 0) theFile->
sfEnabled = 1;
4186 int XrdXrootdProtocol::Squash(
char *fn)
4188 char *ofn, *ifn = fn;
4195 || (*(ifn+1) ==
'.' && *(ifn+1) && *(ifn+2) ==
'/'))
break;
4202 while(*ifn) {*ofn = *ifn++;
4204 {
while(*ifn ==
'/') ifn++;
4205 if (ifn[0] ==
'.' && ifn[1] ==
'/') ifn += 2;
4219 int XrdXrootdProtocol::vpEmsg(
const char *op,
char *fn)
4222 snprintf(buff,
sizeof(buff)-1,
"%s path '%s' is disallowed.",op,fn);
4223 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 stat(const char *path, struct stat *buf)
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)
const char * Host() const
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)
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 const char * getParms(int &size, XrdNetAddrInfo *endPoint=0)=0
virtual bool PostProcess(XrdSecEntity &entity, XrdOucErrInfo &einfo)
virtual XrdSecProtocol * getProtocol(const char *host, XrdNetAddrInfo &endPoint, const XrdSecCredentials *cred, XrdOucErrInfo &einfo)=0
virtual int autoStat(struct stat *buf)
virtual const char * nextEntry()=0
virtual int open(const char *path, const XrdSecEntity *client=0, const char *opaque=0)=0
virtual XrdSfsDirectory * newDir(char *user=0, int MonID=0)=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 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 XrdSfsFile * newFile(char *user=0, int MonID=0)=0
virtual int rem(const char *path, XrdOucErrInfo &eInfo, const XrdSecEntity *client=0, const char *opaque=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 XrdScheduler * Sched
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()
void StreamID(kXR_char *sid)
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