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';
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));
1645 int XrdXrootdProtocol::do_Ping()
1661 int 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;
1880 int 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)
1975 int 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(
"proxy", val))
2030 {
const char* pxyOrigin =
"proxy";
2032 {pxyOrigin = getenv(
"XRDXROOTD_PROXY");
2033 if (!pxyOrigin) pxyOrigin =
"proxy";
2035 n = snprintf(bp,bleft,
"%s\n",pxyOrigin);
2036 bp += n; bleft -= n;
2038 else if (!strcmp(
"readv_ior_max", val))
2040 bp += n; bleft -= n;
2042 else if (!strcmp(
"readv_iov_max", val))
2044 bp += n; bleft -= n;
2046 else if (!strcmp(
"role", val))
2047 {
const char *theRole = getenv(
"XRDROLE");
2048 n = snprintf(bp, bleft,
"%s\n", (theRole ? theRole :
"none"));
2049 bp += n; bleft -= n;
2051 else if (!strcmp(
"sitename", val))
2052 {
const char *siteName = getenv(
"XRDSITE");
2053 n = snprintf(bp, bleft,
"%s\n", (siteName ? siteName :
"sitename"));
2054 bp += n; bleft -= n;
2056 else if (!strcmp(
"start", val))
2057 {n = snprintf(bp, bleft,
"%s\n", startUP);
2058 bp += n; bleft -= n;
2060 else if (!strcmp(
"sysid", val))
2061 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2062 const char *nidval = getenv(
"XRDCMSVNID");
2063 if (!cidval || !(*cidval) || !nidval || !(*nidval))
2064 {cidval =
"sysid"; nidval =
"";}
2065 n = snprintf(bp, bleft,
"%s %s\n", nidval, cidval);
2066 bp += n; bleft -= n;
2068 else if (!strcmp(
"tpc", val))
2069 {
char *tpcval = getenv(
"XRDTPC");
2070 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpc"));
2071 bp += n; bleft -= n;
2073 else if (!strcmp(
"tpcdlg", val))
2074 {
char *tpcval = getenv(
"XRDTPCDLG");
2075 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpcdlg"));
2076 bp += n; bleft -= n;
2078 else if (!strcmp(
"tls_port", val) &&
tlsPort)
2079 {n = snprintf(bp, bleft,
"%d\n",
tlsPort);
2080 bp += n; bleft -= n;
2082 else if (!strcmp(
"window", val) &&
Window)
2083 {n = snprintf(bp, bleft,
"%d\n",
Window);
2084 bp += n; bleft -= n;
2086 else if (!strcmp(
"version", val))
2087 {n = snprintf(bp, bleft,
"%s\n", XrdVSTRING);
2088 bp += n; bleft -= n;
2090 else if (!strcmp(
"vnid", val))
2091 {
const char *nidval = getenv(
"XRDCMSVNID");
2092 if (!nidval || !(*nidval)) nidval =
"vnid";
2093 n = snprintf(bp, bleft,
"%s\n", nidval);
2095 else if (!strcmp(
"fattr", val))
2096 {n = snprintf(bp, bleft,
"%s\n",
usxParms);
2097 bp += n; bleft -= n;
2099 else {n = strlen(val);
2100 if (bleft <= n)
break;
2101 strcpy(bp, val); bp +=n; *bp =
'\n'; bp++;
2104 }
while(bleft > 0 && (val = qcargs.GetToken()));
2123 bool isCMSD = (*val ==
'c');
2148 int XrdXrootdProtocol::do_Qfh()
2153 const char *fArg = 0, *qType =
"";
2165 "query does not refer to an open file");
2185 "Required query argument not present");
2190 TRACEP(FS,
"fh=" <<fh.handle <<
" query " <<qType <<
" rc=" <<rc);
2203 int XrdXrootdProtocol::do_Qopaque(
short qopt)
2208 const char *Act, *AData;
2216 myData.Arg2 = 0; myData.
Arg2Len = 0;
2218 Act =
" qopaque '"; AData =
"...";
2233 myData.Arg2 = opaque;
2236 Act =
" qopaquf '"; AData =
argp->
buff;
2245 TRACEP(FS,
"rc=" <<rc <<Act <<AData <<
"'");
2247 return fsError(rc, 0, myError, 0, 0);
2254 int XrdXrootdProtocol::do_Qspace()
2275 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2290 int XrdXrootdProtocol::do_Query()
2307 case kXR_QPrep:
return do_Prepare(
true);
2314 "Invalid information query type code");
2321 int XrdXrootdProtocol::do_Qxattr()
2343 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2357 int XrdXrootdProtocol::do_Read()
2368 else if (do_ReadNone(retc, pathID))
return retc;
2379 "read does not refer to an open file");
2383 TRACEP(FSIO, pathID <<
" fh=" <<fh.handle <<
" read " <<
IO.
IOLen
2386 "Read length is negative");
2411 if (!pathID) pP =
this;
2412 else {
if (!(pP =
VerifyStream(retc, pathID,
false)))
return retc;
2427 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_ReadAll, pathID);
2431 return do_ReadAll();
2442 int XrdXrootdProtocol::do_ReadAll()
2477 {
if ((rc = getBuff(1, Quantum)) <= 0)
return rc;}
2488 IO.Offset += xframt;
IO.
IOLen -= xframt;
2502 int XrdXrootdProtocol::do_ReadNone(
int &retc,
int &pathID)
2511 pathID =
static_cast<int>(rargs->
pathid);
2512 if ((ralsz -=
sizeof(
read_args)) <= 0)
return 0;
2531 "preread does not refer to an open file");
2549 int XrdXrootdProtocol::do_ReadV()
2563 int rdVBeg, rdVBreak, rdVNow, rdVNum, rdVecNum;
2564 int currFH, i, k, Quantum, Qleft, rdVecLen =
Request.header.dlen;
2566 int ioMon = (rvMon > 1);
2567 char *buffp, vType = (ioMon ? XROOTD_MON_READU : XROOTD_MON_READV);
2572 rdVecNum = rdVecLen / sizeof(readahead_list);
2573 if ( (rdVecNum <= 0) || (rdVecNum*hdrSZ != rdVecLen) )
2574 return Response.Send(kXR_ArgInvalid, "Read vector is invalid");
2580 if (rdVecNum > XrdProto::maxRvecsz)
2581 return
Response.
Send(kXR_ArgTooLong, "Read vector is too long");
2591 raVec = (readahead_list *)
argp->buff;
2593 for (i = 0; i < rdVecNum; i++)
2594 {totSZ += (rdVec[i].size = ntohl(raVec[i].rlen));
2595 if (rdVec[i].size < 0) return Response.Send(kXR_ArgInvalid,
2596 "Readv length is negative");
2597 if (rdVec[i].size > Quantum) return Response.Send(kXR_NoMemory,
2598 "Single readv transfer is too large");
2599 rdVec[i].offset = ntohll(raVec[i].offset);
2600 memcpy(&rdVec[i].info, raVec[i].fhandle, sizeof(int));
2605 rdVec[i].offset = -1;
2608 rdVBreak = rdVecNum;
2613 if (totSZ > 0x7fffffffLL)
2614 return
Response.
Send(kXR_NoMemory, "Total readv transfer is too large");
2623 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->bsize)
2624 {
if ((k = getBuff(1, Quantum)) <= 0)
return k;}
2631 "readv does not refer to an open file");
2636 currFH = rdVec[0].info;
2637 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2639 "readv does not refer to an open file");
2644 rdVBeg = rdVNow = 0; rdVXfr = rdVAmt = 0;
2648 for (i = 0; i < rdVecNum; i++)
2649 {
if (rdVec[i].info != currFH)
2651 if (xfrSZ != rdVAmt)
break;
2652 rdVNum = i - rdVBeg; rdVXfr += rdVAmt;
2656 htons(rdVNum),
rvSeq, vType);
2657 if (ioMon)
for (k = rdVBeg; k < i; k++)
2659 htonl(rdVec[k].size), htonll(rdVec[k].offset));
2661 rdVXfr = rdVAmt = 0;
2662 if (i == rdVBreak)
break;
2663 rdVBeg = rdVNow = i; currFH = rdVec[i].info;
2664 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2667 "readv does not refer to an open file");
2670 if (Qleft < (rdVec[i].size + hdrSZ))
2673 if (xfrSZ != rdVAmt)
break;
2679 rdVNow = i; rdVXfr += rdVAmt; rdVAmt = 0;
2682 xfrSZ = rdVec[i].size; rdVAmt += xfrSZ;
2683 respHdr.rlen = htonl(xfrSZ);
2684 respHdr.offset = htonll(rdVec[i].offset);
2685 memcpy(buffp, &respHdr, hdrSZ);
2686 rdVec[i].data = buffp + hdrSZ;
2687 buffp += (xfrSZ+hdrSZ); Qleft -= (xfrSZ+hdrSZ);
2688 TRACEP(FSIO,
"fh=" <<currFH<<
" readV "<< xfrSZ <<
'@'<<rdVec[i].offset);
2710 int XrdXrootdProtocol::do_Rm()
2740 int XrdXrootdProtocol::do_Rmdir()
2770 int XrdXrootdProtocol::do_Set()
2777 if (!setargs.GetLine() || !(val = setargs.GetToken(&rest)))
2786 if (!strcmp(
"appid", val))
2787 {
while(*rest && *rest ==
' ') rest++;
2791 else if (!strcmp(
"monitor", val))
return do_Set_Mon(setargs);
2792 else if (!strcmp(
"cache", val))
return do_Set_Cache(setargs);
2809 char *cmd, *cargs, *opaque;
2810 const char *myArgs[2];
2819 if (!(cmd = setargs.
GetToken(&cargs)))
2824 if (cargs && *cargs ==
'/')
2825 {
if (rpCheck(cargs, &opaque))
return rpEmsg(
"Setting", cargs);
2826 if (!Squash(cargs))
return vpEmsg(
"Setting", cargs);
2827 myData.ArgP = myArgs; myData.
Arg2Len = -2;
2831 myData.Arg2 = opaque; myData.
Arg2Len = (opaque ? strlen(opaque) : 0);
2838 TRACEP(FS,
"rc=" <<rc <<
"set cache " <<myData.
Arg1 <<
' ' <<cargs);
2840 return fsError(rc, 0, myError, 0, 0);
2856 if (!(val = setargs.
GetToken(&appid)))
2863 if (!strcmp(val,
"info"))
2865 {
while(*appid && *appid ==
' ') appid++;
2866 if (strlen(appid) > 1024) appid[1024] =
'\0';
2874 if (!strcmp(val,
"on"))
2877 {
while(*appid && *appid ==
' ') appid++;
2886 if (!strcmp(val,
"off"))
2888 {
while(*appid && *appid ==
' ') appid++;
2904 int XrdXrootdProtocol::do_Stat()
2910 char *opaque, xxBuff[1024];
2929 "stat does not refer to an open file");
2933 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2956 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2966 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2975 int XrdXrootdProtocol::do_Statx()
2979 char *path, *opaque, *respinfo =
argp->
buff;
2990 while((path = pathlist.GetLine()))
2991 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Stating", path);
2992 if (!Squash(path))
return vpEmsg(
"Stating", path);
2994 TRACEP(FS,
"rc=" <<rc <<
" stat " <<path);
2997 else {
if (mode == (mode_t)-1) *respinfo = (char)
kXR_offline;
2998 else if (S_ISDIR(mode)) *respinfo = (
char)
kXR_isDir;
3013 int XrdXrootdProtocol::do_Sync()
3048 int XrdXrootdProtocol::do_Truncate()
3053 long long theOffset;
3072 "trunc does not refer to an open file");
3078 TRACEP(FS,
"fh=" <<fh.
handle <<
" trunc rc=" <<rc <<
" sz=" <<theOffset);
3099 TRACEP(FS,
"rc=" <<rc <<
" trunc " <<theOffset <<
' ' <<
argp->
buff);
3113 int XrdXrootdProtocol::do_Write()
3129 return do_WriteNone(pathID);
3136 "Write length is negative");
3155 {
if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAio,pathID);
3156 return do_WriteAio();
3164 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAll, pathID);
3168 return do_WriteAll();
3179 int XrdXrootdProtocol::do_WriteAio()
3189 return do_WriteAll();
3205 int XrdXrootdProtocol::do_WriteAll()
3212 {
if ((rc = getBuff(0, Quantum)) <= 0)
return rc;}
3220 {
Resume = &XrdXrootdProtocol::do_WriteCont;
3227 return do_WriteNone();
3229 IO.Offset += Quantum;
IO.
IOLen -= Quantum;
3247 int XrdXrootdProtocol::do_WriteCont()
3255 return do_WriteNone();
3261 if (
IO.
IOLen > 0)
return do_WriteAll();
3269 int XrdXrootdProtocol::do_WriteNone()
3271 char *buff, dbuff[4096];
3281 blen =
sizeof(dbuff);
3290 if (rlen < 0)
return Link->
setEtext(
"link read error");
3294 Resume = &XrdXrootdProtocol::do_WriteNone;
3302 return do_WriteNoneMsg();
3307 int XrdXrootdProtocol::do_WriteNone(
int pathID,
XErrorCode ec,
3315 else do_WriteNoneMsg();
3331 return do_WriteNone();
3338 int XrdXrootdProtocol::do_WriteNoneMsg()
3392 return do_WriteNone();
3398 if (
IO.
IOLen > 0)
return do_WriteAll();
3406 int XrdXrootdProtocol::do_WriteV()
3424 long long totSZ, maxSZ;
3430 wrVecNum = wrVecLen / wveSZ;
3431 if ( (wrVecLen <= 0) || (wrVecNum*wveSZ != wrVecLen) )
3457 totSZ = 0; maxSZ = 0; k = 0; Quantum =
maxTransz; curFH = 0;
3458 for (
int i = 0; i < wrVecNum; i++)
3459 {
if (wrLst[i].
wlen == 0)
continue;
3460 memcpy(&wrVec[k].info, wrLst[i].
fhandle,
sizeof(
int));
3461 wrVec[k].
size = ntohl(wrLst[i].
wlen);
3462 if (wrVec[k].size < 0)
3466 if (wrVec[k].size > Quantum)
3471 if (wrVec[k].info == curFH) totSZ += wrVec[k].
size;
3472 else {
if (maxSZ < totSZ) maxSZ = totSZ;
3473 totSZ = wrVec[k].
size;
3480 if (maxSZ < totSZ) maxSZ = totSZ;
3491 else Quantum =
static_cast<int>(maxSZ);
3495 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->
bsize)
3496 {
if (getBuff(0, Quantum) <= 0)
return -1;}
3525 freeInfo.doit =
false;
3534 int XrdXrootdProtocol::do_WriteVec()
3547 {
if (rc < 0)
return rc;
3549 Resume = &XrdXrootdProtocol::do_WriteVec;
3557 done = newfile =
false;
3577 if (done || newfile)
3594 if (xfrSZ< 0)
break;
3660 for (i = 1; i < sfvnum; i++) xframt += sfvec[i].sendsz;
3661 if (xframt >
IO.
IOLen)
return 1;
3677 else IO.
File->fdNum = fildes;
3687 int XrdXrootdProtocol::fsError(
int rc,
char opC,
XrdOucErrInfo &myError,
3688 const char *
Path,
char *Cgi)
3690 int ecode, popt, rs;
3702 return fsOvrld(opC,
Path, Cgi);
3712 if (Cgi) rs = fsRedirNoEnt(
eMsg, Cgi, popt);
3735 <<
eMsg <<
':' <<ecode);
3750 if (ecode <= 0) ecode = 1800;
3755 return (rc ? rc : 1);
3791 sprintf(buff,
"%d", rc);
3803 int XrdXrootdProtocol::fsOvrld(
char opC,
const char *
Path,
char *Cgi)
3805 static const char *prot =
"root://";
3806 static int negOne = -1;
3807 static char quest =
'?', slash =
'/';
3809 struct iovec rdrResp[8];
3810 char *destP=0, dest[512];
3811 int iovNum=0, pOff, port;
3819 { rdrResp[1].iov_base = (
char *)&negOne;
3820 rdrResp[1].iov_len =
sizeof(negOne);
3821 rdrResp[2].iov_base = (
char *)prot;
3822 rdrResp[2].iov_len = 7;
3823 rdrResp[3].iov_base = (
char *)dest;
3824 rdrResp[3].iov_len = strlen(dest);
3825 rdrResp[4].iov_base = (
char *)&slash;
3826 rdrResp[4].iov_len = (*
Path ==
'/' ? 1 : 0);
3827 rdrResp[5].iov_base = (
char *)(
Path+pOff);
3828 rdrResp[5].iov_len = strlen(
Path+pOff);
3830 {rdrResp[6].iov_base = (
char *)?
3831 rdrResp[6].iov_len =
sizeof(quest);
3832 rdrResp[7].iov_base = (
char *)Cgi;
3833 rdrResp[7].iov_len = strlen(Cgi);
3873 int XrdXrootdProtocol::fsRedirNoEnt(
const char *
eMsg,
char *Cgi,
int popt)
3875 struct iovec ioV[4];
3876 char *tried, *trend, *ptried = 0;
3883 {
do {
if (!(tried = strstr(Cgi,
"tried=")))
break;
3884 if (tried == trend || *(tried-1) ==
'&')
3885 {
if (!ptried || (*(tried+6) && *(tried+6) !=
'&')) ptried=tried;}
3886 Cgi = index(tried+6,
'&');
3893 if ((tried = ptried))
3895 while(*(tried+1) && *(tried+1) ==
',') tried++;
3896 trend = index(tried,
'&');
3897 if (trend) {tlen = trend - tried; *trend = 0;}
3898 else tlen = strlen(tried);
3905 if ((trend = tried) &&
eMsg)
3906 do {
if ((trend = strstr(trend,
myCName)))
3909 trend = index(trend+
myCNlen,
',');
3917 if (!tried || !tlen || tlen > 16384)
3925 ioV[1].iov_base = (
char *)&pnum;
3926 ioV[1].iov_len =
sizeof(pnum);
3929 ioV[3].iov_base = tried;
3930 ioV[3].iov_len = tlen;
3945 int XrdXrootdProtocol::getBuff(
const int isRead,
int Quantum)
3964 "insufficient memory to read file" :
3965 "insufficient memory to write file"));
3976 char *XrdXrootdProtocol::getCksType(
char *opaque,
char *cspec,
int cslen)
3982 if (opaque && *opaque)
3984 if ((cksT = jobEnv.Get(
"cks.type")))
3986 while(tP && strcasecmp(tP->
text, cksT)) tP = tP->
next;
3987 if (!tP && cspec) snprintf(cspec, cslen,
"%s", cksT);
3988 return (tP ? tP->
text : 0);
4001 bool XrdXrootdProtocol::logLogin(
bool xauth)
4003 const char *uName, *ipName, *tMsg, *zMsg =
"";
4004 char lBuff[512], pBuff[512];
4020 if (*tMsg) zMsg =
" ";
4024 snprintf(lBuff,
sizeof(lBuff),
"%s %s %s%slogin%s%s",
4027 (xauth ?
" as " :
""),
4028 (uName ? uName :
""));
4033 {snprintf(pBuff,
sizeof(pBuff),
"via %s auth for %s",
4051 eDest.
Emsg(
"Xeq",
"session requires TLS but",
Link->
ID,
"is incapable.");
4075 #define Map_Mode(x,y) if (Mode & kXR_ ## x) newmode |= S_I ## y
4077 int XrdXrootdProtocol::mapMode(
int Mode)
4099 const char *bP = Buff;
4102 else {snprintf(Buff,
sizeof(Buff),
4103 "&p=%s&n=%s&h=%s&o=%s&r=%s&g=%s&m=%s%s&I=%c",
4125 int XrdXrootdProtocol::rpCheck(
char *fn,
char **opaque)
4134 if (!(cp = index(fn,
'?'))) *opaque = 0;
4135 else {*cp =
'\0'; *opaque = cp+1;
4136 if (!**opaque) *opaque = 0;
4139 if (*fn !=
'/')
return 0;
4141 while ((cp = index(fn,
'/')))
4143 if (fn[0] ==
'.' && fn[1] ==
'.' && fn[2] ==
'/')
return 1;
4152 int XrdXrootdProtocol::rpEmsg(
const char *op,
char *fn)
4155 snprintf(buff,
sizeof(buff)-1,
"%s relative path '%s' is disallowed.",op,fn);
4156 buff[
sizeof(buff)-1] =
'\0';
4174 else if (theFile->fdNum >= 0) theFile->
sfEnabled = 1;
4185 int XrdXrootdProtocol::Squash(
char *fn)
4187 char *ofn, *ifn = fn;
4194 || (*(ifn+1) ==
'.' && *(ifn+1) && *(ifn+2) ==
'/'))
break;
4201 while(*ifn) {*ofn = *ifn++;
4203 {
while(*ifn ==
'/') ifn++;
4204 if (ifn[0] ==
'.' && ifn[1] ==
'/') ifn += 2;
4218 int XrdXrootdProtocol::vpEmsg(
const char *op,
char *fn)
4221 snprintf(buff,
sizeof(buff)-1,
"%s path '%s' is disallowed.",op,fn);
4222 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