72#include "XrdVersion.hh"
75#define ENODATA ENOATTR
79#define ETIME ETIMEDOUT
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));
153static const char *startUP = getTime();
160int XrdXrootdProtocol::do_Auth()
183 sizeof(
Request.auth.credtype)))
185 size_t size =
sizeof(
Request.auth.credtype);
186 strncpy(
Entity.prot, (
const char *)
Request.auth.credtype, size);
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!");
233 SI->Bump(
SI->AuthBad);
234 eText =
eMsg.getErrText(rc);
235 eDest.Emsg(
"Xeq",
"User authentication failed;", eText);
243int XrdXrootdProtocol::do_Bind()
245 XrdXrootdSessID *sp = (XrdXrootdSessID *)
Request.bind.sessid;
249 char buff[64], *cp, *dp;
253 SI->Bump(
SI->miscCnt);
296 if (strcmp(
Link->Host(), lp->
Host()))
323 if ( (dp = rindex(cp,
'@'))) *dp =
'\0';
324 if (!(dp = rindex(cp,
'.'))) pPid = 0;
325 else {*dp++ =
'\0'; pPid = strtol(dp, (
char **)NULL, 10);}
326 Link->setID(cp, pPid);
343 sprintf(buff,
"FD %d#%d bound",
Link->FDnum(), i);
352 buff[0] =
static_cast<char>(i);
371int XrdXrootdProtocol::do_Chmod()
383 mode = mapMode((
int)ntohs(
Request.chmod.mode));
384 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Modifying",
argp->buff);
385 if (!Squash(
argp->buff))
return vpEmsg(
"Modifying",
argp->buff);
402int XrdXrootdProtocol::do_CKsum(
int canit)
405 char *algT =
JobCKT, *args[6];
419 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Check summing",
argp->buff);
420 if (!Squash(
argp->buff))
return vpEmsg(
"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;
458 args[2] =
argp->buff;
459 args[3] =
const_cast<char *
>(
Client->tident);
460 if (
Client->eaAPI->Get(std::string(
"request.name"), keyval) && !keyval.empty())
461 args[4] =
const_cast<char *
>(keyval.c_str());
467 args[1] =
argp->buff;
479int 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);
495 {
if (*csData ==
'!')
return Response.Send(csData+1);
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);
518int XrdXrootdProtocol::do_Close()
522 XrdXrootdFHandle fh(
Request.close.fhandle);
528 SI->Bump(
SI->miscCnt);
532 if (!
FTab || !(fp =
FTab->Get(fh.handle)))
534 "close does not refer to an open file");
544 if (fp->
pgwFob && !do_PgClose(fp, rc))
555 fp->cbArg =
ReqID.getID();
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);
602int XrdXrootdProtocol::do_Dirlist()
604 int bleft, rc = 0, dlen, cnt = 0;
605 char *opaque, *buff, ebuff[4096];
620 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Listing",
argp->buff);
621 if (!doDig && !Squash(
argp->buff))
return vpEmsg(
"Listing",
argp->buff);
631 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s",
argp->buff);
632 eDest.Emsg(
"Xeq", ebuff);
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);
673 {
if (ebuff == buff) rc =
Response.Send();
674 else {*(buff-1) =
'\0';
675 rc =
Response.Send((
void *)ebuff, buff-ebuff);
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);
724 {strcpy(pbuff,
argp->buff);
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);
779 TRACEP(FS,
"dirstat sofar n=" <<cnt <<
" path=" <<
argp->buff);
781 }
while(!rc && dname);
786 {
if (XB.ebuff == buff) rc =
Response.Send();
787 else {*(buff-1) =
'\0';
788 rc =
Response.Send((
void *)XB.ebuff, buff-XB.ebuff);
796 if (!rc) {
TRACEP(FS,
"dirstat entries=" <<cnt <<
" path=" <<
argp->buff);}
804int XrdXrootdProtocol::do_Endsess()
806 XrdXrootdSessID *sp, sessID;
811 SI->Bump(
SI->miscCnt);
815 sp = (XrdXrootdSessID *)
Request.endsess.sessid;
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)
831 || !(rc =
Link->Terminate(0, sessID.
FD, sessID.
Inst)))
return -1;
835 TRACEP(LOGIN,
"endsess " <<sessID.
Pid <<
':' <<sessID.
FD <<
'.' <<sessID.
Inst
836 <<
" rc=" <<rc <<
" (" <<
XrdSysE2T(rc < 0 ? -rc : EAGAIN) <<
")");
859int XrdXrootdProtocol::do_gpFile()
865 SI->Bump(
SI->getfCnt);
880int 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;
912 fn =
XPList.Next()->Path();
923 {
if (rpCheck(
Path, &opaque))
return rpEmsg(
"Locating",
Path);
924 if (!doDig && !Squash(
Path))
return vpEmsg(
"Locating",
Path);
929 if (doDig) rc =
digFS->fsctl(fsctl_cmd, fn, myError,
CRED);
931 {
int n = strlen(
argp->buff);
argp->buff[n] =
'?';
932 if ((
argp->buff)+n != opaque-1)
933 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
935 rc =
osFS->fsctl(fsctl_cmd, fn, myError,
CRED);
937 TRACEP(FS,
"rc=" <<rc <<
" locate " <<fn);
945int XrdXrootdProtocol::do_Login()
947 XrdXrootdSessID sessID;
948 XrdNetAddrInfo *addrP;
949 int i, pid, rc, sendSID = 0;
950 char uname[
sizeof(
Request.login.username)+1];
954 SI->Bump(
SI->LoginAT);
959 {
const char *
emsg =
"login requires TLS be enabled";
961 {
emsg =
"login requires TLS support";
962 eDest.Emsg(
"Xeq",
"login requires TLS but",
Link->ID,
"is incapable.");
969 pid = (int)ntohl(
Request.login.pid);
970 strncpy(uname, (
const char *)
Request.login.username,
sizeof(uname)-1);
971 uname[
sizeof(uname)-1] = 0;
977 "duplicate login; already logged in");
981 Link->setID(uname, pid);
987 {sessID.
FD =
Link->FDnum();
1021 addrP =
Link->AddrInfo();
1043 {
const char *pp=
CIA->getParms(i,
Link->AddrInfo());
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;
1050 rc =
Response.Send(iov,3,
int(i+
sizeof(sessID)));
1054 else {rc = (sendSID ?
Response.Send((
void *)&sessID,
sizeof(sessID))
1059 else {rc = (sendSID ?
Response.Send((
void *)&sessID,
sizeof(sessID))
1076 {XrdOucEnv loginEnv(
argp->buff+1,
Request.login.dlen-1);
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)
1084 {XrdNetAddrInfo::LocInfo locInfo;
1087 Link->setLocation(locInfo);
1089 if (
Monitor.Ready() && (appXQ || aInfo))
1091 snprintf(apBuff, sizeof(apBuff),
"&R=%s&x=%s&y=%s&I=%c",
1092 (rnumb ? rnumb :
""),
1093 (appXQ ? appXQ :
""), (aInfo ? aInfo :
""),
1094 (clientPV & XrdOucEI::uIPv4 ?
'4' :
'6'));
1095 Entity.moninfo = strdup(apBuff);
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);
1132int XrdXrootdProtocol::do_Mkdir()
1144 mode = mapMode((
int)ntohs(
Request.mkdir.mode)) | S_IRWXU;
1147 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Creating",
argp->buff);
1148 if (!Squash(
argp->buff))
return vpEmsg(
"Creating",
argp->buff);
1165int XrdXrootdProtocol::do_Mv()
1168 char *oldp, *newp, *Opaque, *Npaque;
1177 oldp = newp =
argp->buff;
1179 {
int n = ntohs(
Request.mv.arg1len);
1180 if (n < 0 || n >=
Request.mv.dlen || *(
argp->buff+n) !=
' ')
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);
1205 rc =
osFS->rename(oldp, newp, myError,
CRED, Opaque, Npaque);
1206 TRACEP(FS,
"rc=" <<rc <<
" mv " <<oldp <<
' ' <<newp);
1220 XrdSysSemaphore isAvail(0);
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);
1284int 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;
1325 else {rc = -1;
IO.File->Ref(-1);}
1329 if (rc)
isNOP =
true;
1331 Stream[0]->Link->setRef(-1);
1335 TRACEP(FSZIO,
"offload complete path "<<
PathID<<
" virt rc=" <<rc);
1336 return (rc ? rc : -EINPROGRESS);
1348 XrdXrootdFileLock *Locker;
1353 OpenHelper(XrdXrootdFileLock *lkP,
const char *fn)
1354 : fp(0), xp(0), Locker(lkP), path(fn), mode(0),
1360 else {
if (fp)
delete fp;
1361 if (mode) Locker->Unlock(path,mode);
1368int 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;
1380 struct ServerResponseBody_Open myResp;
1381 int resplen =
sizeof(myResp.fhandle);
1382 struct iovec IOResp[3];
1386 SI->Bump(
SI->openCnt);
1390 mode = (int)ntohs(
Request.open.mode);
1395 mode = mapMode(mode) | S_IRUSR | S_IWUSR;
usage =
'r';
1431 {openopts |=
SFS_O_RAWIO; *op++ =
'c'; compchk = 1;}
1434 {*op++ =
'a'; isAsync =
true;}
1436 SI->Bump(
SI->Refresh);
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);
1490 eDest.Emsg(
"Xeq", ebuff);
1492 }
else oHelp.mode =
usage;
1503 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s",fn);
1504 eDest.Emsg(
"Xeq", ebuff);
1522 (mode_t)mode,
CRED, opaque)))
1523 {rc = fsError(rc, opC, fp->
error, fn, opaque);
return rc;}
1527 xp =
new XrdXrootdFile(
Link->ID, fn, fp,
usage, isAsync, &statbuf);
1529 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1530 eDest.Emsg(
"Xeq", ebuff);
1546 if (!
FTab || (fhandle =
FTab->Add(xp)) < 0)
1547 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1548 eDest.Emsg(
"Xeq", ebuff);
1560 Locker->numLocks(fn, rdrs, wrtrs);
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);
1565 eDest.Emsg(
"Xeq", ebuff);
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));
1617 {
Stream[i]->pmDone =
true;
1636 if (retStat)
return Response.Send(IOResp, 3, resplen);
1637 else return Response.Send((
void *)&myResp, resplen);
1644int XrdXrootdProtocol::do_Ping()
1649 SI->Bump(
SI->miscCnt);
1660int XrdXrootdProtocol::do_Prepare(
bool isQuery)
1666 XrdOucTokenizer pathlist(
argp->buff);
1667 XrdOucTList *pFirst=0, *pP, *pLast = 0;
1668 XrdOucTList *oFirst=0, *oP, *oLast = 0;
1669 XrdOucTListHelper pHelp(&pFirst), oHelp(&oFirst);
1670 XrdXrootdPrepArgs pargs(0, 0);
1673 int rc, pathnum = 0;
1674 char reqid[128], nidbuff[512], *path, *opaque, *prpid = 0;
1675 unsigned short optX = ntohs(
Request.prepare.optionX);
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);
1762 pP =
new XrdOucTList(path, pathnum);
1763 (pLast ? (pLast->next = pP) : (pFirst = pP)); pLast = pP;
1764 oP =
new XrdOucTList(opaque, 0);
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;
1795 pargs.user =
Link->ID;
1796 pargs.paths = pFirst;
1798 if (rc < 0) rc =
Response.Send(
"No information found.");
1826 else snprintf(nidbuff,
sizeof(nidbuff),
"%s://%s:%d/",
1827 nprot,
Link->Host(), ntohs(
Request.prepare.port));
1858 else {rc =
Response.Send(reqid, strlen(reqid));
1860 {pargs.reqid = prpid;
1861 pargs.user =
Link->ID;
1862 pargs.paths = pFirst;
1879int XrdXrootdProtocol::do_Protocol()
1886 ServerResponseBody_Protocol theResp;
1890 bool wantTLS =
false;
1894 SI->Bump(
SI->miscCnt);
1898 if (
Request.protocol.clientpv)
1906 {
int k =(
Link->AddrInfo()->isPrivate() ? 1 : 0);
1914 {
int n =
DHS->ProtResp(theResp.
secreq, *(
Link->AddrInfo()), cvn);
1915 ioVec[iovN ].iov_base = (
void *)&theResp.
secreq;
1916 ioVec[iovN++].iov_len = n;
1921 {wantTLS = (
Request.protocol.flags &
1942 theResp.
flags = (wantTLS ? theRlt : theRle);
1944 theResp.
flags = theRlf;
1950 theResp.
pval = verNum;
1951 rc =
Response.Send(ioVec, iovN, RespLen);
1958 if (rc == 0 && wantTLS)
1960 {
Link->setProtName(
"xroots");
1963 eDest.Emsg(
"Xeq",
"Unable to enable TLS for",
Link->ID);
1974int XrdXrootdProtocol::do_Qconf()
1977 XrdOucTokenizer qcargs(
argp->buff);
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()));
2112 return Response.Send(buff,
sizeof(buff) - bleft);
2122 bool isCMSD = (*val ==
'c');
2131 if (isCMSD)
return Response.Send((
void *)
"\n", 2);
2140 return Response.Send((
void *)
"\n", 2);
2147int XrdXrootdProtocol::do_Qfh()
2150 XrdXrootdFHandle fh(
Request.query.fhandle);
2152 const char *fArg = 0, *qType =
"";
2154 short qopt = (short)ntohs(
Request.query.infotype);
2158 SI->Bump(
SI->miscCnt);
2162 if (!
FTab || !(fp =
FTab->Get(fh.handle)))
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);
2202int XrdXrootdProtocol::do_Qopaque(
short qopt)
2207 const char *Act, *AData;
2209 int fsctl_cmd, rc, dlen =
Request.query.dlen;
2215 myData.Arg2 = 0; myData.
Arg2Len = 0;
2217 Act =
" qopaque '"; AData =
"...";
2225 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Querying",
argp->buff);
2226 if (!Squash(
argp->buff))
return vpEmsg(
"Querying",
argp->buff);
2231 myData.
Arg1Len = (opaque ? opaque -
argp->buff - 1 : dlen);
2232 myData.Arg2 = opaque;
2233 myData.
Arg2Len = (opaque ?
argp->buff + dlen - opaque : 0);
2235 Act =
" qopaquf '"; AData =
argp->buff;
2239 myError.setErrCB(&qpqCB,
ReqID.getID());
2243 rc =
osFS->FSctl(fsctl_cmd, myData, myError,
CRED);
2244 TRACEP(FS,
"rc=" <<rc <<Act <<AData <<
"'");
2246 return fsError(rc, 0, myError, 0, 0);
2253int XrdXrootdProtocol::do_Qspace()
2266 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Stating",
argp->buff);
2267 if (!Squash(
argp->buff))
return vpEmsg(
"Stating",
argp->buff);
2272 {n = strlen(
argp->buff);
argp->buff[n] =
'?';
2273 if ((
argp->buff)+n != opaque-1)
2274 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
2279 rc =
osFS->fsctl(fsctl_cmd,
argp->buff, myError,
CRED);
2280 TRACEP(FS,
"rc=" <<rc <<
" qspace '" <<
argp->buff <<
"'");
2289int XrdXrootdProtocol::do_Query()
2291 short qopt = (short)ntohs(
Request.query.infotype);
2306 case kXR_QPrep:
return do_Prepare(
true);
2313 "Invalid information query type code");
2320int XrdXrootdProtocol::do_Qxattr()
2334 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Stating",
argp->buff);
2335 if (!Squash(
argp->buff))
return vpEmsg(
"Stating",
argp->buff);
2340 {
int n = strlen(
argp->buff);
argp->buff[n] =
'?';
2341 if ((
argp->buff)+n != opaque-1)
2342 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
2347 rc =
osFS->fsctl(fsctl_cmd,
argp->buff, myError,
CRED);
2348 TRACEP(FS,
"rc=" <<rc <<
" qxattr " <<
argp->buff);
2356int XrdXrootdProtocol::do_Read()
2359 XrdXrootdFHandle fh(
Request.read.fhandle);
2366 if (!
Request.header.dlen) pathID = 0;
2367 else if (do_ReadNone(retc, pathID))
return retc;
2376 if (!
FTab || !(
IO.File =
FTab->Get(fh.handle)))
2378 "read does not refer to an open file");
2382 TRACEP(FSIO, pathID <<
" fh=" <<fh.handle <<
" read " <<
IO.IOLen
2385 "Read length is negative");
2402 &&
IO.Offset+
IO.IOLen <=
IO.File->Stats.fSize)
2408 XrdXrootdNormAio *aioP;
2410 if (!pathID) pP =
this;
2411 else {
if (!(pP =
VerifyStream(retc, pathID,
false)))
return retc;
2415 {
if (!
IO.File->aioFob)
IO.File->aioFob =
new XrdXrootdAioFob;
2426 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_ReadAll, pathID);
2430 return do_ReadAll();
2441int XrdXrootdProtocol::do_ReadAll()
2450 {
if (
IO.Offset >=
IO.File->Stats.fSize)
return Response.Send();
2451 if (
IO.Offset+
IO.IOLen <=
IO.File->Stats.fSize)
2452 {
IO.File->Stats.rdOps(
IO.IOLen);
2455 xframt =
IO.File->Stats.fSize -
IO.Offset;
2456 IO.File->Stats.rdOps(xframt);
2457 return Response.Send(
IO.File->mmAddr+
IO.Offset, xframt);
2463 {
IO.File->Stats.rdOps(
IO.IOLen);
2464 if (
IO.File->fdNum >= 0)
2466 rc =
IO.File->XrdSfsp->SendData((
XrdSfsDio *)
this,
IO.Offset,
IO.IOLen);
2468 {
if (!
IO.IOLen)
return 0;
2469 if (
IO.IOLen < 0)
return -1;
2470 }
else return fsError(rc, 0,
IO.File->XrdSfsp->error, 0, 0);
2475 if (!
argp || Quantum < halfBSize || Quantum >
argp->bsize)
2476 {
if ((rc = getBuff(1, Quantum)) <= 0)
return rc;}
2483 IO.File->Stats.rdOps(
IO.IOLen);
2484 do {
if ((xframt =
IO.File->XrdSfsp->read(
IO.Offset, buff, Quantum)) <= 0)
break;
2485 if (xframt >=
IO.IOLen)
return Response.Send(buff, xframt);
2487 IO.Offset += xframt;
IO.IOLen -= xframt;
2488 if (
IO.IOLen < Quantum) Quantum =
IO.IOLen;
2493 if (xframt == 0)
return Response.Send();
2494 return fsError(xframt, 0,
IO.File->XrdSfsp->error, 0, 0);
2501int XrdXrootdProtocol::do_ReadNone(
int &retc,
int &pathID)
2503 XrdXrootdFHandle fh;
2504 int ralsz =
Request.header.dlen;
2505 struct read_args *rargs=(
struct read_args *)(
argp->buff);
2506 struct readahead_list *ralsp = (readahead_list *)(rargs+1);
2510 pathID =
static_cast<int>(rargs->
pathid);
2511 if ((ralsz -=
sizeof(read_args)) <= 0)
return 0;
2515 if (ralsz%
sizeof(readahead_list))
2523 {
IO.IOLen = ntohl(ralsp->
rlen);
2530 "preread does not refer to an open file");
2533 IO.File->XrdSfsp->read(
IO.Offset,
IO.IOLen);
2534 ralsz -=
sizeof(
struct readahead_list);
2548int XrdXrootdProtocol::do_ReadV()
2557 const int hdrSZ =
sizeof(readahead_list);
2558 struct XrdOucIOVec rdVec[XrdProto::maxRvecsz+1];
2559 struct readahead_list *raVec, respHdr;
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");
2642 Qleft = Quantum; buffp =
argp->buff;
rvSeq++;
2643 rdVBeg = rdVNow = 0; rdVXfr = rdVAmt = 0;
2647 for (i = 0; i < rdVecNum; i++)
2648 {
if (rdVec[i].info != currFH)
2649 {xfrSZ =
IO.File->XrdSfsp->readv(&rdVec[rdVNow], i-rdVNow);
2650 if (xfrSZ != rdVAmt)
break;
2651 rdVNum = i - rdVBeg; rdVXfr += rdVAmt;
2652 IO.File->Stats.rvOps(rdVXfr, rdVNum);
2654 {
Monitor.Agent->Add_rv(
IO.File->Stats.FileID, htonl(rdVXfr),
2655 htons(rdVNum),
rvSeq, vType);
2656 if (ioMon)
for (k = rdVBeg; k < i; k++)
2657 Monitor.Agent->Add_rd(
IO.File->Stats.FileID,
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));
2664 if (!(
IO.File =
FTab->Get(currFH)))
2666 "readv does not refer to an open file");
2669 if (Qleft < (rdVec[i].size + hdrSZ))
2671 {xfrSZ =
IO.File->XrdSfsp->readv(&rdVec[rdVNow], i-rdVNow);
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);
2695 IO.File->XrdSfsp->error.setErrInfo(-
ENODATA,
"readv past EOF");
2697 return fsError(xfrSZ, 0,
IO.File->XrdSfsp->error, 0, 0);
2702 return (Quantum != Qleft ?
Response.Send(
argp->buff, Quantum-Qleft) : 0);
2709int XrdXrootdProtocol::do_Rm()
2721 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Removing",
argp->buff);
2722 if (!Squash(
argp->buff))
return vpEmsg(
"Removing",
argp->buff);
2727 TRACEP(FS,
"rc=" <<rc <<
" rm " <<
argp->buff);
2739int XrdXrootdProtocol::do_Rmdir()
2751 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Removing",
argp->buff);
2752 if (!Squash(
argp->buff))
return vpEmsg(
"Removing",
argp->buff);
2757 TRACEP(FS,
"rc=" <<rc <<
" rmdir " <<
argp->buff);
2769int XrdXrootdProtocol::do_Set()
2771 XrdOucTokenizer setargs(
argp->buff);
2776 if (!setargs.GetLine() || !(val = setargs.GetToken(&rest)))
2785 if (!strcmp(
"appid", val))
2786 {
while(*rest && *rest ==
' ') rest++;
2787 eDest.Emsg(
"Xeq",
Link->ID,
"appid", 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';
2866 if (*appid) myseq =
Monitor.MapInfo(appid);
2868 return Response.Send((
void *)&myseq,
sizeof(myseq));
2873 if (!strcmp(val,
"on"))
2876 {
while(*appid && *appid ==
' ') appid++;
2877 if (*appid)
Monitor.Agent->appID(appid);
2885 if (!strcmp(val,
"off"))
2886 {
if (appid &&
Monitor.InOut())
2887 {
while(*appid && *appid ==
' ') appid++;
2888 if (*appid)
Monitor.Agent->appID(appid);
2903int XrdXrootdProtocol::do_Stat()
2909 char *opaque, xxBuff[1024];
2915 SI->Bump(
SI->miscCnt);
2921 XrdXrootdFHandle fh(
Request.stat.fhandle);
2928 "stat does not refer to an open file");
2932 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2946 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Stating",
argp->buff);
2947 if (!doDig && !Squash(
argp->buff))
return vpEmsg(
"Stating",
argp->buff);
2953 {
int n = strlen(
argp->buff);
argp->buff[n] =
'?';
2954 if ((
argp->buff)+n != opaque-1)
2955 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
2957 rc =
osFS->fsctl(fsctl_cmd,
argp->buff, myError,
CRED);
2958 TRACEP(FS,
"rc=" <<rc <<
" statfs " <<
argp->buff);
2961 if (doDig) rc =
digFS->stat(
argp->buff, &buf, myError,
CRED, opaque);
2962 else rc =
osFS->stat(
argp->buff, &buf, myError,
CRED, opaque);
2963 TRACEP(FS,
"rc=" <<rc <<
" stat " <<
argp->buff);
2965 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2974int XrdXrootdProtocol::do_Statx()
2978 char *path, *opaque, *respinfo =
argp->buff;
2981 XrdOucTokenizer pathlist(
argp->buff);
2989 while((path = pathlist.GetLine()))
2990 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Stating", path);
2991 if (!Squash(path))
return vpEmsg(
"Stating", path);
2992 rc =
osFS->stat(path, mode, myError,
CRED, opaque);
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;
3012int XrdXrootdProtocol::do_Sync()
3014 static XrdXrootdCallBack syncCB(
"sync", 0);
3017 XrdXrootdFHandle fh(
Request.sync.fhandle);
3021 SI->Bump(
SI->syncCnt);
3047int XrdXrootdProtocol::do_Truncate()
3049 static XrdXrootdCallBack truncCB(
"trunc", 0);
3051 XrdXrootdFHandle fh(
Request.truncate.fhandle);
3052 long long theOffset;
3057 n2hll(
Request.truncate.offset, theOffset);
3065 SI->Bump(
SI->miscCnt);
3071 "trunc does not refer to an open file");
3077 TRACEP(FS,
"fh=" <<fh.
handle <<
" trunc rc=" <<rc <<
" sz=" <<theOffset);
3091 if (rpCheck(
argp->buff,&opaque))
return rpEmsg(
"Truncating",
argp->buff);
3092 if (!Squash(
argp->buff))
return vpEmsg(
"Truncating",
argp->buff);
3098 TRACEP(FS,
"rc=" <<rc <<
" trunc " <<theOffset <<
' ' <<
argp->buff);
3112int XrdXrootdProtocol::do_Write()
3115 XrdXrootdFHandle fh(
Request.write.fhandle);
3122 pathID =
static_cast<int>(
Request.write.pathid);
3128 return do_WriteNone(pathID);
3133 TRACEP(FSIO, pathID<<
" fh="<<fh.
handle<<
" write "<<
IO.IOLen<<
'@'<<
IO.Offset);
3135 "Write length is negative");
3146 IO.File->Stats.wrOps(
IO.IOLen);
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();
3178int XrdXrootdProtocol::do_WriteAio()
3180 XrdXrootdNormAio *aioP;
3188 return do_WriteAll();
3193 return aioP->
Write(
IO.Offset,
IO.IOLen);
3204int XrdXrootdProtocol::do_WriteAll()
3210 if (!
argp || Quantum < halfBSize || Quantum >
argp->bsize)
3211 {
if ((rc = getBuff(0, Quantum)) <= 0)
return rc;}
3219 {
Resume = &XrdXrootdProtocol::do_WriteCont;
3224 if ((rc =
IO.File->XrdSfsp->write(
IO.Offset,
argp->buff, Quantum)) < 0)
3225 {
IO.IOLen =
IO.IOLen-Quantum;
IO.EInfo[0] = rc;
IO.EInfo[1] = 0;
3226 return do_WriteNone();
3228 IO.Offset += Quantum;
IO.IOLen -= Quantum;
3229 if (
IO.IOLen < Quantum) Quantum =
IO.IOLen;
3246int XrdXrootdProtocol::do_WriteCont()
3252 if ((rc =
IO.File->XrdSfsp->write(
IO.Offset,
argp->buff,
myBlast)) < 0)
3254 return do_WriteNone();
3260 if (
IO.IOLen > 0)
return do_WriteAll();
3268int XrdXrootdProtocol::do_WriteNone()
3270 char *buff, dbuff[4096];
3275 if (
argp &&
argp->bsize > (
int)
sizeof(dbuff))
3280 blen =
sizeof(dbuff);
3282 if (
IO.IOLen < blen) blen =
IO.IOLen;
3286 TRACEP(REQ,
"discarding " <<
IO.IOLen <<
" bytes");
3289 if (rlen < 0)
return Link->setEtext(
"link read error");
3293 Resume = &XrdXrootdProtocol::do_WriteNone;
3296 if (
IO.IOLen < blen) blen =
IO.IOLen;
3301 return do_WriteNoneMsg();
3306int XrdXrootdProtocol::do_WriteNone(
int pathID,
XErrorCode ec,
3314 else do_WriteNoneMsg();
3315 return Link->setEtext(
"write protocol violation");
3324 IO.File->XrdSfsp->error.setErrInfo(0,
emsg);
3330 return do_WriteNone();
3337int XrdXrootdProtocol::do_WriteNoneMsg()
3341 if (!
IO.File)
return
3346 IO.File->XrdSfsp->error.getErrText());
3348 if (
IO.EInfo[0])
return fsError(
IO.EInfo[0], 0,
IO.File->XrdSfsp->error, 0, 0);
3373 return do_WriteNone(
Request.write.pathid);
3381 IO.File->Stats.wrOps(
IO.IOLen);
3391 return do_WriteNone();
3397 if (
IO.IOLen > 0)
return do_WriteAll();
3405int XrdXrootdProtocol::do_WriteV()
3418 ~trackInfo() {
if (doit && *wvInfo) {free(*wvInfo); *wvInfo = 0;}}
3421 struct XrdProto::write_list *wrLst;
3423 long long totSZ, maxSZ;
3424 int curFH, k, Quantum, wrVecNum, wrVecLen =
Request.header.dlen;
3429 wrVecNum = wrVecLen / wveSZ;
3430 if ( (wrVecLen <= 0) || (wrVecNum*wveSZ != wrVecLen) )
3446 wvInfo = (XrdXrootdWVInfo *)malloc(
sizeof(XrdXrootdWVInfo) +
3447 sizeof(XrdOucIOVec)*(wrVecNum-1));
3448 memset(
wvInfo, 0,
sizeof(XrdXrootdWVInfo) -
sizeof(XrdOucIOVec));
3455 wrLst = (XrdProto::write_list *)
argp->buff;
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)
3469 wrVec[k].
offset = ntohll(wrLst[i].offset);
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;
3480 if (maxSZ == 0)
return Response.Send();
3490 else Quantum =
static_cast<int>(maxSZ);
3494 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->bsize)
3495 {
if (getBuff(0, Quantum) <= 0)
return -1;}
3500 if (!
FTab || !(
IO.File =
FTab->Get(wrVec[0].info)))
3517 IO.IOLen = wrVec[0].
size;
3524 freeInfo.doit =
false;
3533int XrdXrootdProtocol::do_WriteVec()
3536 int rc, wrVNum, vNow =
wvInfo->vPos;
3546 {
if (rc < 0)
return rc;
3548 Resume = &XrdXrootdProtocol::do_WriteVec;
3556 done = newfile =
false;
3557 if (vNow >=
wvInfo->vEnd) done =
true;
3558 else if (
wvInfo->wrVec[vNow].info !=
wvInfo->curFH) newfile =
true;
3560 {
IO.IOLen =
wvInfo->wrVec[vNow].size;
3568 wrVNum = vNow -
wvInfo->vBeg;
3569 xfrSZ =
IO.File->XrdSfsp->writev(&(
wvInfo->wrVec[
wvInfo->vBeg]), wrVNum);
3570 TRACEP(FSIO,
"fh=" <<
wvInfo->curFH <<
" writeV " << xfrSZ <<
':' <<wrVNum);
3576 if (done || newfile)
3577 {
int monVnum = vNow -
wvInfo->vMon;
3578 IO.File->Stats.wvOps(
IO.WVBytes, monVnum);
3591 {
IO.File->XrdSfsp->error.setErrCB(0,0);
3592 xfrSZ =
IO.File->XrdSfsp->sync();
3593 if (xfrSZ< 0)
break;
3618 IO.IOLen =
wvInfo->wrVec[vNow].size;
3627 return fsError((
int)xfrSZ, 0,
IO.File->XrdSfsp->error, 0, 0);
3639 if (!
IO.IOLen)
return 1;
3655 if (!
IO.IOLen)
return 1;
3659 for (i = 1; i < sfvnum; i++) xframt += sfvec[i].sendsz;
3660 if (xframt >
IO.IOLen)
return 1;
3664 if (xframt)
IO.IOLen =
Response.Send(sfvec, sfvnum, xframt);
3675 if (fildes < 0)
IO.File->sfEnabled = 0;
3676 else IO.File->fdNum = fildes;
3686int 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;
3750 TRACEI(STALL,
Response.ID() <<
"delaying client up to " <<ecode <<
" sec");
3754 return (rc ? rc : 1);
3769 {
if (ecode < 2) rs =
Response.Send();
3780 TRACEI(STALL,
Response.ID() <<
"stalling client for " <<rc <<
" sec");
3790 sprintf(buff,
"%d", rc);
3791 eDest.Emsg(
"Xeq",
"Unknown error code", buff,
eMsg);
3802int 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);
3850 TRACEI(REDIR,
Response.ID() <<
"redirecting to "<<destP<<
':'<<port);
3872int 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;
3944int XrdXrootdProtocol::getBuff(
const int isRead,
int Quantum)
3963 "insufficient memory to read file" :
3964 "insufficient memory to write file"));
3975char *XrdXrootdProtocol::getCksType(
char *opaque,
char *cspec,
int cslen)
3981 if (opaque && *opaque)
3982 {XrdOucEnv jobEnv(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);
4000bool XrdXrootdProtocol::logLogin(
bool xauth)
4002 const char *uName, *ipName, *tMsg, *zMsg =
"";
4003 char lBuff[512], pBuff[512];
4013 if (xauth) uName = (
Client->name ?
Client->name :
"nobody");
4018 tMsg =
Link->verTLS();
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",
4043 {
Link->setProtName(
"xroots");
4046 eDest.Emsg(
"Xeq",
"Unable to require TLS for",
Link->ID);
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
4076int 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",
4124int 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;
4151int 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;
4184int XrdXrootdProtocol::Squash(
char *fn)
4186 char *ofn, *ifn = fn;
4193 || (*(ifn+1) ==
'.' && *(ifn+1) && *(ifn+2) ==
'/'))
break;
4197 if (!*ifn)
return XPList.Validate(fn, ifn-fn);
4200 while(*ifn) {*ofn = *ifn++;
4202 {
while(*ifn ==
'/') ifn++;
4203 if (ifn[0] ==
'.' && ifn[1] ==
'/') ifn += 2;
4210 return XPList.Validate(fn, ofn-fn);
4217int 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';
#define kXR_ShortProtRespLen
#define kXR_PROTSIGNVERSION
#define kXR_PROTOCOLVERSION
ServerResponseReqs_Protocol secreq
XrdOucTrace * XrdXrootdTrace
XrdSecBuffer XrdSecParameters
XrdSecBuffer XrdSecCredentials
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
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
#define STATIC_REDIRECT(xfnc)
static const char * errName(kXR_int32 errCode)
static int mapError(int rc)
static const int ValuSize
static const int NameSize
static bool GetAssumeV4()
XrdJob(const char *desc="")
static XrdLink * fd2link(int fd)
char * ID
Pointer to the client's link identity.
XrdProtocol * getProtocol()
Obtain current protocol object pointer.
const char * Host() const
bool isIPType(IPType ipType) const
static bool getEA(const char *cgi, int &ecode, int &acode)
virtual void Done(int &Result, XrdOucErrInfo *eInfo, const char *Path=0)=0
void setErrCB(XrdOucEICB *cb, unsigned long long cbarg=0)
const char * getErrText()
void setUCap(int ucval)
Set user capabilties.
void Reset()
Reset object to no message state. Call this method to release appendages.
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)
XrdSfsDio()
Constructor and destructor.
virtual int autoStat(struct stat *buf)
virtual int open(const char *path, const XrdSecEntity *client=0, const char *opaque=0)=0
virtual const char * nextEntry()=0
virtual int open(const char *fileName, XrdSfsFileOpenMode openMode, mode_t createMode, const XrdSecEntity *client=0, const char *opaque=0)=0
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
static void Snooze(int seconds)
static void Open(XrdXrootdFileStats *fsP, const char *Path, unsigned int uDID, bool isRW)
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 struct XrdXrootdProtocol::RD_Table Route[RD_Num]
static XrdSecProtector * DHS
static XrdBuffManager * BPool
static XrdSecService * CIA
static RAtomic_int srvrAioOps
static uint64_t fsFeatures
static XrdOucReqID * PrepID
static XrdSfsFileSystem * osFS
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
char * buffer
Pointer to the buffer.
int size
Size of the buffer or length of data in the buffer.
static const int useBasic