72 #include "XrdVersion.hh"
75 #define ENODATA ENOATTR
79 #define ETIME ETIMEDOUT
109 const char *getTime()
111 static char buff[16];
116 if (gettimeofday(&tv, 0))
117 {perror(
"gettimeofday");
120 tmp = localtime(&tv.tv_sec);
122 {perror(
"localtime");
126 if (strftime(buff,
sizeof(buff),
"%y%m%d:%H%M%S. ", tmp) <= 0)
132 snprintf(tuff,
sizeof(tuff),
"%d",
static_cast<int>(tv.tv_usec/100000));
153 static const char *startUP = getTime();
160 int XrdXrootdProtocol::do_Auth()
189 {eText =
eMsg.getErrText(rc);
190 eDest.
Emsg(
"Xeq",
"User authentication failed;", eText);
207 if (!logLogin(
true))
return -1;
214 {
TRACEP(LOGIN,
"more auth requested; sz=" <<(parm ? parm->
size : 0));
219 eDest.
Emsg(
"Xeq",
"Security requested additional auth w/o parms!");
234 eText =
eMsg.getErrText(rc);
235 eDest.
Emsg(
"Xeq",
"User authentication failed;", eText);
243 int XrdXrootdProtocol::do_Bind()
249 char buff[64], *cp, *dp;
296 if (strcmp(
Link->
Host(), lp->Host()))
308 for (i = 1; i <
maxStreams && pp->Stream[i]; i++) {}
316 pp->Stream[i] =
this;
323 if ( (dp = rindex(cp,
'@'))) *dp =
'\0';
324 if (!(dp = rindex(cp,
'.'))) pPid = 0;
325 else {*dp++ =
'\0'; pPid = strtol(dp, (
char **)NULL, 10);}
337 *(pp->pmHandle),
Link->
ID);
343 sprintf(buff,
"FD %d#%d bound",
Link->
FDnum(), i);
352 buff[0] =
static_cast<char>(i);
371 int XrdXrootdProtocol::do_Chmod()
402 int XrdXrootdProtocol::do_CKsum(
int canit)
405 char *algT =
JobCKT, *args[6];
419 if (rpCheck(
argp->
buff, &opaque))
return rpEmsg(
"Check summing",
argp->
buff);
433 algT = getCksType(opaque, cksT,
sizeof(cksT));
436 snprintf(ebuf,
sizeof(ebuf),
"%s checksum not supported.", cksT);
443 if (
JobLCL && (rc = do_CKsum(algT,
argp->
buff, opaque)) <= 0)
return rc;
460 if (
Client->
eaAPI->
Get(std::string(
"request.name"), keyval) && !keyval.empty())
461 args[4] =
const_cast<char *
>(keyval.c_str());
479 int XrdXrootdProtocol::do_CKsum(
char *algT,
const char *
Path,
char *Opaque)
481 static char Space =
' ';
483 int CKTLen = strlen(algT);
485 myError,
CRED, Opaque);
486 const char *csData = myError.getErrText(
ec);
490 if (rc)
return fsError(rc, 0, myError,
Path, Opaque);
496 struct iovec
iov[4] = {{0,0}, {algT, (size_t)CKTLen}, {&Space, 1},
497 {(
char *)csData, strlen(csData)+1}};
504 {
const char *eTxt[2] = {
JobCKT,
" checksum not available."};
505 myError.setErrInfo(0, eTxt, 2);
518 int XrdXrootdProtocol::do_Close()
534 "close does not refer to an open file");
544 if (fp->
pgwFob && !do_PgClose(fp, rc))
569 rc = fp->XrdSfsp->close();
570 TRACEP(FS,
" fh=" <<fh.handle <<
" close rc=" <<rc);
574 return fsError(rc, 0, fp->XrdSfsp->error, 0, 0);
583 if (
SFS_OK != rc) retval = fsError(rc, 0, fp->XrdSfsp->error, 0, 0);
590 if (!doDel) fp->Ref(-1);
602 int XrdXrootdProtocol::do_Dirlist()
604 int bleft, rc = 0, dlen, cnt = 0;
605 char *opaque, *buff, ebuff[4096];
631 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s",
argp->
buff);
648 return do_DirStat(dp, ebuff, opaque);
658 do {buff = ebuff; bleft =
sizeof(ebuff);
659 while(dname || (dname = dp->
nextEntry()))
660 {dlen = strlen(dname);
661 if (dlen > 2 || dname[0] !=
'.' || (dlen == 2 && dname[1] !=
'.'))
662 {
if ((bleft -= (dlen+1)) < 0)
break;
663 strcpy(buff, dname); buff += dlen; *buff =
'\n'; buff++; cnt++;
668 }
while(!rc && dname);
674 else {*(buff-1) =
'\0';
683 if (!rc) {
TRACEP(FS,
"dirlist entries=" <<cnt <<
" path=" <<
argp->
buff);}
696 char *buff, *dLoc, *algT = 0;
697 const char *csData, *dname;
698 int bleft, rc = 0, dlen, cnt = 0, statSz = 160;
700 struct {
char ebuff[8192];
char epad[512];} XB;
707 algT = getCksType(opaque, cksT,
sizeof(cksT));
710 snprintf(ebuf,
sizeof(ebuf),
"%s checksum not supported.", cksT);
725 dlen = strlen(pbuff);
726 if (pbuff[dlen-1] !=
'/') {pbuff[dlen] =
'/'; dlen++;}
735 strcpy(XB.ebuff,
".\n0 0 0 0\n");
736 buff = XB.ebuff+10; bleft =
sizeof(XB.ebuff)-10;
746 do {
while(dname || (dname = dp->
nextEntry()))
747 {dlen = strlen(dname);
748 if (dlen > 2 || dname[0] !=
'.' || (dlen == 2 && dname[1] !=
'.'))
749 {
if ((bleft -= (dlen+1)) < 0 || bleft < statSz)
break;
750 if (dLoc) strcpy(dLoc, dname);
753 if (rc ==
SFS_ERROR && myError.getErrInfo() == ENOENT)
754 {dname = 0;
continue;}
759 strcpy(buff, dname); buff += dlen; *buff =
'\n'; buff++; cnt++;
760 dlen = StatGen(
Stat, buff,
sizeof(XB.epad));
761 bleft -= dlen; buff += (dlen-1);
764 pbuff, myError,
CRED, opaque);
765 csData = myError.getErrText();
766 if (
ec !=
SFS_OK || !(*csData) || *csData ==
'!')
768 int n = snprintf(buff,
sizeof(XB.epad),
" [ %s:%s ]",
770 buff += n; bleft -= n;
772 *buff =
'\n'; buff++;
778 buff = XB.ebuff; bleft =
sizeof(XB.ebuff);
781 }
while(!rc && dname);
787 else {*(buff-1) =
'\0';
796 if (!rc) {
TRACEP(FS,
"dirstat entries=" <<cnt <<
" path=" <<
argp->
buff);}
804 int XrdXrootdProtocol::do_Endsess()
816 memcpy((
void *)&sessID.
Pid, &sp->
Pid,
sizeof(sessID.
Pid));
817 memcpy((
void *)&sessID.
FD, &sp->
FD,
sizeof(sessID.
FD));
818 memcpy((
void *)&sessID.
Inst, &sp->
Inst,
sizeof(sessID.
Inst));
822 TRACEP(LOGIN,
"endsess " <<sessID.
Pid <<
':' <<sessID.
FD <<
'.' <<sessID.
Inst);
830 if ((sessID.
FD == 0 && sessID.
Inst == 0)
835 TRACEP(LOGIN,
"endsess " <<sessID.
Pid <<
':' <<sessID.
FD <<
'.' <<sessID.
Inst
836 <<
" rc=" <<rc <<
" (" <<
XrdSysE2T(rc < 0 ? -rc : EAGAIN) <<
")");
859 int XrdXrootdProtocol::do_gpFile()
880 int XrdXrootdProtocol::do_Locate()
884 char *opaque = 0, *
Path, *fn =
argp->
buff, opt[8], *op=opt;
901 TRACEP(FS,
"locate " <<opt <<
' ' <<fn);
905 if (*fn !=
'*'){
Path = fn;
908 else if (*(fn+1)) {
Path = fn+1;
923 {
if (rpCheck(
Path, &opaque))
return rpEmsg(
"Locating",
Path);
924 if (!doDig && !Squash(
Path))
return vpEmsg(
"Locating",
Path);
933 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
937 TRACEP(FS,
"rc=" <<rc <<
" locate " <<fn);
945 int XrdXrootdProtocol::do_Login()
949 int i, pid, rc, sendSID = 0;
959 {
const char *
emsg =
"login requires TLS be enabled";
961 {
emsg =
"login requires TLS support";
971 uname[
sizeof(uname)-1] = 0;
977 "duplicate login; already logged in");
1044 if (pp && i ) {
if (!sendSID) rc =
Response.
Send((
void *)pp, i);
1045 else {
struct iovec
iov[3];
1046 iov[1].iov_base = (
char *)&sessID;
1047 iov[1].iov_len =
sizeof(sessID);
1048 iov[2].iov_base = (
char *)pp;
1054 else {rc = (sendSID ?
Response.
Send((
void *)&sessID,
sizeof(sessID))
1059 else {rc = (sendSID ?
Response.
Send((
void *)&sessID,
sizeof(sessID))
1077 char *rnumb = loginEnv.Get(
"xrd.rn");
1078 char *cCode = loginEnv.Get(
"xrd.cc");
1079 char *tzVal = loginEnv.Get(
"xrd.tz");
1080 char *appXQ = loginEnv.Get(
"xrd.appname");
1081 char *aInfo = loginEnv.Get(
"xrd.info");
1082 int tzNum = (tzVal ? atoi(tzVal) : 0);
1083 if (cCode && *cCode && tzNum >= -12 && tzNum <= 14)
1091 snprintf(apBuff,
sizeof(apBuff),
"&R=%s&x=%s&y=%s&I=%c",
1092 (rnumb ? rnumb :
""),
1093 (appXQ ? appXQ :
""), (aInfo ? aInfo :
""),
1099 {
int majr, minr, pchr;
1100 if (sscanf(rnumb,
"v%d.%d.%d", &majr, &minr, &pchr) == 3)
1101 clientRN = (majr<<16) | ((minr<<8) | pchr);
1102 else if (sscanf(rnumb,
"v%d-%*x", &majr) == 1)
clientRN = -1;
1104 if (appXQ)
AppName = strdup(appXQ);
1132 int XrdXrootdProtocol::do_Mkdir()
1165 int XrdXrootdProtocol::do_Mv()
1168 char *oldp, *newp, *Opaque, *Npaque;
1185 while(*newp && *newp !=
' ') newp++;
1186 if (*newp) {*newp =
'\0'; newp++;
1187 while(*newp && *newp ==
' ') newp++;
1193 if (rpCheck(oldp, &Opaque))
return rpEmsg(
"Renaming", oldp);
1194 if (rpCheck(newp, &Npaque))
return rpEmsg(
"Renaming to", newp);
1195 if (!Squash(oldp))
return vpEmsg(
"Renaming", oldp);
1196 if (!Squash(newp))
return vpEmsg(
"Renaming to", newp);
1206 TRACEP(FS,
"rc=" <<rc <<
" mv " <<oldp <<
' ' <<newp);
1218 int XrdXrootdProtocol::do_Offload(
int (
XrdXrootdProtocol::*Invoke)(),
int pathID)
1241 pp->
Resume = &XrdXrootdProtocol::do_OffloadIO;
1245 pp->
reTry = &isAvail;
1255 if ((pioP = pp->
pioFree))
break;
1256 pp->
reTry = &isAvail;
1258 TRACEP(FSZIO,
"busy path " <<pathID <<
" offs=" <<
IO.Offset);
1260 TRACEP(FSZIO,
"retry path " <<pathID <<
" offs=" <<
IO.Offset);
1271 pioP->
Set(Invoke,
IO, streamID);
1284 int XrdXrootdProtocol::do_OffloadIO()
1297 TRACEP(FSZIO,
"dispatch new I/O path " <<
PathID <<
" offs=" <<
IO.Offset);
1307 if (rc > 0 && !
isNOP)
1309 Resume = &XrdXrootdProtocol::do_OffloadIO;
1329 if (rc)
isNOP =
true;
1335 TRACEP(FSZIO,
"offload complete path "<<
PathID<<
" virt rc=" <<rc);
1336 return (rc ? rc : -EINPROGRESS);
1354 : fp(0), xp(0), Locker(lkP), path(fn), mode(0),
1360 else {
if (fp)
delete fp;
1361 if (mode) Locker->
Unlock(path,mode);
1368 int XrdXrootdProtocol::do_Open()
1372 int rc, mode,
opts, openopts, compchk = 0;
1373 int popt, retStat = 0;
1374 char *opaque,
usage, ebuff[2048], opC;
1375 bool doDig, doforce =
false, isAsync =
false;
1376 char *fn =
argp->
buff, opt[16], *op=opt;
1379 struct stat statbuf;
1381 int resplen =
sizeof(myResp.fhandle);
1382 struct iovec IOResp[3];
1395 mode = mapMode(mode) | S_IRUSR | S_IWUSR;
usage =
'r';
1431 {openopts |=
SFS_O_RAWIO; *op++ =
'c'; compchk = 1;}
1434 {*op++ =
'a'; isAsync =
true;}
1446 {
char* cgiP = index(fn,
'?');
1447 if (cgiP) *cgiP = 0;
1448 TRACEP(FS,
"open " <<opt <<
' ' <<fn);
1449 if (cgiP) *cgiP =
'?';
1454 if (rpCheck(fn, &opaque))
return rpEmsg(
"Opening", fn);
1464 if (!(popt = Squash(fn)))
return vpEmsg(
"Opening", fn);
1476 OpenHelper oHelp(
Locker, fn);
1483 if (rc > 0) who = (rc > 1 ?
"readers" :
"reader");
1485 who = (rc > 1 ?
"writers" :
"writer");
1487 snprintf(ebuff,
sizeof(ebuff)-1,
1488 "%s file %s is already opened by %d %s; open denied.",
1489 (
'r' ==
usage ?
"Input" :
"Output"), fn, rc, who);
1492 }
else oHelp.mode =
usage;
1503 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s",fn);
1522 (mode_t)mode,
CRED, opaque)))
1523 {rc = fsError(rc, opC, fp->
error, fn, opaque);
return rc;}
1529 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1547 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1561 if ((
'r' ==
usage && wrtrs) || (
'w' ==
usage && rdrs) || wrtrs > 1)
1562 {snprintf(ebuff,
sizeof(ebuff)-1,
1563 "%s file %s forced opened with %d reader(s) and %d writer(s).",
1564 (
'r' ==
usage ?
"Input" :
"Output"), fn, rdrs, wrtrs);
1571 memset(&myResp, 0,
sizeof(myResp));
1572 if (!compchk) resplen =
sizeof(myResp.fhandle);
1574 fp->
getCXinfo((
char *)myResp.cptype, cpsize);
1575 myResp.cpsize =
static_cast<kXR_int32>(htonl(cpsize));
1576 resplen =
sizeof(myResp);
1582 {retStat = StatGen(statbuf, ebuff,
sizeof(ebuff));
1583 IOResp[1].iov_base = (
char *)&myResp; IOResp[1].iov_len =
sizeof(myResp);
1584 IOResp[2].iov_base = ebuff; IOResp[2].iov_len = retStat;
1585 resplen =
sizeof(myResp) + retStat;
1604 memcpy((
void *)myResp.fhandle,(
const void *)&fhandle,
sizeof(myResp.fhandle));
1644 int XrdXrootdProtocol::do_Ping()
1660 int XrdXrootdProtocol::do_Prepare(
bool isQuery)
1673 int rc, pathnum = 0;
1674 char reqid[128], nidbuff[512], *path, *opaque, *prpid = 0;
1677 bool isCancel, isEvict, isPrepare;
1697 isPrepare = !(isCancel || isQuery);
1704 "Surpassed this connection's prepare limit.");
1722 if (isCancel || isQuery)
1723 {
if (!(prpid = pathlist.GetLine()))
1725 fsprep.
reqid = prpid;
1730 prpid =
PrepID->
isMine(prpid, hport, hname,
sizeof(hname));
1733 "Prepare requestid owned by an unknown server");
1735 << hname <<
':' <<hport);
1741 {prpid =
PrepID->
ID(reqid,
sizeof(reqid));
1742 fsprep.
reqid = reqid;
1745 reqid[0]=
'*'; reqid[1]=
'\0';
1746 fsprep.
reqid = prpid = reqid;
1759 while((path = pathlist.GetLine()))
1760 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Preparing", path);
1761 if (!Squash(path))
return vpEmsg(
"Preparing", path);
1763 (pLast ? (pLast->next = pP) : (pFirst = pP)); pLast = pP;
1765 (oLast ? (oLast->next = oP) : (oFirst = oP)); oLast = oP;
1768 fsprep.
paths = pFirst;
1769 fsprep.
oinfo = oFirst;
1793 char *mBuff = myError.getMsgBuff(rc);
1794 pargs.reqid = prpid;
1796 pargs.paths = pFirst;
1798 if (rc < 0) rc =
Response.
Send(
"No information found.");
1826 else snprintf(nidbuff,
sizeof(nidbuff),
"%s://%s:%d/",
1860 {pargs.reqid = prpid;
1862 pargs.paths = pFirst;
1879 int XrdXrootdProtocol::do_Protocol()
1890 bool wantTLS =
false;
1915 ioVec[iovN ].iov_base = (
void *)&theResp.
secreq;
1916 ioVec[iovN++].iov_len = n;
1942 theResp.
flags = (wantTLS ? theRlt : theRle);
1944 theResp.
flags = theRlf;
1950 theResp.
pval = verNum;
1958 if (rc == 0 && wantTLS)
1974 int XrdXrootdProtocol::do_Qconf()
1978 char *val, buff[4096], *bp=buff;
1979 int n, bleft =
sizeof(buff);
1983 if (!qcargs.GetLine() || !(val = qcargs.GetToken()))
1988 if (!strcmp(val,
"cmsd") || !strcmp(val,
"xrootd"))
1989 return do_QconfCX(qcargs, val);
1997 if (!strcmp(
"bind_max", val))
1998 {n = snprintf(bp, bleft,
"%d\n",
maxStreams-1);
1999 bp += n; bleft -= n;
2001 else if (!strcmp(
"chksum", val))
2002 {
const char *csList = getenv(
"XRD_CSLIST");
2004 {n = snprintf(bp, bleft,
"chksum\n");
2005 bp += n; bleft -= n;
2008 n = snprintf(bp, bleft,
"%s\n", csList);
2009 bp += n; bleft -= n;
2011 else if (!strcmp(
"cid", val))
2012 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2013 if (!cidval || !(*cidval)) cidval =
"cid";
2014 n = snprintf(bp, bleft,
"%s\n", cidval);
2015 bp += n; bleft -= n;
2017 else if (!strcmp(
"cms", val))
2020 n = snprintf(bp, bleft,
"%s\n", myError.getErrText());
2021 else n = snprintf(bp, bleft,
"%s\n",
"cms");
2022 bp += n; bleft -= n;
2024 else if (!strcmp(
"pio_max", val))
2025 {n = snprintf(bp, bleft,
"%d\n",
maxPio+1);
2026 bp += n; bleft -= n;
2028 else if (!strcmp(
"proxy", val))
2029 {
const char* pxyOrigin =
"proxy";
2031 {pxyOrigin = getenv(
"XRDXROOTD_PROXY");
2032 if (!pxyOrigin) pxyOrigin =
"proxy";
2034 n = snprintf(bp,bleft,
"%s\n",pxyOrigin);
2035 bp += n; bleft -= n;
2037 else if (!strcmp(
"readv_ior_max", val))
2039 bp += n; bleft -= n;
2041 else if (!strcmp(
"readv_iov_max", val))
2043 bp += n; bleft -= n;
2045 else if (!strcmp(
"role", val))
2046 {
const char *theRole = getenv(
"XRDROLE");
2047 n = snprintf(bp, bleft,
"%s\n", (theRole ? theRole :
"none"));
2048 bp += n; bleft -= n;
2050 else if (!strcmp(
"sitename", val))
2051 {
const char *siteName = getenv(
"XRDSITE");
2052 n = snprintf(bp, bleft,
"%s\n", (siteName ? siteName :
"sitename"));
2053 bp += n; bleft -= n;
2055 else if (!strcmp(
"start", val))
2056 {n = snprintf(bp, bleft,
"%s\n", startUP);
2057 bp += n; bleft -= n;
2059 else if (!strcmp(
"sysid", val))
2060 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2061 const char *nidval = getenv(
"XRDCMSVNID");
2062 if (!cidval || !(*cidval) || !nidval || !(*nidval))
2063 {cidval =
"sysid"; nidval =
"";}
2064 n = snprintf(bp, bleft,
"%s %s\n", nidval, cidval);
2065 bp += n; bleft -= n;
2067 else if (!strcmp(
"tpc", val))
2068 {
char *tpcval = getenv(
"XRDTPC");
2069 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpc"));
2070 bp += n; bleft -= n;
2072 else if (!strcmp(
"tpcdlg", val))
2073 {
char *tpcval = getenv(
"XRDTPCDLG");
2074 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpcdlg"));
2075 bp += n; bleft -= n;
2077 else if (!strcmp(
"tls_port", val) &&
tlsPort)
2078 {n = snprintf(bp, bleft,
"%d\n",
tlsPort);
2079 bp += n; bleft -= n;
2081 else if (!strcmp(
"window", val) &&
Window)
2082 {n = snprintf(bp, bleft,
"%d\n",
Window);
2083 bp += n; bleft -= n;
2085 else if (!strcmp(
"version", val))
2086 {n = snprintf(bp, bleft,
"%s\n", XrdVSTRING);
2087 bp += n; bleft -= n;
2089 else if (!strcmp(
"vnid", val))
2090 {
const char *nidval = getenv(
"XRDCMSVNID");
2091 if (!nidval || !(*nidval)) nidval =
"vnid";
2092 n = snprintf(bp, bleft,
"%s\n", nidval);
2094 else if (!strcmp(
"fattr", val))
2095 {n = snprintf(bp, bleft,
"%s\n",
usxParms);
2096 bp += n; bleft -= n;
2098 else {n = strlen(val);
2099 if (bleft <= n)
break;
2100 strcpy(bp, val); bp +=n; *bp =
'\n'; bp++;
2103 }
while(bleft > 0 && (val = qcargs.GetToken()));
2122 bool isCMSD = (*val ==
'c');
2147 int XrdXrootdProtocol::do_Qfh()
2152 const char *fArg = 0, *qType =
"";
2164 "query does not refer to an open file");
2184 "Required query argument not present");
2189 TRACEP(FS,
"fh=" <<fh.handle <<
" query " <<qType <<
" rc=" <<rc);
2202 int XrdXrootdProtocol::do_Qopaque(
short qopt)
2207 const char *Act, *AData;
2215 myData.Arg2 = 0; myData.
Arg2Len = 0;
2217 Act =
" qopaque '"; AData =
"...";
2232 myData.Arg2 = opaque;
2235 Act =
" qopaquf '"; AData =
argp->
buff;
2244 TRACEP(FS,
"rc=" <<rc <<Act <<AData <<
"'");
2246 return fsError(rc, 0, myError, 0, 0);
2253 int XrdXrootdProtocol::do_Qspace()
2274 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2289 int XrdXrootdProtocol::do_Query()
2306 case kXR_QPrep:
return do_Prepare(
true);
2313 "Invalid information query type code");
2320 int XrdXrootdProtocol::do_Qxattr()
2342 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2356 int XrdXrootdProtocol::do_Read()
2367 else if (do_ReadNone(retc, pathID))
return retc;
2378 "read does not refer to an open file");
2382 TRACEP(FSIO, pathID <<
" fh=" <<fh.handle <<
" read " <<
IO.
IOLen
2385 "Read length is negative");
2410 if (!pathID) pP =
this;
2411 else {
if (!(pP =
VerifyStream(retc, pathID,
false)))
return retc;
2426 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_ReadAll, pathID);
2430 return do_ReadAll();
2441 int XrdXrootdProtocol::do_ReadAll()
2476 {
if ((rc = getBuff(1, Quantum)) <= 0)
return rc;}
2487 IO.Offset += xframt;
IO.
IOLen -= xframt;
2501 int XrdXrootdProtocol::do_ReadNone(
int &retc,
int &pathID)
2510 pathID =
static_cast<int>(rargs->
pathid);
2511 if ((ralsz -=
sizeof(
read_args)) <= 0)
return 0;
2530 "preread does not refer to an open file");
2548 int XrdXrootdProtocol::do_ReadV()
2562 int rdVBeg, rdVBreak, rdVNow, rdVNum, rdVecNum;
2563 int currFH, i, k, Quantum, Qleft, rdVecLen =
Request.header.dlen;
2565 int ioMon = (rvMon > 1);
2566 char *buffp, vType = (ioMon ? XROOTD_MON_READU : XROOTD_MON_READV);
2571 rdVecNum = rdVecLen / sizeof(readahead_list);
2572 if ( (rdVecNum <= 0) || (rdVecNum*hdrSZ != rdVecLen) )
2573 return Response.Send(kXR_ArgInvalid, "Read vector is invalid");
2579 if (rdVecNum > XrdProto::maxRvecsz)
2580 return
Response.
Send(kXR_ArgTooLong, "Read vector is too long");
2590 raVec = (readahead_list *)
argp->buff;
2592 for (i = 0; i < rdVecNum; i++)
2593 {totSZ += (rdVec[i].size = ntohl(raVec[i].rlen));
2594 if (rdVec[i].size < 0) return Response.Send(kXR_ArgInvalid,
2595 "Readv length is negative");
2596 if (rdVec[i].size > Quantum) return Response.Send(kXR_NoMemory,
2597 "Single readv transfer is too large");
2598 rdVec[i].offset = ntohll(raVec[i].offset);
2599 memcpy(&rdVec[i].info, raVec[i].fhandle, sizeof(int));
2604 rdVec[i].offset = -1;
2607 rdVBreak = rdVecNum;
2612 if (totSZ > 0x7fffffffLL)
2613 return
Response.
Send(kXR_NoMemory, "Total readv transfer is too large");
2622 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->bsize)
2623 {
if ((k = getBuff(1, Quantum)) <= 0)
return k;}
2630 "readv does not refer to an open file");
2635 currFH = rdVec[0].info;
2636 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2638 "readv does not refer to an open file");
2643 rdVBeg = rdVNow = 0; rdVXfr = rdVAmt = 0;
2647 for (i = 0; i < rdVecNum; i++)
2648 {
if (rdVec[i].info != currFH)
2650 if (xfrSZ != rdVAmt)
break;
2651 rdVNum = i - rdVBeg; rdVXfr += rdVAmt;
2655 htons(rdVNum),
rvSeq, vType);
2656 if (ioMon)
for (k = rdVBeg; k < i; k++)
2658 htonl(rdVec[k].size), htonll(rdVec[k].offset));
2660 rdVXfr = rdVAmt = 0;
2661 if (i == rdVBreak)
break;
2662 rdVBeg = rdVNow = i; currFH = rdVec[i].info;
2663 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2666 "readv does not refer to an open file");
2669 if (Qleft < (rdVec[i].size + hdrSZ))
2672 if (xfrSZ != rdVAmt)
break;
2678 rdVNow = i; rdVXfr += rdVAmt; rdVAmt = 0;
2681 xfrSZ = rdVec[i].size; rdVAmt += xfrSZ;
2682 respHdr.rlen = htonl(xfrSZ);
2683 respHdr.offset = htonll(rdVec[i].offset);
2684 memcpy(buffp, &respHdr, hdrSZ);
2685 rdVec[i].data = buffp + hdrSZ;
2686 buffp += (xfrSZ+hdrSZ); Qleft -= (xfrSZ+hdrSZ);
2687 TRACEP(FSIO,
"fh=" <<currFH<<
" readV "<< xfrSZ <<
'@'<<rdVec[i].offset);
2709 int XrdXrootdProtocol::do_Rm()
2739 int XrdXrootdProtocol::do_Rmdir()
2769 int XrdXrootdProtocol::do_Set()
2776 if (!setargs.GetLine() || !(val = setargs.GetToken(&rest)))
2785 if (!strcmp(
"appid", val))
2786 {
while(*rest && *rest ==
' ') rest++;
2790 else if (!strcmp(
"monitor", val))
return do_Set_Mon(setargs);
2791 else if (!strcmp(
"cache", val))
return do_Set_Cache(setargs);
2808 char *cmd, *cargs, *opaque =
nullptr;
2809 const char *myArgs[2];
2818 if (!(cmd = setargs.
GetToken(&cargs)))
2823 if (cargs && *cargs ==
'/')
2824 {
if (rpCheck(cargs, &opaque))
return rpEmsg(
"Setting", cargs);
2825 if (!Squash(cargs))
return vpEmsg(
"Setting", cargs);
2826 myData.ArgP = myArgs; myData.
Arg2Len = -2;
2830 myData.Arg2 = opaque; myData.
Arg2Len = (opaque ? strlen(opaque) : 0);
2837 TRACEP(FS,
"rc=" <<rc <<
"set cache " <<myData.
Arg1 <<
' ' <<cargs);
2839 return fsError(rc, 0, myError, 0, 0);
2855 if (!(val = setargs.
GetToken(&appid)))
2862 if (!strcmp(val,
"info"))
2864 {
while(*appid && *appid ==
' ') appid++;
2865 if (strlen(appid) > 1024) appid[1024] =
'\0';
2873 if (!strcmp(val,
"on"))
2876 {
while(*appid && *appid ==
' ') appid++;
2885 if (!strcmp(val,
"off"))
2887 {
while(*appid && *appid ==
' ') appid++;
2903 int XrdXrootdProtocol::do_Stat()
2909 char *opaque, xxBuff[1024];
2928 "stat does not refer to an open file");
2932 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2955 memmove(&
argp->
buff[n+1], opaque, strlen(opaque)+1);
2965 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2974 int XrdXrootdProtocol::do_Statx()
2978 char *path, *opaque, *respinfo =
argp->
buff;
2989 while((path = pathlist.GetLine()))
2990 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Stating", path);
2991 if (!Squash(path))
return vpEmsg(
"Stating", path);
2993 TRACEP(FS,
"rc=" <<rc <<
" stat " <<path);
2996 else {
if (mode == (mode_t)-1) *respinfo = (char)
kXR_offline;
2997 else if (S_ISDIR(mode)) *respinfo = (
char)
kXR_isDir;
3012 int XrdXrootdProtocol::do_Sync()
3047 int XrdXrootdProtocol::do_Truncate()
3052 long long theOffset;
3071 "trunc does not refer to an open file");
3077 TRACEP(FS,
"fh=" <<fh.
handle <<
" trunc rc=" <<rc <<
" sz=" <<theOffset);
3098 TRACEP(FS,
"rc=" <<rc <<
" trunc " <<theOffset <<
' ' <<
argp->
buff);
3112 int XrdXrootdProtocol::do_Write()
3128 return do_WriteNone(pathID);
3135 "Write length is negative");
3154 {
if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAio,pathID);
3155 return do_WriteAio();
3163 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAll, pathID);
3167 return do_WriteAll();
3178 int XrdXrootdProtocol::do_WriteAio()
3188 return do_WriteAll();
3204 int XrdXrootdProtocol::do_WriteAll()
3211 {
if ((rc = getBuff(0, Quantum)) <= 0)
return rc;}
3219 {
Resume = &XrdXrootdProtocol::do_WriteCont;
3226 return do_WriteNone();
3228 IO.Offset += Quantum;
IO.
IOLen -= Quantum;
3246 int XrdXrootdProtocol::do_WriteCont()
3254 return do_WriteNone();
3260 if (
IO.
IOLen > 0)
return do_WriteAll();
3268 int XrdXrootdProtocol::do_WriteNone()
3270 char *buff, dbuff[4096];
3280 blen =
sizeof(dbuff);
3289 if (rlen < 0)
return Link->
setEtext(
"link read error");
3293 Resume = &XrdXrootdProtocol::do_WriteNone;
3301 return do_WriteNoneMsg();
3306 int XrdXrootdProtocol::do_WriteNone(
int pathID,
XErrorCode ec,
3314 else do_WriteNoneMsg();
3330 return do_WriteNone();
3337 int XrdXrootdProtocol::do_WriteNoneMsg()
3391 return do_WriteNone();
3397 if (
IO.
IOLen > 0)
return do_WriteAll();
3405 int XrdXrootdProtocol::do_WriteV()
3423 long long totSZ, maxSZ;
3429 wrVecNum = wrVecLen / wveSZ;
3430 if ( (wrVecLen <= 0) || (wrVecNum*wveSZ != wrVecLen) )
3456 totSZ = 0; maxSZ = 0; k = 0; Quantum =
maxTransz; curFH = 0;
3457 for (
int i = 0; i < wrVecNum; i++)
3458 {
if (wrLst[i].
wlen == 0)
continue;
3459 memcpy(&wrVec[k].info, wrLst[i].
fhandle,
sizeof(
int));
3460 wrVec[k].
size = ntohl(wrLst[i].
wlen);
3461 if (wrVec[k].size < 0)
3465 if (wrVec[k].size > Quantum)
3470 if (wrVec[k].info == curFH) totSZ += wrVec[k].
size;
3471 else {
if (maxSZ < totSZ) maxSZ = totSZ;
3472 totSZ = wrVec[k].
size;
3479 if (maxSZ < totSZ) maxSZ = totSZ;
3490 else Quantum =
static_cast<int>(maxSZ);
3494 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->
bsize)
3495 {
if (getBuff(0, Quantum) <= 0)
return -1;}
3524 freeInfo.doit =
false;
3533 int XrdXrootdProtocol::do_WriteVec()
3546 {
if (rc < 0)
return rc;
3548 Resume = &XrdXrootdProtocol::do_WriteVec;
3556 done = newfile =
false;
3576 if (done || newfile)
3593 if (xfrSZ< 0)
break;
3659 for (i = 1; i < sfvnum; i++) xframt += sfvec[i].sendsz;
3660 if (xframt >
IO.
IOLen)
return 1;
3676 else IO.
File->fdNum = fildes;
3686 int XrdXrootdProtocol::fsError(
int rc,
char opC,
XrdOucErrInfo &myError,
3687 const char *
Path,
char *Cgi)
3689 int ecode, popt, rs;
3701 return fsOvrld(opC,
Path, Cgi);
3711 if (Cgi) rs = fsRedirNoEnt(
eMsg, Cgi, popt);
3734 <<
eMsg <<
':' <<ecode);
3749 if (ecode <= 0) ecode = 1800;
3754 return (rc ? rc : 1);
3790 sprintf(buff,
"%d", rc);
3802 int XrdXrootdProtocol::fsOvrld(
char opC,
const char *
Path,
char *Cgi)
3804 static const char *prot =
"root://";
3805 static int negOne = -1;
3806 static char quest =
'?', slash =
'/';
3808 struct iovec rdrResp[8];
3809 char *destP=0, dest[512];
3810 int iovNum=0, pOff, port;
3818 { rdrResp[1].iov_base = (
char *)&negOne;
3819 rdrResp[1].iov_len =
sizeof(negOne);
3820 rdrResp[2].iov_base = (
char *)prot;
3821 rdrResp[2].iov_len = 7;
3822 rdrResp[3].iov_base = (
char *)dest;
3823 rdrResp[3].iov_len = strlen(dest);
3824 rdrResp[4].iov_base = (
char *)&slash;
3825 rdrResp[4].iov_len = (*
Path ==
'/' ? 1 : 0);
3826 rdrResp[5].iov_base = (
char *)(
Path+pOff);
3827 rdrResp[5].iov_len = strlen(
Path+pOff);
3829 {rdrResp[6].iov_base = (
char *)?
3830 rdrResp[6].iov_len =
sizeof(quest);
3831 rdrResp[7].iov_base = (
char *)Cgi;
3832 rdrResp[7].iov_len = strlen(Cgi);
3872 int XrdXrootdProtocol::fsRedirNoEnt(
const char *
eMsg,
char *Cgi,
int popt)
3874 struct iovec ioV[4];
3875 char *tried, *trend, *ptried = 0;
3882 {
do {
if (!(tried = strstr(Cgi,
"tried=")))
break;
3883 if (tried == trend || *(tried-1) ==
'&')
3884 {
if (!ptried || (*(tried+6) && *(tried+6) !=
'&')) ptried=tried;}
3885 Cgi = index(tried+6,
'&');
3892 if ((tried = ptried))
3894 while(*(tried+1) && *(tried+1) ==
',') tried++;
3895 trend = index(tried,
'&');
3896 if (trend) {tlen = trend - tried; *trend = 0;}
3897 else tlen = strlen(tried);
3904 if ((trend = tried) &&
eMsg)
3905 do {
if ((trend = strstr(trend,
myCName)))
3908 trend = index(trend+
myCNlen,
',');
3916 if (!tried || !tlen || tlen > 16384)
3924 ioV[1].iov_base = (
char *)&pnum;
3925 ioV[1].iov_len =
sizeof(pnum);
3928 ioV[3].iov_base = tried;
3929 ioV[3].iov_len = tlen;
3944 int XrdXrootdProtocol::getBuff(
const int isRead,
int Quantum)
3963 "insufficient memory to read file" :
3964 "insufficient memory to write file"));
3975 char *XrdXrootdProtocol::getCksType(
char *opaque,
char *cspec,
int cslen)
3981 if (opaque && *opaque)
3983 if ((cksT = jobEnv.Get(
"cks.type")))
3985 while(tP && strcasecmp(tP->
text, cksT)) tP = tP->
next;
3986 if (!tP && cspec) snprintf(cspec, cslen,
"%s", cksT);
3987 return (tP ? tP->
text : 0);
4000 bool XrdXrootdProtocol::logLogin(
bool xauth)
4002 const char *uName, *ipName, *tMsg, *zMsg =
"";
4003 char lBuff[512], pBuff[512];
4019 if (*tMsg) zMsg =
" ";
4023 snprintf(lBuff,
sizeof(lBuff),
"%s %s %s%slogin%s%s",
4026 (xauth ?
" as " :
""),
4027 (uName ? uName :
""));
4032 {snprintf(pBuff,
sizeof(pBuff),
"via %s auth for %s",
4050 eDest.
Emsg(
"Xeq",
"session requires TLS but",
Link->
ID,
"is incapable.");
4074 #define Map_Mode(x,y) if (Mode & kXR_ ## x) newmode |= S_I ## y
4076 int XrdXrootdProtocol::mapMode(
int Mode)
4098 const char *bP = Buff;
4101 else {snprintf(Buff,
sizeof(Buff),
4102 "&p=%s&n=%s&h=%s&o=%s&r=%s&g=%s&m=%s%s&I=%c",
4124 int XrdXrootdProtocol::rpCheck(
char *fn,
char **opaque)
4133 if (!(cp = index(fn,
'?'))) *opaque = 0;
4134 else {*cp =
'\0'; *opaque = cp+1;
4135 if (!**opaque) *opaque = 0;
4138 if (*fn !=
'/')
return 0;
4140 while ((cp = index(fn,
'/')))
4142 if (fn[0] ==
'.' && fn[1] ==
'.' && fn[2] ==
'/')
return 1;
4151 int XrdXrootdProtocol::rpEmsg(
const char *op,
char *fn)
4154 snprintf(buff,
sizeof(buff)-1,
"%s relative path '%s' is disallowed.",op,fn);
4155 buff[
sizeof(buff)-1] =
'\0';
4173 else if (theFile->fdNum >= 0) theFile->
sfEnabled = 1;
4184 int XrdXrootdProtocol::Squash(
char *fn)
4186 char *ofn, *ifn = fn;
4193 || (*(ifn+1) ==
'.' && *(ifn+1) && *(ifn+2) ==
'/'))
break;
4200 while(*ifn) {*ofn = *ifn++;
4202 {
while(*ifn ==
'/') ifn++;
4203 if (ifn[0] ==
'.' && ifn[1] ==
'/') ifn += 2;
4217 int XrdXrootdProtocol::vpEmsg(
const char *op,
char *fn)
4220 snprintf(buff,
sizeof(buff)-1,
"%s path '%s' is disallowed.",op,fn);
4221 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)
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