72#include "XrdVersion.hh"
75#define ENODATA ENOATTR
79#define ETIME ETIMEDOUT
108static const int op_isOpen = 0x00010000;
109static const int op_isRead = 0x00020000;
118 if (gettimeofday(&tv, 0))
119 {perror(
"gettimeofday");
122 tmp = localtime(&tv.tv_sec);
124 {perror(
"localtime");
128 if (strftime(buff,
sizeof(buff),
"%y%m%d:%H%M%S. ", tmp) <= 0)
134 snprintf(tuff,
sizeof(tuff),
"%d",
static_cast<int>(tv.tv_usec/100000));
155static const char *startUP = getTime();
162int XrdXrootdProtocol::do_Auth()
185 sizeof(
Request.auth.credtype)))
187 size_t size =
sizeof(
Request.auth.credtype);
188 strncpy(
Entity.prot, (
const char *)
Request.auth.credtype, size);
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!");
235 SI->Bump(
SI->AuthBad);
236 eText =
eMsg.getErrText(rc);
237 eDest.Emsg(
"Xeq",
"User authentication failed;", eText);
245int XrdXrootdProtocol::do_Bind()
247 XrdXrootdSessID *sp = (XrdXrootdSessID *)
Request.bind.sessid;
251 char buff[64], *cp, *dp;
255 SI->Bump(
SI->miscCnt);
298 if (strcmp(
Link->Host(), lp->
Host()))
325 if ( (dp = rindex(cp,
'@'))) *dp =
'\0';
326 if (!(dp = rindex(cp,
'.'))) pPid = 0;
327 else {*dp++ =
'\0'; pPid = strtol(dp, (
char **)NULL, 10);}
328 Link->setID(cp, pPid);
345 sprintf(buff,
"FD %d#%d bound",
Link->FDnum(), i);
354 buff[0] =
static_cast<char>(i);
373int XrdXrootdProtocol::do_Chmod()
385 mode = mapMode((
int)ntohs(
Request.chmod.mode));
386 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Modifying",
argp->buff);
387 if (!Squash(
argp->buff))
return vpEmsg(
"Modifying",
argp->buff);
404int XrdXrootdProtocol::do_CKsum(
int canit)
407 char *algT =
JobCKT, *args[6];
421 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Check summing",
argp->buff);
422 if (!Squash(
argp->buff))
return vpEmsg(
"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;
460 args[2] =
argp->buff;
461 args[3] =
const_cast<char *
>(
Client->tident);
462 if (
Client->eaAPI->Get(std::string(
"request.name"), keyval) && !keyval.empty())
463 args[4] =
const_cast<char *
>(keyval.c_str());
469 args[1] =
argp->buff;
481int XrdXrootdProtocol::do_CKsum(
char *algT,
const char *
Path,
char *Opaque)
483 static char Space =
' ';
485 int CKTLen = strlen(algT);
487 myError,
CRED, Opaque);
488 const char *csData = myError.getErrText(
ec);
492 if (rc)
return fsError(rc, 0, myError,
Path, Opaque);
497 {
if (*csData ==
'!')
return Response.Send(csData+1);
498 struct iovec iov[4] = {{0,0}, {algT, (size_t)CKTLen}, {&Space, 1},
499 {(
char *)csData, strlen(csData)+1}};
506 {
const char *eTxt[2] = {
JobCKT,
" checksum not available."};
507 myError.setErrInfo(0, eTxt, 2);
520int XrdXrootdProtocol::do_Close()
524 XrdXrootdFHandle fh(
Request.close.fhandle);
530 SI->Bump(
SI->miscCnt);
534 if (!
FTab || !(fp =
FTab->Get(fh.handle)))
536 "close does not refer to an open file");
546 if (fp->
pgwFob && !do_PgClose(fp, rc))
557 fp->cbArg =
ReqID.getID();
571 rc = fp->XrdSfsp->close();
572 TRACEP(FS,
" fh=" <<fh.handle <<
" close rc=" <<rc);
576 return fsError(rc, 0, fp->XrdSfsp->error, 0, 0);
585 if (
SFS_OK != rc) retval = fsError(rc, 0, fp->XrdSfsp->error, 0, 0);
592 if (!doDel) fp->Ref(-1);
604int XrdXrootdProtocol::do_Dirlist()
606 int bleft, rc = 0, dlen, cnt = 0;
607 char *opaque, *buff, ebuff[4096];
622 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Listing",
argp->buff);
623 if (!doDig && !Squash(
argp->buff))
return vpEmsg(
"Listing",
argp->buff);
633 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s",
argp->buff);
634 eDest.Emsg(
"Xeq", ebuff);
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);
675 {
if (ebuff == buff) rc =
Response.Send();
676 else {*(buff-1) =
'\0';
677 rc =
Response.Send((
void *)ebuff, buff-ebuff);
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);
726 {strcpy(pbuff,
argp->buff);
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);
781 TRACEP(FS,
"dirstat sofar n=" <<cnt <<
" path=" <<
argp->buff);
783 }
while(!rc && dname);
788 {
if (XB.ebuff == buff) rc =
Response.Send();
789 else {*(buff-1) =
'\0';
790 rc =
Response.Send((
void *)XB.ebuff, buff-XB.ebuff);
798 if (!rc) {
TRACEP(FS,
"dirstat entries=" <<cnt <<
" path=" <<
argp->buff);}
806int XrdXrootdProtocol::do_Endsess()
808 XrdXrootdSessID *sp, sessID;
813 SI->Bump(
SI->miscCnt);
817 sp = (XrdXrootdSessID *)
Request.endsess.sessid;
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)
833 || !(rc =
Link->Terminate(0, sessID.
FD, sessID.
Inst)))
return -1;
837 TRACEP(LOGIN,
"endsess " <<sessID.
Pid <<
':' <<sessID.
FD <<
'.' <<sessID.
Inst
838 <<
" rc=" <<rc <<
" (" <<
XrdSysE2T(rc < 0 ? -rc : EAGAIN) <<
")");
861int XrdXrootdProtocol::do_gpFile()
867 SI->Bump(
SI->getfCnt);
882int XrdXrootdProtocol::do_Locate()
886 char *opaque = 0, *
Path, *fn =
argp->buff, opt[8], *op=opt;
903 TRACEP(FS,
"locate " <<opt <<
' ' <<fn);
907 if (*fn !=
'*'){
Path = fn;
910 else if (*(fn+1)) {
Path = fn+1;
914 fn =
XPList.Next()->Path();
925 {
if (rpCheck(
Path, &opaque))
return rpEmsg(
"Locating",
Path);
926 if (!doDig && !Squash(
Path))
return vpEmsg(
"Locating",
Path);
931 if (doDig) rc =
digFS->fsctl(fsctl_cmd, fn, myError,
CRED);
933 {
int n = strlen(
argp->buff);
argp->buff[n] =
'?';
934 if ((
argp->buff)+n != opaque-1)
935 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
937 rc =
osFS->fsctl(fsctl_cmd, fn, myError,
CRED);
939 TRACEP(FS,
"rc=" <<rc <<
" locate " <<fn);
947int XrdXrootdProtocol::do_Login()
949 XrdXrootdSessID sessID;
950 XrdNetAddrInfo *addrP;
951 int i, pid, rc, sendSID = 0;
952 char uname[
sizeof(
Request.login.username)+1];
956 SI->Bump(
SI->LoginAT);
961 {
const char *
emsg =
"login requires TLS be enabled";
963 {
emsg =
"login requires TLS support";
964 eDest.Emsg(
"Xeq",
"login requires TLS but",
Link->ID,
"is incapable.");
971 pid = (int)ntohl(
Request.login.pid);
972 strncpy(uname, (
const char *)
Request.login.username,
sizeof(uname)-1);
973 uname[
sizeof(uname)-1] = 0;
979 "duplicate login; already logged in");
983 Link->setID(uname, pid);
989 {sessID.
FD =
Link->FDnum();
1023 addrP =
Link->AddrInfo();
1045 {
const char *pp=
CIA->getParms(i,
Link->AddrInfo());
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;
1052 rc =
Response.Send(iov,3,
int(i+
sizeof(sessID)));
1056 else {rc = (sendSID ?
Response.Send((
void *)&sessID,
sizeof(sessID))
1061 else {rc = (sendSID ?
Response.Send((
void *)&sessID,
sizeof(sessID))
1078 {XrdOucEnv loginEnv(
argp->buff+1,
Request.login.dlen-1);
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)
1086 {XrdNetAddrInfo::LocInfo locInfo;
1089 Link->setLocation(locInfo);
1091 if (
Monitor.Ready() && (appXQ || aInfo))
1093 snprintf(apBuff, sizeof(apBuff),
"&R=%s&x=%s&y=%s&I=%c",
1094 (rnumb ? rnumb :
""),
1095 (appXQ ? appXQ :
""), (aInfo ? aInfo :
""),
1096 (clientPV & XrdOucEI::uIPv4 ?
'4' :
'6'));
1097 Entity.moninfo = strdup(apBuff);
1101 {
int majr, minr, pchr;
1102 if (sscanf(rnumb,
"v%d.%d.%d", &majr, &minr, &pchr) == 3)
1103 clientRN = (majr<<16) | ((minr<<8) | pchr);
1104 else if (sscanf(rnumb,
"v%d-%*x", &majr) == 1)
clientRN = -1;
1106 if (appXQ)
AppName = strdup(appXQ);
1134int XrdXrootdProtocol::do_Mkdir()
1146 mode = mapMode((
int)ntohs(
Request.mkdir.mode)) | S_IRWXU;
1149 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Creating",
argp->buff);
1150 if (!Squash(
argp->buff))
return vpEmsg(
"Creating",
argp->buff);
1167int XrdXrootdProtocol::do_Mv()
1170 char *oldp, *newp, *Opaque, *Npaque;
1179 oldp = newp =
argp->buff;
1181 {
int n = ntohs(
Request.mv.arg1len);
1182 if (n < 0 || n >=
Request.mv.dlen || *(
argp->buff+n) !=
' ')
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);
1207 rc =
osFS->rename(oldp, newp, myError,
CRED, Opaque, Npaque);
1208 TRACEP(FS,
"rc=" <<rc <<
" mv " <<oldp <<
' ' <<newp);
1222 XrdSysSemaphore isAvail(0);
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);
1286int XrdXrootdProtocol::do_OffloadIO()
1299 TRACEP(FSZIO,
"dispatch new I/O path " <<
PathID <<
" offs=" <<
IO.Offset);
1309 if (rc > 0 && !
isNOP)
1311 Resume = &XrdXrootdProtocol::do_OffloadIO;
1327 else {rc = -1;
IO.File->Ref(-1);}
1331 if (rc)
isNOP =
true;
1333 Stream[0]->Link->setRef(-1);
1337 TRACEP(FSZIO,
"offload complete path "<<
PathID<<
" virt rc=" <<rc);
1338 return (rc ? rc : -EINPROGRESS);
1350 XrdXrootdFileLock *Locker;
1355 OpenHelper(XrdXrootdFileLock *lkP,
const char *fn)
1356 : fp(0), xp(0), Locker(lkP), path(fn), mode(0),
1362 else {
if (fp)
delete fp;
1363 if (mode) Locker->Unlock(path,mode);
1370int XrdXrootdProtocol::do_Open()
1374 int rc, mode,
opts, openopts, compchk = 0;
1375 int popt, retStat = 0;
1376 char *opaque,
usage, ebuff[2048], opC;
1377 bool doDig, doforce =
false, isAsync =
false;
1378 char *fn =
argp->buff, opt[16], *op=opt;
1381 struct stat statbuf;
1382 struct ServerResponseBody_Open myResp;
1383 int resplen =
sizeof(myResp.fhandle);
1384 struct iovec IOResp[3];
1388 SI->Bump(
SI->openCnt);
1392 mode = (int)ntohs(
Request.open.mode);
1397 mode = mapMode(mode) | S_IRUSR | S_IWUSR;
usage =
'r';
1433 {openopts |=
SFS_O_RAWIO; *op++ =
'c'; compchk = 1;}
1436 {*op++ =
'a'; isAsync =
true;}
1438 SI->Bump(
SI->Refresh);
1448 {
char* cgiP = index(fn,
'?');
1449 if (cgiP) *cgiP = 0;
1450 TRACEP(FS,
"open " <<opt <<
' ' <<fn);
1451 if (cgiP) *cgiP =
'?';
1456 if (rpCheck(fn, &opaque))
return rpEmsg(
"Opening", fn);
1466 if (!(popt = Squash(fn)))
return vpEmsg(
"Opening", fn);
1478 OpenHelper oHelp(
Locker, fn);
1485 if (rc > 0) who = (rc > 1 ?
"readers" :
"reader");
1487 who = (rc > 1 ?
"writers" :
"writer");
1489 snprintf(ebuff,
sizeof(ebuff)-1,
1490 "%s file %s is already opened by %d %s; open denied.",
1491 (
'r' ==
usage ?
"Input" :
"Output"), fn, rc, who);
1492 eDest.Emsg(
"Xeq", ebuff);
1494 }
else oHelp.mode =
usage;
1505 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s",fn);
1506 eDest.Emsg(
"Xeq", ebuff);
1524 (mode_t)mode,
CRED, opaque)))
1525 {rc = fsError(rc, opC, fp->
error, fn, opaque);
return rc;}
1529 xp =
new XrdXrootdFile(
Link->ID, fn, fp,
usage, isAsync, &statbuf);
1531 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1532 eDest.Emsg(
"Xeq", ebuff);
1548 if (!
FTab || (fhandle =
FTab->Add(xp)) < 0)
1549 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1550 eDest.Emsg(
"Xeq", ebuff);
1562 Locker->numLocks(fn, rdrs, wrtrs);
1563 if ((
'r' ==
usage && wrtrs) || (
'w' ==
usage && rdrs) || wrtrs > 1)
1564 {snprintf(ebuff,
sizeof(ebuff)-1,
1565 "%s file %s forced opened with %d reader(s) and %d writer(s).",
1566 (
'r' ==
usage ?
"Input" :
"Output"), fn, rdrs, wrtrs);
1567 eDest.Emsg(
"Xeq", ebuff);
1573 memset(&myResp, 0,
sizeof(myResp));
1574 if (!compchk) resplen =
sizeof(myResp.fhandle);
1576 fp->
getCXinfo((
char *)myResp.cptype, cpsize);
1577 myResp.cpsize =
static_cast<kXR_int32>(htonl(cpsize));
1578 resplen =
sizeof(myResp);
1584 {retStat = StatGen(statbuf, ebuff,
sizeof(ebuff));
1585 IOResp[1].iov_base = (
char *)&myResp; IOResp[1].iov_len =
sizeof(myResp);
1586 IOResp[2].iov_base = ebuff; IOResp[2].iov_len = retStat;
1587 resplen =
sizeof(myResp) + retStat;
1606 memcpy((
void *)myResp.fhandle,(
const void *)&fhandle,
sizeof(myResp.fhandle));
1619 {
Stream[i]->pmDone =
true;
1638 if (retStat)
return Response.Send(IOResp, 3, resplen);
1639 else return Response.Send((
void *)&myResp, resplen);
1646int XrdXrootdProtocol::do_Ping()
1651 SI->Bump(
SI->miscCnt);
1662int XrdXrootdProtocol::do_Prepare(
bool isQuery)
1668 XrdOucTokenizer pathlist(
argp->buff);
1669 XrdOucTList *pFirst=0, *pP, *pLast = 0;
1670 XrdOucTList *oFirst=0, *oP, *oLast = 0;
1671 XrdOucTListHelper pHelp(&pFirst), oHelp(&oFirst);
1672 XrdXrootdPrepArgs pargs(0, 0);
1675 int rc, pathnum = 0;
1676 char reqid[128], nidbuff[512], *path, *opaque, *prpid = 0;
1677 unsigned short optX = ntohs(
Request.prepare.optionX);
1679 bool isCancel, isEvict, isPrepare;
1699 isPrepare = !(isCancel || isQuery);
1706 "Surpassed this connection's prepare limit.");
1724 if (isCancel || isQuery)
1725 {
if (!(prpid = pathlist.GetLine()))
1727 fsprep.
reqid = prpid;
1732 prpid =
PrepID->isMine(prpid, hport, hname,
sizeof(hname));
1735 "Prepare requestid owned by an unknown server");
1737 << hname <<
':' <<hport);
1743 {prpid =
PrepID->ID(reqid,
sizeof(reqid));
1744 fsprep.
reqid = reqid;
1747 reqid[0]=
'*'; reqid[1]=
'\0';
1748 fsprep.
reqid = prpid = reqid;
1761 while((path = pathlist.GetLine()))
1762 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Preparing", path);
1763 if (!Squash(path))
return vpEmsg(
"Preparing", path);
1764 pP =
new XrdOucTList(path, pathnum);
1765 (pLast ? (pLast->next = pP) : (pFirst = pP)); pLast = pP;
1766 oP =
new XrdOucTList(opaque, 0);
1767 (oLast ? (oLast->next = oP) : (oFirst = oP)); oLast = oP;
1770 fsprep.
paths = pFirst;
1771 fsprep.
oinfo = oFirst;
1795 char *mBuff = myError.getMsgBuff(rc);
1796 pargs.reqid = prpid;
1797 pargs.user =
Link->ID;
1798 pargs.paths = pFirst;
1800 if (rc < 0) rc =
Response.Send(
"No information found.");
1828 else snprintf(nidbuff,
sizeof(nidbuff),
"%s://%s:%d/",
1829 nprot,
Link->Host(), ntohs(
Request.prepare.port));
1860 else {rc =
Response.Send(reqid, strlen(reqid));
1862 {pargs.reqid = prpid;
1863 pargs.user =
Link->ID;
1864 pargs.paths = pFirst;
1881int XrdXrootdProtocol::do_Protocol()
1888 ServerResponseBody_Protocol theResp;
1892 bool wantTLS =
false;
1896 SI->Bump(
SI->miscCnt);
1900 if (
Request.protocol.clientpv)
1908 {
int k =(
Link->AddrInfo()->isPrivate() ? 1 : 0);
1916 {
int n =
DHS->ProtResp(theResp.
secreq, *(
Link->AddrInfo()), cvn);
1917 ioVec[iovN ].iov_base = (
void *)&theResp.
secreq;
1918 ioVec[iovN++].iov_len = n;
1923 {wantTLS = (
Request.protocol.flags &
1944 theResp.
flags = (wantTLS ? theRlt : theRle);
1946 theResp.
flags = theRlf;
1952 theResp.
pval = verNum;
1953 rc =
Response.Send(ioVec, iovN, RespLen);
1960 if (rc == 0 && wantTLS)
1962 {
Link->setProtName(
"xroots");
1965 eDest.Emsg(
"Xeq",
"Unable to enable TLS for",
Link->ID);
1976int XrdXrootdProtocol::do_Qconf()
1979 XrdOucTokenizer qcargs(
argp->buff);
1980 char *val, buff[4096], *bp=buff;
1981 int n, bleft =
sizeof(buff);
1985 if (!qcargs.GetLine() || !(val = qcargs.GetToken()))
1990 if (!strcmp(val,
"cmsd") || !strcmp(val,
"xrootd"))
1991 return do_QconfCX(qcargs, val);
1999 if (!strcmp(
"bind_max", val))
2000 {n = snprintf(bp, bleft,
"%d\n",
maxStreams-1);
2001 bp += n; bleft -= n;
2003 else if (!strcmp(
"chksum", val))
2004 {
const char *csList = getenv(
"XRD_CSLIST");
2006 {n = snprintf(bp, bleft,
"chksum\n");
2007 bp += n; bleft -= n;
2010 n = snprintf(bp, bleft,
"%s\n", csList);
2011 bp += n; bleft -= n;
2013 else if (!strcmp(
"cid", val))
2014 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2015 if (!cidval || !(*cidval)) cidval =
"cid";
2016 n = snprintf(bp, bleft,
"%s\n", cidval);
2017 bp += n; bleft -= n;
2019 else if (!strcmp(
"cms", val))
2022 n = snprintf(bp, bleft,
"%s\n", myError.getErrText());
2023 else n = snprintf(bp, bleft,
"%s\n",
"cms");
2024 bp += n; bleft -= n;
2026 else if (!strcmp(
"pio_max", val))
2027 {n = snprintf(bp, bleft,
"%d\n",
maxPio+1);
2028 bp += n; bleft -= n;
2030 else if (!strcmp(
"proxy", val))
2031 {
const char* pxyOrigin =
"proxy";
2033 {pxyOrigin = getenv(
"XRDXROOTD_PROXY");
2034 if (!pxyOrigin) pxyOrigin =
"proxy";
2036 n = snprintf(bp,bleft,
"%s\n",pxyOrigin);
2037 bp += n; bleft -= n;
2039 else if (!strcmp(
"readv_ior_max", val))
2041 bp += n; bleft -= n;
2043 else if (!strcmp(
"readv_iov_max", val))
2045 bp += n; bleft -= n;
2047 else if (!strcmp(
"role", val))
2048 {
const char *theRole = getenv(
"XRDROLE");
2049 n = snprintf(bp, bleft,
"%s\n", (theRole ? theRole :
"none"));
2050 bp += n; bleft -= n;
2052 else if (!strcmp(
"sitename", val))
2053 {
const char *siteName = getenv(
"XRDSITE");
2054 n = snprintf(bp, bleft,
"%s\n", (siteName ? siteName :
"sitename"));
2055 bp += n; bleft -= n;
2057 else if (!strcmp(
"start", val))
2058 {n = snprintf(bp, bleft,
"%s\n", startUP);
2059 bp += n; bleft -= n;
2061 else if (!strcmp(
"sysid", val))
2062 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2063 const char *nidval = getenv(
"XRDCMSVNID");
2064 if (!cidval || !(*cidval) || !nidval || !(*nidval))
2065 {cidval =
"sysid"; nidval =
"";}
2066 n = snprintf(bp, bleft,
"%s %s\n", nidval, cidval);
2067 bp += n; bleft -= n;
2069 else if (!strcmp(
"tpc", val))
2070 {
char *tpcval = getenv(
"XRDTPC");
2071 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpc"));
2072 bp += n; bleft -= n;
2074 else if (!strcmp(
"tpcdlg", val))
2075 {
char *tpcval = getenv(
"XRDTPCDLG");
2076 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpcdlg"));
2077 bp += n; bleft -= n;
2079 else if (!strcmp(
"tls_port", val) &&
tlsPort)
2080 {n = snprintf(bp, bleft,
"%d\n",
tlsPort);
2081 bp += n; bleft -= n;
2083 else if (!strcmp(
"window", val) &&
Window)
2084 {n = snprintf(bp, bleft,
"%d\n",
Window);
2085 bp += n; bleft -= n;
2087 else if (!strcmp(
"version", val))
2088 {n = snprintf(bp, bleft,
"%s\n", XrdVSTRING);
2089 bp += n; bleft -= n;
2091 else if (!strcmp(
"vnid", val))
2092 {
const char *nidval = getenv(
"XRDCMSVNID");
2093 if (!nidval || !(*nidval)) nidval =
"vnid";
2094 n = snprintf(bp, bleft,
"%s\n", nidval);
2096 else if (!strcmp(
"fattr", val))
2097 {n = snprintf(bp, bleft,
"%s\n",
usxParms);
2098 bp += n; bleft -= n;
2100 else {n = strlen(val);
2101 if (bleft <= n)
break;
2102 strcpy(bp, val); bp +=n; *bp =
'\n'; bp++;
2105 }
while(bleft > 0 && (val = qcargs.GetToken()));
2114 return Response.Send(buff,
sizeof(buff) - bleft);
2124 bool isCMSD = (*val ==
'c');
2133 if (isCMSD)
return Response.Send((
void *)
"\n", 2);
2142 return Response.Send((
void *)
"\n", 2);
2149int XrdXrootdProtocol::do_Qfh()
2152 XrdXrootdFHandle fh(
Request.query.fhandle);
2154 const char *fArg = 0, *qType =
"";
2156 short qopt = (short)ntohs(
Request.query.infotype);
2160 SI->Bump(
SI->miscCnt);
2164 if (!
FTab || !(fp =
FTab->Get(fh.handle)))
2166 "query does not refer to an open file");
2186 "Required query argument not present");
2191 TRACEP(FS,
"fh=" <<fh.handle <<
" query " <<qType <<
" rc=" <<rc);
2204int XrdXrootdProtocol::do_Qopaque(
short qopt)
2209 const char *Act, *AData;
2211 int fsctl_cmd, rc, dlen =
Request.query.dlen;
2217 myData.Arg2 = 0; myData.
Arg2Len = 0;
2219 Act =
" qopaque '"; AData =
"...";
2227 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Querying",
argp->buff);
2228 if (!Squash(
argp->buff))
return vpEmsg(
"Querying",
argp->buff);
2233 myData.
Arg1Len = (opaque ? opaque -
argp->buff - 1 : dlen);
2234 myData.Arg2 = opaque;
2235 myData.
Arg2Len = (opaque ?
argp->buff + dlen - opaque : 0);
2237 Act =
" qopaquf '"; AData =
argp->buff;
2241 myError.setErrCB(&qpqCB,
ReqID.getID());
2245 rc =
osFS->FSctl(fsctl_cmd, myData, myError,
CRED);
2246 TRACEP(FS,
"rc=" <<rc <<Act <<AData <<
"'");
2248 return fsError(rc, 0, myError, 0, 0);
2255int XrdXrootdProtocol::do_Qspace()
2268 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Stating",
argp->buff);
2269 if (!Squash(
argp->buff))
return vpEmsg(
"Stating",
argp->buff);
2274 {n = strlen(
argp->buff);
argp->buff[n] =
'?';
2275 if ((
argp->buff)+n != opaque-1)
2276 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
2281 rc =
osFS->fsctl(fsctl_cmd,
argp->buff, myError,
CRED);
2282 TRACEP(FS,
"rc=" <<rc <<
" qspace '" <<
argp->buff <<
"'");
2291int XrdXrootdProtocol::do_Query()
2293 short qopt = (short)ntohs(
Request.query.infotype);
2308 case kXR_QPrep:
return do_Prepare(
true);
2315 "Invalid information query type code");
2322int XrdXrootdProtocol::do_Qxattr()
2336 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Stating",
argp->buff);
2337 if (!Squash(
argp->buff))
return vpEmsg(
"Stating",
argp->buff);
2342 {
int n = strlen(
argp->buff);
argp->buff[n] =
'?';
2343 if ((
argp->buff)+n != opaque-1)
2344 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
2349 rc =
osFS->fsctl(fsctl_cmd,
argp->buff, myError,
CRED);
2350 TRACEP(FS,
"rc=" <<rc <<
" qxattr " <<
argp->buff);
2358int XrdXrootdProtocol::do_Read()
2361 XrdXrootdFHandle fh(
Request.read.fhandle);
2368 if (!
Request.header.dlen) pathID = 0;
2369 else if (do_ReadNone(retc, pathID))
return retc;
2378 if (!
FTab || !(
IO.File =
FTab->Get(fh.handle)))
2380 "read does not refer to an open file");
2384 TRACEP(FSIO, pathID <<
" fh=" <<fh.handle <<
" read " <<
IO.IOLen
2387 "Read length is negative");
2404 &&
IO.Offset+
IO.IOLen <=
IO.File->Stats.fSize)
2410 XrdXrootdNormAio *aioP;
2412 if (!pathID) pP =
this;
2413 else {
if (!(pP =
VerifyStream(retc, pathID,
false)))
return retc;
2417 {
if (!
IO.File->aioFob)
IO.File->aioFob =
new XrdXrootdAioFob;
2428 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_ReadAll, pathID);
2432 return do_ReadAll();
2443int XrdXrootdProtocol::do_ReadAll()
2452 {
if (
IO.Offset >=
IO.File->Stats.fSize)
return Response.Send();
2453 if (
IO.Offset+
IO.IOLen <=
IO.File->Stats.fSize)
2454 {
IO.File->Stats.rdOps(
IO.IOLen);
2457 xframt =
IO.File->Stats.fSize -
IO.Offset;
2458 IO.File->Stats.rdOps(xframt);
2459 return Response.Send(
IO.File->mmAddr+
IO.Offset, xframt);
2465 {
IO.File->Stats.rdOps(
IO.IOLen);
2466 if (
IO.File->fdNum >= 0)
2468 rc =
IO.File->XrdSfsp->SendData((
XrdSfsDio *)
this,
IO.Offset,
IO.IOLen);
2470 {
if (!
IO.IOLen)
return 0;
2471 if (
IO.IOLen < 0)
return -1;
2472 }
else return fsError(rc, 0,
IO.File->XrdSfsp->error, 0, 0);
2477 if (!
argp || Quantum < halfBSize || Quantum >
argp->bsize)
2478 {
if ((rc = getBuff(1, Quantum)) <= 0)
return rc;}
2485 IO.File->Stats.rdOps(
IO.IOLen);
2486 do {
if ((xframt =
IO.File->XrdSfsp->read(
IO.Offset, buff, Quantum)) <= 0)
break;
2487 if (xframt >=
IO.IOLen)
return Response.Send(buff, xframt);
2489 IO.Offset += xframt;
IO.IOLen -= xframt;
2490 if (
IO.IOLen < Quantum) Quantum =
IO.IOLen;
2495 if (xframt == 0)
return Response.Send();
2496 return fsError(xframt, 0,
IO.File->XrdSfsp->error, 0, 0);
2503int XrdXrootdProtocol::do_ReadNone(
int &retc,
int &pathID)
2505 XrdXrootdFHandle fh;
2506 int ralsz =
Request.header.dlen;
2507 struct read_args *rargs=(
struct read_args *)(
argp->buff);
2508 struct readahead_list *ralsp = (readahead_list *)(rargs+1);
2512 pathID =
static_cast<int>(rargs->
pathid);
2513 if ((ralsz -=
sizeof(read_args)) <= 0)
return 0;
2517 if (ralsz%
sizeof(readahead_list))
2525 {
IO.IOLen = ntohl(ralsp->
rlen);
2532 "preread does not refer to an open file");
2535 IO.File->XrdSfsp->read(
IO.Offset,
IO.IOLen);
2536 ralsz -=
sizeof(
struct readahead_list);
2550int XrdXrootdProtocol::do_ReadV()
2559 const int hdrSZ =
sizeof(readahead_list);
2560 struct XrdOucIOVec rdVec[XrdProto::maxRvecsz+1];
2561 struct readahead_list *raVec, respHdr;
2564 int rdVBeg, rdVBreak, rdVNow, rdVNum, rdVecNum;
2565 int currFH, i, k, Quantum, Qleft, rdVecLen =
Request.header.dlen;
2567 int ioMon = (rvMon > 1);
2568 char *buffp, vType = (ioMon ? XROOTD_MON_READU : XROOTD_MON_READV);
2573 rdVecNum = rdVecLen / sizeof(readahead_list);
2574 if ( (rdVecNum <= 0) || (rdVecNum*hdrSZ != rdVecLen) )
2575 return Response.Send(kXR_ArgInvalid, "Read vector is invalid");
2581 if (rdVecNum > XrdProto::maxRvecsz)
2582 return
Response.
Send(kXR_ArgTooLong, "Read vector is too long");
2592 raVec = (readahead_list *)
argp->buff;
2594 for (i = 0; i < rdVecNum; i++)
2595 {totSZ += (rdVec[i].size = ntohl(raVec[i].rlen));
2596 if (rdVec[i].size < 0) return Response.Send(kXR_ArgInvalid,
2597 "Readv length is negative");
2598 if (rdVec[i].size > Quantum) return Response.Send(kXR_NoMemory,
2599 "Single readv transfer is too large");
2600 rdVec[i].offset = ntohll(raVec[i].offset);
2601 memcpy(&rdVec[i].info, raVec[i].fhandle, sizeof(int));
2606 rdVec[i].offset = -1;
2609 rdVBreak = rdVecNum;
2614 if (totSZ > 0x7fffffffLL)
2615 return
Response.
Send(kXR_NoMemory, "Total readv transfer is too large");
2624 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->bsize)
2625 {
if ((k = getBuff(1, Quantum)) <= 0)
return k;}
2632 "readv does not refer to an open file");
2637 currFH = rdVec[0].info;
2638 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2640 "readv does not refer to an open file");
2644 Qleft = Quantum; buffp =
argp->buff;
rvSeq++;
2645 rdVBeg = rdVNow = 0; rdVXfr = rdVAmt = 0;
2649 for (i = 0; i < rdVecNum; i++)
2650 {
if (rdVec[i].info != currFH)
2651 {xfrSZ =
IO.File->XrdSfsp->readv(&rdVec[rdVNow], i-rdVNow);
2652 if (xfrSZ != rdVAmt)
break;
2653 rdVNum = i - rdVBeg; rdVXfr += rdVAmt;
2654 IO.File->Stats.rvOps(rdVXfr, rdVNum);
2656 {
Monitor.Agent->Add_rv(
IO.File->Stats.FileID, htonl(rdVXfr),
2657 htons(rdVNum),
rvSeq, vType);
2658 if (ioMon)
for (k = rdVBeg; k < i; k++)
2659 Monitor.Agent->Add_rd(
IO.File->Stats.FileID,
2660 htonl(rdVec[k].size), htonll(rdVec[k].offset));
2662 rdVXfr = rdVAmt = 0;
2663 if (i == rdVBreak)
break;
2664 rdVBeg = rdVNow = i; currFH = rdVec[i].info;
2665 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2666 if (!(
IO.File =
FTab->Get(currFH)))
2668 "readv does not refer to an open file");
2671 if (Qleft < (rdVec[i].size + hdrSZ))
2673 {xfrSZ =
IO.File->XrdSfsp->readv(&rdVec[rdVNow], i-rdVNow);
2674 if (xfrSZ != rdVAmt)
break;
2680 rdVNow = i; rdVXfr += rdVAmt; rdVAmt = 0;
2683 xfrSZ = rdVec[i].size; rdVAmt += xfrSZ;
2684 respHdr.rlen = htonl(xfrSZ);
2685 respHdr.offset = htonll(rdVec[i].offset);
2686 memcpy(buffp, &respHdr, hdrSZ);
2687 rdVec[i].data = buffp + hdrSZ;
2688 buffp += (xfrSZ+hdrSZ); Qleft -= (xfrSZ+hdrSZ);
2689 TRACEP(FSIO,
"fh=" <<currFH<<
" readV "<< xfrSZ <<
'@'<<rdVec[i].offset);
2697 IO.File->XrdSfsp->error.setErrInfo(-
ENODATA,
"readv past EOF");
2699 return fsError(xfrSZ, 0,
IO.File->XrdSfsp->error, 0, 0);
2704 return (Quantum != Qleft ?
Response.Send(
argp->buff, Quantum-Qleft) : 0);
2711int XrdXrootdProtocol::do_Rm()
2723 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Removing",
argp->buff);
2724 if (!Squash(
argp->buff))
return vpEmsg(
"Removing",
argp->buff);
2729 TRACEP(FS,
"rc=" <<rc <<
" rm " <<
argp->buff);
2741int XrdXrootdProtocol::do_Rmdir()
2753 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Removing",
argp->buff);
2754 if (!Squash(
argp->buff))
return vpEmsg(
"Removing",
argp->buff);
2759 TRACEP(FS,
"rc=" <<rc <<
" rmdir " <<
argp->buff);
2771int XrdXrootdProtocol::do_Set()
2773 XrdOucTokenizer setargs(
argp->buff);
2778 if (!setargs.GetLine() || !(val = setargs.GetToken(&rest)))
2787 if (!strcmp(
"appid", val))
2788 {
while(*rest && *rest ==
' ') rest++;
2789 eDest.Emsg(
"Xeq",
Link->ID,
"appid", rest);
2792 else if (!strcmp(
"monitor", val))
return do_Set_Mon(setargs);
2793 else if (!strcmp(
"cache", val))
return do_Set_Cache(setargs);
2810 char *cmd, *cargs, *opaque;
2811 const char *myArgs[2];
2820 if (!(cmd = setargs.
GetToken(&cargs)))
2825 if (cargs && *cargs ==
'/')
2826 {
if (rpCheck(cargs, &opaque))
return rpEmsg(
"Setting", cargs);
2827 if (!Squash(cargs))
return vpEmsg(
"Setting", cargs);
2828 myData.ArgP = myArgs; myData.
Arg2Len = -2;
2832 myData.Arg2 = opaque; myData.
Arg2Len = (opaque ? strlen(opaque) : 0);
2839 TRACEP(FS,
"rc=" <<rc <<
"set cache " <<myData.
Arg1 <<
' ' <<cargs);
2841 return fsError(rc, 0, myError, 0, 0);
2857 if (!(val = setargs.
GetToken(&appid)))
2864 if (!strcmp(val,
"info"))
2866 {
while(*appid && *appid ==
' ') appid++;
2867 if (strlen(appid) > 1024) appid[1024] =
'\0';
2868 if (*appid) myseq =
Monitor.MapInfo(appid);
2870 return Response.Send((
void *)&myseq,
sizeof(myseq));
2875 if (!strcmp(val,
"on"))
2878 {
while(*appid && *appid ==
' ') appid++;
2879 if (*appid)
Monitor.Agent->appID(appid);
2887 if (!strcmp(val,
"off"))
2888 {
if (appid &&
Monitor.InOut())
2889 {
while(*appid && *appid ==
' ') appid++;
2890 if (*appid)
Monitor.Agent->appID(appid);
2905int XrdXrootdProtocol::do_Stat()
2911 char *opaque, xxBuff[1024];
2917 SI->Bump(
SI->miscCnt);
2923 XrdXrootdFHandle fh(
Request.stat.fhandle);
2930 "stat does not refer to an open file");
2934 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2948 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Stating",
argp->buff);
2949 if (!doDig && !Squash(
argp->buff))
return vpEmsg(
"Stating",
argp->buff);
2955 {
int n = strlen(
argp->buff);
argp->buff[n] =
'?';
2956 if ((
argp->buff)+n != opaque-1)
2957 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
2959 rc =
osFS->fsctl(fsctl_cmd,
argp->buff, myError,
CRED);
2960 TRACEP(FS,
"rc=" <<rc <<
" statfs " <<
argp->buff);
2963 if (doDig) rc =
digFS->stat(
argp->buff, &buf, myError,
CRED, opaque);
2964 else rc =
osFS->stat(
argp->buff, &buf, myError,
CRED, opaque);
2965 TRACEP(FS,
"rc=" <<rc <<
" stat " <<
argp->buff);
2967 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2976int XrdXrootdProtocol::do_Statx()
2980 char *path, *opaque, *respinfo =
argp->buff;
2983 XrdOucTokenizer pathlist(
argp->buff);
2991 while((path = pathlist.GetLine()))
2992 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Stating", path);
2993 if (!Squash(path))
return vpEmsg(
"Stating", path);
2994 rc =
osFS->stat(path, mode, myError,
CRED, opaque);
2995 TRACEP(FS,
"rc=" <<rc <<
" stat " <<path);
2998 else {
if (mode == (mode_t)-1) *respinfo = (char)
kXR_offline;
2999 else if (S_ISDIR(mode)) *respinfo = (char)
kXR_isDir;
3014int XrdXrootdProtocol::do_Sync()
3016 static XrdXrootdCallBack syncCB(
"sync", 0);
3019 XrdXrootdFHandle fh(
Request.sync.fhandle);
3023 SI->Bump(
SI->syncCnt);
3049int XrdXrootdProtocol::do_Truncate()
3051 static XrdXrootdCallBack truncCB(
"trunc", 0);
3053 XrdXrootdFHandle fh(
Request.truncate.fhandle);
3054 long long theOffset;
3059 n2hll(
Request.truncate.offset, theOffset);
3067 SI->Bump(
SI->miscCnt);
3073 "trunc does not refer to an open file");
3079 TRACEP(FS,
"fh=" <<fh.
handle <<
" trunc rc=" <<rc <<
" sz=" <<theOffset);
3093 if (rpCheck(
argp->buff,&opaque))
return rpEmsg(
"Truncating",
argp->buff);
3094 if (!Squash(
argp->buff))
return vpEmsg(
"Truncating",
argp->buff);
3100 TRACEP(FS,
"rc=" <<rc <<
" trunc " <<theOffset <<
' ' <<
argp->buff);
3114int XrdXrootdProtocol::do_Write()
3117 XrdXrootdFHandle fh(
Request.write.fhandle);
3124 pathID =
static_cast<int>(
Request.write.pathid);
3130 return do_WriteNone(pathID);
3135 TRACEP(FSIO, pathID<<
" fh="<<fh.
handle<<
" write "<<
IO.IOLen<<
'@'<<
IO.Offset);
3137 "Write length is negative");
3148 IO.File->Stats.wrOps(
IO.IOLen);
3156 {
if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAio,pathID);
3157 return do_WriteAio();
3165 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAll, pathID);
3169 return do_WriteAll();
3180int XrdXrootdProtocol::do_WriteAio()
3182 XrdXrootdNormAio *aioP;
3190 return do_WriteAll();
3195 return aioP->
Write(
IO.Offset,
IO.IOLen);
3206int XrdXrootdProtocol::do_WriteAll()
3212 if (!
argp || Quantum < halfBSize || Quantum >
argp->bsize)
3213 {
if ((rc = getBuff(0, Quantum)) <= 0)
return rc;}
3221 {
Resume = &XrdXrootdProtocol::do_WriteCont;
3226 if ((rc =
IO.File->XrdSfsp->write(
IO.Offset,
argp->buff, Quantum)) < 0)
3227 {
IO.IOLen =
IO.IOLen-Quantum;
IO.EInfo[0] = rc;
IO.EInfo[1] = 0;
3228 return do_WriteNone();
3230 IO.Offset += Quantum;
IO.IOLen -= Quantum;
3231 if (
IO.IOLen < Quantum) Quantum =
IO.IOLen;
3248int XrdXrootdProtocol::do_WriteCont()
3254 if ((rc =
IO.File->XrdSfsp->write(
IO.Offset,
argp->buff,
myBlast)) < 0)
3256 return do_WriteNone();
3262 if (
IO.IOLen > 0)
return do_WriteAll();
3270int XrdXrootdProtocol::do_WriteNone()
3272 char *buff, dbuff[4096];
3277 if (
argp &&
argp->bsize > (
int)
sizeof(dbuff))
3282 blen =
sizeof(dbuff);
3284 if (
IO.IOLen < blen) blen =
IO.IOLen;
3288 TRACEP(REQ,
"discarding " <<
IO.IOLen <<
" bytes");
3291 if (rlen < 0)
return Link->setEtext(
"link read error");
3295 Resume = &XrdXrootdProtocol::do_WriteNone;
3298 if (
IO.IOLen < blen) blen =
IO.IOLen;
3303 return do_WriteNoneMsg();
3308int XrdXrootdProtocol::do_WriteNone(
int pathID,
XErrorCode ec,
3316 else do_WriteNoneMsg();
3317 return Link->setEtext(
"write protocol violation");
3326 IO.File->XrdSfsp->error.setErrInfo(0,
emsg);
3332 return do_WriteNone();
3339int XrdXrootdProtocol::do_WriteNoneMsg()
3343 if (!
IO.File)
return
3348 IO.File->XrdSfsp->error.getErrText());
3350 if (
IO.EInfo[0])
return fsError(
IO.EInfo[0], 0,
IO.File->XrdSfsp->error, 0, 0);
3375 return do_WriteNone(
Request.write.pathid);
3383 IO.File->Stats.wrOps(
IO.IOLen);
3393 return do_WriteNone();
3399 if (
IO.IOLen > 0)
return do_WriteAll();
3407int XrdXrootdProtocol::do_WriteV()
3420 ~trackInfo() {
if (doit && *wvInfo) {free(*wvInfo); *wvInfo = 0;}}
3423 struct XrdProto::write_list *wrLst;
3425 long long totSZ, maxSZ;
3426 int curFH, k, Quantum, wrVecNum, wrVecLen =
Request.header.dlen;
3431 wrVecNum = wrVecLen / wveSZ;
3432 if ( (wrVecLen <= 0) || (wrVecNum*wveSZ != wrVecLen) )
3448 wvInfo = (XrdXrootdWVInfo *)malloc(
sizeof(XrdXrootdWVInfo) +
3449 sizeof(XrdOucIOVec)*(wrVecNum-1));
3450 memset(
wvInfo, 0,
sizeof(XrdXrootdWVInfo) -
sizeof(XrdOucIOVec));
3457 wrLst = (XrdProto::write_list *)
argp->buff;
3458 totSZ = 0; maxSZ = 0; k = 0; Quantum =
maxTransz; curFH = 0;
3459 for (
int i = 0; i < wrVecNum; i++)
3460 {
if (wrLst[i].wlen == 0)
continue;
3461 memcpy(&wrVec[k].info, wrLst[i].fhandle,
sizeof(
int));
3462 wrVec[k].
size = ntohl(wrLst[i].wlen);
3463 if (wrVec[k].size < 0)
3467 if (wrVec[k].size > Quantum)
3471 wrVec[k].
offset = ntohll(wrLst[i].offset);
3472 if (wrVec[k].info == curFH) totSZ += wrVec[k].
size;
3473 else {
if (maxSZ < totSZ) maxSZ = totSZ;
3474 totSZ = wrVec[k].
size;
3481 if (maxSZ < totSZ) maxSZ = totSZ;
3482 if (maxSZ == 0)
return Response.Send();
3492 else Quantum =
static_cast<int>(maxSZ);
3496 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->bsize)
3497 {
if (getBuff(0, Quantum) <= 0)
return -1;}
3502 if (!
FTab || !(
IO.File =
FTab->Get(wrVec[0].info)))
3519 IO.IOLen = wrVec[0].
size;
3526 freeInfo.doit =
false;
3535int XrdXrootdProtocol::do_WriteVec()
3538 int rc, wrVNum, vNow =
wvInfo->vPos;
3548 {
if (rc < 0)
return rc;
3550 Resume = &XrdXrootdProtocol::do_WriteVec;
3558 done = newfile =
false;
3559 if (vNow >=
wvInfo->vEnd) done =
true;
3560 else if (
wvInfo->wrVec[vNow].info !=
wvInfo->curFH) newfile =
true;
3562 {
IO.IOLen =
wvInfo->wrVec[vNow].size;
3570 wrVNum = vNow -
wvInfo->vBeg;
3571 xfrSZ =
IO.File->XrdSfsp->writev(&(
wvInfo->wrVec[
wvInfo->vBeg]), wrVNum);
3572 TRACEP(FSIO,
"fh=" <<
wvInfo->curFH <<
" writeV " << xfrSZ <<
':' <<wrVNum);
3578 if (done || newfile)
3579 {
int monVnum = vNow -
wvInfo->vMon;
3580 IO.File->Stats.wvOps(
IO.WVBytes, monVnum);
3593 {
IO.File->XrdSfsp->error.setErrCB(0,0);
3594 xfrSZ =
IO.File->XrdSfsp->sync();
3595 if (xfrSZ< 0)
break;
3620 IO.IOLen =
wvInfo->wrVec[vNow].size;
3629 return fsError((
int)xfrSZ, 0,
IO.File->XrdSfsp->error, 0, 0);
3641 if (!
IO.IOLen)
return 1;
3657 if (!
IO.IOLen)
return 1;
3661 for (i = 1; i < sfvnum; i++) xframt += sfvec[i].sendsz;
3662 if (xframt >
IO.IOLen)
return 1;
3666 if (xframt)
IO.IOLen =
Response.Send(sfvec, sfvnum, xframt);
3677 if (fildes < 0)
IO.File->sfEnabled = 0;
3678 else IO.File->fdNum = fildes;
3688int XrdXrootdProtocol::fsError(
int rc,
char opC,
XrdOucErrInfo &myError,
3689 const char *
Path,
char *Cgi)
3691 int ecode, popt, rs;
3703 return fsOvrld(opC,
Path, Cgi);
3713 if (Cgi) rs = fsRedirNoEnt(
eMsg, Cgi, popt);
3736 <<
eMsg <<
':' <<ecode);
3751 if (ecode <= 0) ecode = 1800;
3752 TRACEI(STALL,
Response.ID() <<
"delaying client up to " <<ecode <<
" sec");
3756 return (rc ? rc : 1);
3771 {
if (ecode < 2) rs =
Response.Send();
3782 TRACEI(STALL,
Response.ID() <<
"stalling client for " <<rc <<
" sec");
3792 sprintf(buff,
"%d", rc);
3793 eDest.Emsg(
"Xeq",
"Unknown error code", buff,
eMsg);
3804int XrdXrootdProtocol::fsOvrld(
char opC,
const char *
Path,
char *Cgi)
3806 static const char *prot =
"root://";
3807 static int negOne = -1;
3808 static char quest =
'?', slash =
'/';
3810 struct iovec rdrResp[8];
3811 char *destP=0, dest[512];
3812 int iovNum=0, pOff, port;
3820 { rdrResp[1].iov_base = (
char *)&negOne;
3821 rdrResp[1].iov_len =
sizeof(negOne);
3822 rdrResp[2].iov_base = (
char *)prot;
3823 rdrResp[2].iov_len = 7;
3824 rdrResp[3].iov_base = (
char *)dest;
3825 rdrResp[3].iov_len = strlen(dest);
3826 rdrResp[4].iov_base = (
char *)&slash;
3827 rdrResp[4].iov_len = (*
Path ==
'/' ? 1 : 0);
3828 rdrResp[5].iov_base = (
char *)(
Path+pOff);
3829 rdrResp[5].iov_len = strlen(
Path+pOff);
3831 {rdrResp[6].iov_base = (
char *)?
3832 rdrResp[6].iov_len =
sizeof(quest);
3833 rdrResp[7].iov_base = (
char *)Cgi;
3834 rdrResp[7].iov_len = strlen(Cgi);
3852 TRACEI(REDIR,
Response.ID() <<
"redirecting to "<<destP<<
':'<<port);
3874int XrdXrootdProtocol::fsRedirNoEnt(
const char *
eMsg,
char *Cgi,
int popt)
3876 struct iovec ioV[4];
3877 char *tried, *trend, *ptried = 0;
3884 {
do {
if (!(tried = strstr(Cgi,
"tried=")))
break;
3885 if (tried == trend || *(tried-1) ==
'&')
3886 {
if (!ptried || (*(tried+6) && *(tried+6) !=
'&')) ptried=tried;}
3887 Cgi = index(tried+6,
'&');
3894 if ((tried = ptried))
3896 while(*(tried+1) && *(tried+1) ==
',') tried++;
3897 trend = index(tried,
'&');
3898 if (trend) {tlen = trend - tried; *trend = 0;}
3899 else tlen = strlen(tried);
3906 if ((trend = tried) &&
eMsg)
3907 do {
if ((trend = strstr(trend,
myCName)))
3910 trend = index(trend+
myCNlen,
',');
3918 if (!tried || !tlen || tlen > 16384)
3926 ioV[1].iov_base = (
char *)&pnum;
3927 ioV[1].iov_len =
sizeof(pnum);
3930 ioV[3].iov_base = tried;
3931 ioV[3].iov_len = tlen;
3946int XrdXrootdProtocol::getBuff(
const int isRead,
int Quantum)
3965 "insufficient memory to read file" :
3966 "insufficient memory to write file"));
3977char *XrdXrootdProtocol::getCksType(
char *opaque,
char *cspec,
int cslen)
3983 if (opaque && *opaque)
3984 {XrdOucEnv jobEnv(opaque);
3985 if ((cksT = jobEnv.Get(
"cks.type")))
3987 while(tP && strcasecmp(tP->
text, cksT)) tP = tP->
next;
3988 if (!tP && cspec) snprintf(cspec, cslen,
"%s", cksT);
3989 return (tP ? tP->
text : 0);
4002bool XrdXrootdProtocol::logLogin(
bool xauth)
4004 const char *uName, *ipName, *tMsg, *zMsg =
"";
4005 char lBuff[512], pBuff[512];
4015 if (xauth) uName = (
Client->name ?
Client->name :
"nobody");
4020 tMsg =
Link->verTLS();
4021 if (*tMsg) zMsg =
" ";
4025 snprintf(lBuff,
sizeof(lBuff),
"%s %s %s%slogin%s%s",
4028 (xauth ?
" as " :
""),
4029 (uName ? uName :
""));
4034 {snprintf(pBuff,
sizeof(pBuff),
"via %s auth for %s",
4045 {
Link->setProtName(
"xroots");
4048 eDest.Emsg(
"Xeq",
"Unable to require TLS for",
Link->ID);
4052 eDest.Emsg(
"Xeq",
"session requires TLS but",
Link->ID,
"is incapable.");
4076#define Map_Mode(x,y) if (Mode & kXR_ ## x) newmode |= S_I ## y
4078int XrdXrootdProtocol::mapMode(
int Mode)
4100 const char *bP = Buff;
4103 else {snprintf(Buff,
sizeof(Buff),
4104 "&p=%s&n=%s&h=%s&o=%s&r=%s&g=%s&m=%s%s&I=%c",
4126int XrdXrootdProtocol::rpCheck(
char *fn,
char **opaque)
4135 if (!(cp = index(fn,
'?'))) *opaque = 0;
4136 else {*cp =
'\0'; *opaque = cp+1;
4137 if (!**opaque) *opaque = 0;
4140 if (*fn !=
'/')
return 0;
4142 while ((cp = index(fn,
'/')))
4144 if (fn[0] ==
'.' && fn[1] ==
'.' && fn[2] ==
'/')
return 1;
4153int XrdXrootdProtocol::rpEmsg(
const char *op,
char *fn)
4156 snprintf(buff,
sizeof(buff)-1,
"%s relative path '%s' is disallowed.",op,fn);
4157 buff[
sizeof(buff)-1] =
'\0';
4175 else if (theFile->fdNum >= 0) theFile->
sfEnabled = 1;
4186int XrdXrootdProtocol::Squash(
char *fn)
4188 char *ofn, *ifn = fn;
4195 || (*(ifn+1) ==
'.' && *(ifn+1) && *(ifn+2) ==
'/'))
break;
4199 if (!*ifn)
return XPList.Validate(fn, ifn-fn);
4202 while(*ifn) {*ofn = *ifn++;
4204 {
while(*ifn ==
'/') ifn++;
4205 if (ifn[0] ==
'.' && ifn[1] ==
'/') ifn += 2;
4212 return XPList.Validate(fn, ofn-fn);
4219int XrdXrootdProtocol::vpEmsg(
const char *op,
char *fn)
4222 snprintf(buff,
sizeof(buff)-1,
"%s path '%s' is disallowed.",op,fn);
4223 buff[
sizeof(buff)-1] =
'\0';
#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