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';
1432 {openopts |=
SFS_O_RAWIO; *op++ =
'c'; compchk = 1;}
1435 {*op++ =
'a'; isAsync =
true;}
1437 SI->Bump(
SI->Refresh);
1447 {
char* cgiP = index(fn,
'?');
1448 if (cgiP) *cgiP = 0;
1449 TRACEP(FS,
"open " <<opt <<
' ' <<fn);
1450 if (cgiP) *cgiP =
'?';
1455 if (rpCheck(fn, &opaque))
return rpEmsg(
"Opening", fn);
1465 if (!(popt = Squash(fn)))
return vpEmsg(
"Opening", fn);
1477 OpenHelper oHelp(
Locker, fn);
1484 if (rc > 0) who = (rc > 1 ?
"readers" :
"reader");
1486 who = (rc > 1 ?
"writers" :
"writer");
1488 snprintf(ebuff,
sizeof(ebuff)-1,
1489 "%s file %s is already opened by %d %s; open denied.",
1490 (
'r' ==
usage ?
"Input" :
"Output"), fn, rc, who);
1491 eDest.Emsg(
"Xeq", ebuff);
1493 }
else oHelp.mode =
usage;
1504 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s",fn);
1505 eDest.Emsg(
"Xeq", ebuff);
1523 (mode_t)mode,
CRED, opaque)))
1524 {rc = fsError(rc, opC, fp->
error, fn, opaque);
return rc;}
1528 xp =
new XrdXrootdFile(
Link->ID, fn, fp,
usage, isAsync, &statbuf);
1530 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1531 eDest.Emsg(
"Xeq", ebuff);
1547 if (!
FTab || (fhandle =
FTab->Add(xp)) < 0)
1548 {snprintf(ebuff,
sizeof(ebuff)-1,
"Insufficient memory to open %s", fn);
1549 eDest.Emsg(
"Xeq", ebuff);
1561 Locker->numLocks(fn, rdrs, wrtrs);
1562 if ((
'r' ==
usage && wrtrs) || (
'w' ==
usage && rdrs) || wrtrs > 1)
1563 {snprintf(ebuff,
sizeof(ebuff)-1,
1564 "%s file %s forced opened with %d reader(s) and %d writer(s).",
1565 (
'r' ==
usage ?
"Input" :
"Output"), fn, rdrs, wrtrs);
1566 eDest.Emsg(
"Xeq", ebuff);
1572 memset(&myResp, 0,
sizeof(myResp));
1573 if (!compchk) resplen =
sizeof(myResp.fhandle);
1575 fp->
getCXinfo((
char *)myResp.cptype, cpsize);
1576 myResp.cpsize =
static_cast<kXR_int32>(htonl(cpsize));
1577 resplen =
sizeof(myResp);
1583 {retStat = StatGen(statbuf, ebuff,
sizeof(ebuff));
1584 IOResp[1].iov_base = (
char *)&myResp; IOResp[1].iov_len =
sizeof(myResp);
1585 IOResp[2].iov_base = ebuff; IOResp[2].iov_len = retStat;
1586 resplen =
sizeof(myResp) + retStat;
1605 memcpy((
void *)myResp.fhandle,(
const void *)&fhandle,
sizeof(myResp.fhandle));
1618 {
Stream[i]->pmDone =
true;
1637 if (retStat)
return Response.Send(IOResp, 3, resplen);
1638 else return Response.Send((
void *)&myResp, resplen);
1645int XrdXrootdProtocol::do_Ping()
1650 SI->Bump(
SI->miscCnt);
1661int XrdXrootdProtocol::do_Prepare(
bool isQuery)
1667 XrdOucTokenizer pathlist(
argp->buff);
1668 XrdOucTList *pFirst=0, *pP, *pLast = 0;
1669 XrdOucTList *oFirst=0, *oP, *oLast = 0;
1670 XrdOucTListHelper pHelp(&pFirst), oHelp(&oFirst);
1671 XrdXrootdPrepArgs pargs(0, 0);
1674 int rc, pathnum = 0;
1675 char reqid[128], nidbuff[512], *path, *opaque, *prpid = 0;
1676 unsigned short optX = ntohs(
Request.prepare.optionX);
1678 bool isCancel, isEvict, isPrepare;
1698 isPrepare = !(isCancel || isQuery);
1705 "Surpassed this connection's prepare limit.");
1723 if (isCancel || isQuery)
1724 {
if (!(prpid = pathlist.GetLine()))
1726 fsprep.
reqid = prpid;
1731 prpid =
PrepID->isMine(prpid, hport, hname,
sizeof(hname));
1734 "Prepare requestid owned by an unknown server");
1736 << hname <<
':' <<hport);
1742 {prpid =
PrepID->ID(reqid,
sizeof(reqid));
1743 fsprep.
reqid = reqid;
1746 reqid[0]=
'*'; reqid[1]=
'\0';
1747 fsprep.
reqid = prpid = reqid;
1760 while((path = pathlist.GetLine()))
1761 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Preparing", path);
1762 if (!Squash(path))
return vpEmsg(
"Preparing", path);
1763 pP =
new XrdOucTList(path, pathnum);
1764 (pLast ? (pLast->next = pP) : (pFirst = pP)); pLast = pP;
1765 oP =
new XrdOucTList(opaque, 0);
1766 (oLast ? (oLast->next = oP) : (oFirst = oP)); oLast = oP;
1769 fsprep.
paths = pFirst;
1770 fsprep.
oinfo = oFirst;
1794 char *mBuff = myError.getMsgBuff(rc);
1795 pargs.reqid = prpid;
1796 pargs.user =
Link->ID;
1797 pargs.paths = pFirst;
1799 if (rc < 0) rc =
Response.Send(
"No information found.");
1827 else snprintf(nidbuff,
sizeof(nidbuff),
"%s://%s:%d/",
1828 nprot,
Link->Host(), ntohs(
Request.prepare.port));
1859 else {rc =
Response.Send(reqid, strlen(reqid));
1861 {pargs.reqid = prpid;
1862 pargs.user =
Link->ID;
1863 pargs.paths = pFirst;
1880int XrdXrootdProtocol::do_Protocol()
1887 ServerResponseBody_Protocol theResp;
1891 bool wantTLS =
false;
1895 SI->Bump(
SI->miscCnt);
1899 if (
Request.protocol.clientpv)
1907 {
int k =(
Link->AddrInfo()->isPrivate() ? 1 : 0);
1915 {
int n =
DHS->ProtResp(theResp.
secreq, *(
Link->AddrInfo()), cvn);
1916 ioVec[iovN ].iov_base = (
void *)&theResp.
secreq;
1917 ioVec[iovN++].iov_len = n;
1922 {wantTLS = (
Request.protocol.flags &
1943 theResp.
flags = (wantTLS ? theRlt : theRle);
1945 theResp.
flags = theRlf;
1951 theResp.
pval = verNum;
1952 rc =
Response.Send(ioVec, iovN, RespLen);
1959 if (rc == 0 && wantTLS)
1961 {
Link->setProtName(
"xroots");
1964 eDest.Emsg(
"Xeq",
"Unable to enable TLS for",
Link->ID);
1975int XrdXrootdProtocol::do_Qconf()
1978 XrdOucTokenizer qcargs(
argp->buff);
1979 char *val, buff[4096], *bp=buff;
1980 int n, bleft =
sizeof(buff);
1984 if (!qcargs.GetLine() || !(val = qcargs.GetToken()))
1989 if (!strcmp(val,
"cmsd") || !strcmp(val,
"xrootd"))
1990 return do_QconfCX(qcargs, val);
1998 if (!strcmp(
"bind_max", val))
1999 {n = snprintf(bp, bleft,
"%d\n",
maxStreams-1);
2000 bp += n; bleft -= n;
2002 else if (!strcmp(
"chksum", val))
2003 {
const char *csList = getenv(
"XRD_CSLIST");
2005 {n = snprintf(bp, bleft,
"chksum\n");
2006 bp += n; bleft -= n;
2009 n = snprintf(bp, bleft,
"%s\n", csList);
2010 bp += n; bleft -= n;
2012 else if (!strcmp(
"cid", val))
2013 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2014 if (!cidval || !(*cidval)) cidval =
"cid";
2015 n = snprintf(bp, bleft,
"%s\n", cidval);
2016 bp += n; bleft -= n;
2018 else if (!strcmp(
"cms", val))
2021 n = snprintf(bp, bleft,
"%s\n", myError.getErrText());
2022 else n = snprintf(bp, bleft,
"%s\n",
"cms");
2023 bp += n; bleft -= n;
2025 else if (!strcmp(
"pio_max", val))
2026 {n = snprintf(bp, bleft,
"%d\n",
maxPio+1);
2027 bp += n; bleft -= n;
2029 else if (!strcmp(
"proxy", val))
2030 {
const char* pxyOrigin =
"proxy";
2032 {pxyOrigin = getenv(
"XRDXROOTD_PROXY");
2033 if (!pxyOrigin) pxyOrigin =
"proxy";
2035 n = snprintf(bp,bleft,
"%s\n",pxyOrigin);
2036 bp += n; bleft -= n;
2038 else if (!strcmp(
"readv_ior_max", val))
2040 bp += n; bleft -= n;
2042 else if (!strcmp(
"readv_iov_max", val))
2044 bp += n; bleft -= n;
2046 else if (!strcmp(
"role", val))
2047 {
const char *theRole = getenv(
"XRDROLE");
2048 n = snprintf(bp, bleft,
"%s\n", (theRole ? theRole :
"none"));
2049 bp += n; bleft -= n;
2051 else if (!strcmp(
"sitename", val))
2052 {
const char *siteName = getenv(
"XRDSITE");
2053 n = snprintf(bp, bleft,
"%s\n", (siteName ? siteName :
"sitename"));
2054 bp += n; bleft -= n;
2056 else if (!strcmp(
"start", val))
2057 {n = snprintf(bp, bleft,
"%s\n", startUP);
2058 bp += n; bleft -= n;
2060 else if (!strcmp(
"sysid", val))
2061 {
const char *cidval = getenv(
"XRDCMSCLUSTERID");
2062 const char *nidval = getenv(
"XRDCMSVNID");
2063 if (!cidval || !(*cidval) || !nidval || !(*nidval))
2064 {cidval =
"sysid"; nidval =
"";}
2065 n = snprintf(bp, bleft,
"%s %s\n", nidval, cidval);
2066 bp += n; bleft -= n;
2068 else if (!strcmp(
"tpc", val))
2069 {
char *tpcval = getenv(
"XRDTPC");
2070 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpc"));
2071 bp += n; bleft -= n;
2073 else if (!strcmp(
"tpcdlg", val))
2074 {
char *tpcval = getenv(
"XRDTPCDLG");
2075 n = snprintf(bp, bleft,
"%s\n", (tpcval ? tpcval :
"tpcdlg"));
2076 bp += n; bleft -= n;
2078 else if (!strcmp(
"tls_port", val) &&
tlsPort)
2079 {n = snprintf(bp, bleft,
"%d\n",
tlsPort);
2080 bp += n; bleft -= n;
2082 else if (!strcmp(
"window", val) &&
Window)
2083 {n = snprintf(bp, bleft,
"%d\n",
Window);
2084 bp += n; bleft -= n;
2086 else if (!strcmp(
"version", val))
2087 {n = snprintf(bp, bleft,
"%s\n", XrdVSTRING);
2088 bp += n; bleft -= n;
2090 else if (!strcmp(
"vnid", val))
2091 {
const char *nidval = getenv(
"XRDCMSVNID");
2092 if (!nidval || !(*nidval)) nidval =
"vnid";
2093 n = snprintf(bp, bleft,
"%s\n", nidval);
2095 else if (!strcmp(
"fattr", val))
2096 {n = snprintf(bp, bleft,
"%s\n",
usxParms);
2097 bp += n; bleft -= n;
2099 else {n = strlen(val);
2100 if (bleft <= n)
break;
2101 strcpy(bp, val); bp +=n; *bp =
'\n'; bp++;
2104 }
while(bleft > 0 && (val = qcargs.GetToken()));
2113 return Response.Send(buff,
sizeof(buff) - bleft);
2123 bool isCMSD = (*val ==
'c');
2132 if (isCMSD)
return Response.Send((
void *)
"\n", 2);
2141 return Response.Send((
void *)
"\n", 2);
2148int XrdXrootdProtocol::do_Qfh()
2151 XrdXrootdFHandle fh(
Request.query.fhandle);
2153 const char *fArg = 0, *qType =
"";
2155 short qopt = (short)ntohs(
Request.query.infotype);
2159 SI->Bump(
SI->miscCnt);
2163 if (!
FTab || !(fp =
FTab->Get(fh.handle)))
2165 "query does not refer to an open file");
2185 "Required query argument not present");
2190 TRACEP(FS,
"fh=" <<fh.handle <<
" query " <<qType <<
" rc=" <<rc);
2203int XrdXrootdProtocol::do_Qopaque(
short qopt)
2208 const char *Act, *AData;
2210 int fsctl_cmd, rc, dlen =
Request.query.dlen;
2216 myData.Arg2 = 0; myData.
Arg2Len = 0;
2218 Act =
" qopaque '"; AData =
"...";
2226 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Querying",
argp->buff);
2227 if (!Squash(
argp->buff))
return vpEmsg(
"Querying",
argp->buff);
2232 myData.
Arg1Len = (opaque ? opaque -
argp->buff - 1 : dlen);
2233 myData.Arg2 = opaque;
2234 myData.
Arg2Len = (opaque ?
argp->buff + dlen - opaque : 0);
2236 Act =
" qopaquf '"; AData =
argp->buff;
2240 myError.setErrCB(&qpqCB,
ReqID.getID());
2244 rc =
osFS->FSctl(fsctl_cmd, myData, myError,
CRED);
2245 TRACEP(FS,
"rc=" <<rc <<Act <<AData <<
"'");
2247 return fsError(rc, 0, myError, 0, 0);
2254int XrdXrootdProtocol::do_Qspace()
2267 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Stating",
argp->buff);
2268 if (!Squash(
argp->buff))
return vpEmsg(
"Stating",
argp->buff);
2273 {n = strlen(
argp->buff);
argp->buff[n] =
'?';
2274 if ((
argp->buff)+n != opaque-1)
2275 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
2280 rc =
osFS->fsctl(fsctl_cmd,
argp->buff, myError,
CRED);
2281 TRACEP(FS,
"rc=" <<rc <<
" qspace '" <<
argp->buff <<
"'");
2290int XrdXrootdProtocol::do_Query()
2292 short qopt = (short)ntohs(
Request.query.infotype);
2307 case kXR_QPrep:
return do_Prepare(
true);
2314 "Invalid information query type code");
2321int XrdXrootdProtocol::do_Qxattr()
2335 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Stating",
argp->buff);
2336 if (!Squash(
argp->buff))
return vpEmsg(
"Stating",
argp->buff);
2341 {
int n = strlen(
argp->buff);
argp->buff[n] =
'?';
2342 if ((
argp->buff)+n != opaque-1)
2343 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
2348 rc =
osFS->fsctl(fsctl_cmd,
argp->buff, myError,
CRED);
2349 TRACEP(FS,
"rc=" <<rc <<
" qxattr " <<
argp->buff);
2357int XrdXrootdProtocol::do_Read()
2360 XrdXrootdFHandle fh(
Request.read.fhandle);
2367 if (!
Request.header.dlen) pathID = 0;
2368 else if (do_ReadNone(retc, pathID))
return retc;
2377 if (!
FTab || !(
IO.File =
FTab->Get(fh.handle)))
2379 "read does not refer to an open file");
2383 TRACEP(FSIO, pathID <<
" fh=" <<fh.handle <<
" read " <<
IO.IOLen
2386 "Read length is negative");
2403 &&
IO.Offset+
IO.IOLen <=
IO.File->Stats.fSize)
2409 XrdXrootdNormAio *aioP;
2411 if (!pathID) pP =
this;
2412 else {
if (!(pP =
VerifyStream(retc, pathID,
false)))
return retc;
2416 {
if (!
IO.File->aioFob)
IO.File->aioFob =
new XrdXrootdAioFob;
2427 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_ReadAll, pathID);
2431 return do_ReadAll();
2442int XrdXrootdProtocol::do_ReadAll()
2451 {
if (
IO.Offset >=
IO.File->Stats.fSize)
return Response.Send();
2452 if (
IO.Offset+
IO.IOLen <=
IO.File->Stats.fSize)
2453 {
IO.File->Stats.rdOps(
IO.IOLen);
2456 xframt =
IO.File->Stats.fSize -
IO.Offset;
2457 IO.File->Stats.rdOps(xframt);
2458 return Response.Send(
IO.File->mmAddr+
IO.Offset, xframt);
2464 {
IO.File->Stats.rdOps(
IO.IOLen);
2465 if (
IO.File->fdNum >= 0)
2467 rc =
IO.File->XrdSfsp->SendData((
XrdSfsDio *)
this,
IO.Offset,
IO.IOLen);
2469 {
if (!
IO.IOLen)
return 0;
2470 if (
IO.IOLen < 0)
return -1;
2471 }
else return fsError(rc, 0,
IO.File->XrdSfsp->error, 0, 0);
2476 if (!
argp || Quantum < halfBSize || Quantum >
argp->bsize)
2477 {
if ((rc = getBuff(1, Quantum)) <= 0)
return rc;}
2484 IO.File->Stats.rdOps(
IO.IOLen);
2485 do {
if ((xframt =
IO.File->XrdSfsp->read(
IO.Offset, buff, Quantum)) <= 0)
break;
2486 if (xframt >=
IO.IOLen)
return Response.Send(buff, xframt);
2488 IO.Offset += xframt;
IO.IOLen -= xframt;
2489 if (
IO.IOLen < Quantum) Quantum =
IO.IOLen;
2494 if (xframt == 0)
return Response.Send();
2495 return fsError(xframt, 0,
IO.File->XrdSfsp->error, 0, 0);
2502int XrdXrootdProtocol::do_ReadNone(
int &retc,
int &pathID)
2504 XrdXrootdFHandle fh;
2505 int ralsz =
Request.header.dlen;
2506 struct read_args *rargs=(
struct read_args *)(
argp->buff);
2507 struct readahead_list *ralsp = (readahead_list *)(rargs+1);
2511 pathID =
static_cast<int>(rargs->
pathid);
2512 if ((ralsz -=
sizeof(read_args)) <= 0)
return 0;
2516 if (ralsz%
sizeof(readahead_list))
2524 {
IO.IOLen = ntohl(ralsp->
rlen);
2531 "preread does not refer to an open file");
2534 IO.File->XrdSfsp->read(
IO.Offset,
IO.IOLen);
2535 ralsz -=
sizeof(
struct readahead_list);
2549int XrdXrootdProtocol::do_ReadV()
2558 const int hdrSZ =
sizeof(readahead_list);
2559 struct XrdOucIOVec rdVec[XrdProto::maxRvecsz+1];
2560 struct readahead_list *raVec, respHdr;
2563 int rdVBeg, rdVBreak, rdVNow, rdVNum, rdVecNum;
2564 int currFH, i, k, Quantum, Qleft, rdVecLen =
Request.header.dlen;
2566 int ioMon = (rvMon > 1);
2567 char *buffp, vType = (ioMon ? XROOTD_MON_READU : XROOTD_MON_READV);
2572 rdVecNum = rdVecLen / sizeof(readahead_list);
2573 if ( (rdVecNum <= 0) || (rdVecNum*hdrSZ != rdVecLen) )
2574 return Response.Send(kXR_ArgInvalid, "Read vector is invalid");
2580 if (rdVecNum > XrdProto::maxRvecsz)
2581 return
Response.
Send(kXR_ArgTooLong, "Read vector is too long");
2591 raVec = (readahead_list *)
argp->buff;
2593 for (i = 0; i < rdVecNum; i++)
2594 {totSZ += (rdVec[i].size = ntohl(raVec[i].rlen));
2595 if (rdVec[i].size < 0) return Response.Send(kXR_ArgInvalid,
2596 "Readv length is negative");
2597 if (rdVec[i].size > Quantum) return Response.Send(kXR_NoMemory,
2598 "Single readv transfer is too large");
2599 rdVec[i].offset = ntohll(raVec[i].offset);
2600 memcpy(&rdVec[i].info, raVec[i].fhandle, sizeof(int));
2605 rdVec[i].offset = -1;
2608 rdVBreak = rdVecNum;
2613 if (totSZ > 0x7fffffffLL)
2614 return
Response.
Send(kXR_NoMemory, "Total readv transfer is too large");
2623 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->bsize)
2624 {
if ((k = getBuff(1, Quantum)) <= 0)
return k;}
2631 "readv does not refer to an open file");
2636 currFH = rdVec[0].info;
2637 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2639 "readv does not refer to an open file");
2643 Qleft = Quantum; buffp =
argp->buff;
rvSeq++;
2644 rdVBeg = rdVNow = 0; rdVXfr = rdVAmt = 0;
2648 for (i = 0; i < rdVecNum; i++)
2649 {
if (rdVec[i].info != currFH)
2650 {xfrSZ =
IO.File->XrdSfsp->readv(&rdVec[rdVNow], i-rdVNow);
2651 if (xfrSZ != rdVAmt)
break;
2652 rdVNum = i - rdVBeg; rdVXfr += rdVAmt;
2653 IO.File->Stats.rvOps(rdVXfr, rdVNum);
2655 {
Monitor.Agent->Add_rv(
IO.File->Stats.FileID, htonl(rdVXfr),
2656 htons(rdVNum),
rvSeq, vType);
2657 if (ioMon)
for (k = rdVBeg; k < i; k++)
2658 Monitor.Agent->Add_rd(
IO.File->Stats.FileID,
2659 htonl(rdVec[k].size), htonll(rdVec[k].offset));
2661 rdVXfr = rdVAmt = 0;
2662 if (i == rdVBreak)
break;
2663 rdVBeg = rdVNow = i; currFH = rdVec[i].info;
2664 memcpy(respHdr.fhandle, &currFH,
sizeof(respHdr.fhandle));
2665 if (!(
IO.File =
FTab->Get(currFH)))
2667 "readv does not refer to an open file");
2670 if (Qleft < (rdVec[i].size + hdrSZ))
2672 {xfrSZ =
IO.File->XrdSfsp->readv(&rdVec[rdVNow], i-rdVNow);
2673 if (xfrSZ != rdVAmt)
break;
2679 rdVNow = i; rdVXfr += rdVAmt; rdVAmt = 0;
2682 xfrSZ = rdVec[i].size; rdVAmt += xfrSZ;
2683 respHdr.rlen = htonl(xfrSZ);
2684 respHdr.offset = htonll(rdVec[i].offset);
2685 memcpy(buffp, &respHdr, hdrSZ);
2686 rdVec[i].data = buffp + hdrSZ;
2687 buffp += (xfrSZ+hdrSZ); Qleft -= (xfrSZ+hdrSZ);
2688 TRACEP(FSIO,
"fh=" <<currFH<<
" readV "<< xfrSZ <<
'@'<<rdVec[i].offset);
2696 IO.File->XrdSfsp->error.setErrInfo(-
ENODATA,
"readv past EOF");
2698 return fsError(xfrSZ, 0,
IO.File->XrdSfsp->error, 0, 0);
2703 return (Quantum != Qleft ?
Response.Send(
argp->buff, Quantum-Qleft) : 0);
2710int XrdXrootdProtocol::do_Rm()
2722 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Removing",
argp->buff);
2723 if (!Squash(
argp->buff))
return vpEmsg(
"Removing",
argp->buff);
2728 TRACEP(FS,
"rc=" <<rc <<
" rm " <<
argp->buff);
2740int XrdXrootdProtocol::do_Rmdir()
2752 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Removing",
argp->buff);
2753 if (!Squash(
argp->buff))
return vpEmsg(
"Removing",
argp->buff);
2758 TRACEP(FS,
"rc=" <<rc <<
" rmdir " <<
argp->buff);
2770int XrdXrootdProtocol::do_Set()
2772 XrdOucTokenizer setargs(
argp->buff);
2777 if (!setargs.GetLine() || !(val = setargs.GetToken(&rest)))
2786 if (!strcmp(
"appid", val))
2787 {
while(*rest && *rest ==
' ') rest++;
2788 eDest.Emsg(
"Xeq",
Link->ID,
"appid", rest);
2791 else if (!strcmp(
"monitor", val))
return do_Set_Mon(setargs);
2792 else if (!strcmp(
"cache", val))
return do_Set_Cache(setargs);
2809 char *cmd, *cargs, *opaque;
2810 const char *myArgs[2];
2819 if (!(cmd = setargs.
GetToken(&cargs)))
2824 if (cargs && *cargs ==
'/')
2825 {
if (rpCheck(cargs, &opaque))
return rpEmsg(
"Setting", cargs);
2826 if (!Squash(cargs))
return vpEmsg(
"Setting", cargs);
2827 myData.ArgP = myArgs; myData.
Arg2Len = -2;
2831 myData.Arg2 = opaque; myData.
Arg2Len = (opaque ? strlen(opaque) : 0);
2838 TRACEP(FS,
"rc=" <<rc <<
"set cache " <<myData.
Arg1 <<
' ' <<cargs);
2840 return fsError(rc, 0, myError, 0, 0);
2856 if (!(val = setargs.
GetToken(&appid)))
2863 if (!strcmp(val,
"info"))
2865 {
while(*appid && *appid ==
' ') appid++;
2866 if (strlen(appid) > 1024) appid[1024] =
'\0';
2867 if (*appid) myseq =
Monitor.MapInfo(appid);
2869 return Response.Send((
void *)&myseq,
sizeof(myseq));
2874 if (!strcmp(val,
"on"))
2877 {
while(*appid && *appid ==
' ') appid++;
2878 if (*appid)
Monitor.Agent->appID(appid);
2886 if (!strcmp(val,
"off"))
2887 {
if (appid &&
Monitor.InOut())
2888 {
while(*appid && *appid ==
' ') appid++;
2889 if (*appid)
Monitor.Agent->appID(appid);
2904int XrdXrootdProtocol::do_Stat()
2910 char *opaque, xxBuff[1024];
2916 SI->Bump(
SI->miscCnt);
2922 XrdXrootdFHandle fh(
Request.stat.fhandle);
2929 "stat does not refer to an open file");
2933 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2947 if (rpCheck(
argp->buff, &opaque))
return rpEmsg(
"Stating",
argp->buff);
2948 if (!doDig && !Squash(
argp->buff))
return vpEmsg(
"Stating",
argp->buff);
2954 {
int n = strlen(
argp->buff);
argp->buff[n] =
'?';
2955 if ((
argp->buff)+n != opaque-1)
2956 memmove(&
argp->buff[n+1], opaque, strlen(opaque)+1);
2958 rc =
osFS->fsctl(fsctl_cmd,
argp->buff, myError,
CRED);
2959 TRACEP(FS,
"rc=" <<rc <<
" statfs " <<
argp->buff);
2962 if (doDig) rc =
digFS->stat(
argp->buff, &buf, myError,
CRED, opaque);
2963 else rc =
osFS->stat(
argp->buff, &buf, myError,
CRED, opaque);
2964 TRACEP(FS,
"rc=" <<rc <<
" stat " <<
argp->buff);
2966 StatGen(buf,xxBuff,
sizeof(xxBuff)));
2975int XrdXrootdProtocol::do_Statx()
2979 char *path, *opaque, *respinfo =
argp->buff;
2982 XrdOucTokenizer pathlist(
argp->buff);
2990 while((path = pathlist.GetLine()))
2991 {
if (rpCheck(path, &opaque))
return rpEmsg(
"Stating", path);
2992 if (!Squash(path))
return vpEmsg(
"Stating", path);
2993 rc =
osFS->stat(path, mode, myError,
CRED, opaque);
2994 TRACEP(FS,
"rc=" <<rc <<
" stat " <<path);
2997 else {
if (mode == (mode_t)-1) *respinfo = (char)
kXR_offline;
2998 else if (S_ISDIR(mode)) *respinfo = (char)
kXR_isDir;
3013int XrdXrootdProtocol::do_Sync()
3015 static XrdXrootdCallBack syncCB(
"sync", 0);
3018 XrdXrootdFHandle fh(
Request.sync.fhandle);
3022 SI->Bump(
SI->syncCnt);
3048int XrdXrootdProtocol::do_Truncate()
3050 static XrdXrootdCallBack truncCB(
"trunc", 0);
3052 XrdXrootdFHandle fh(
Request.truncate.fhandle);
3053 long long theOffset;
3058 n2hll(
Request.truncate.offset, theOffset);
3066 SI->Bump(
SI->miscCnt);
3072 "trunc does not refer to an open file");
3078 TRACEP(FS,
"fh=" <<fh.
handle <<
" trunc rc=" <<rc <<
" sz=" <<theOffset);
3092 if (rpCheck(
argp->buff,&opaque))
return rpEmsg(
"Truncating",
argp->buff);
3093 if (!Squash(
argp->buff))
return vpEmsg(
"Truncating",
argp->buff);
3099 TRACEP(FS,
"rc=" <<rc <<
" trunc " <<theOffset <<
' ' <<
argp->buff);
3113int XrdXrootdProtocol::do_Write()
3116 XrdXrootdFHandle fh(
Request.write.fhandle);
3123 pathID =
static_cast<int>(
Request.write.pathid);
3129 return do_WriteNone(pathID);
3134 TRACEP(FSIO, pathID<<
" fh="<<fh.
handle<<
" write "<<
IO.IOLen<<
'@'<<
IO.Offset);
3136 "Write length is negative");
3147 IO.File->Stats.wrOps(
IO.IOLen);
3155 {
if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAio,pathID);
3156 return do_WriteAio();
3164 if (pathID)
return do_Offload(&XrdXrootdProtocol::do_WriteAll, pathID);
3168 return do_WriteAll();
3179int XrdXrootdProtocol::do_WriteAio()
3181 XrdXrootdNormAio *aioP;
3189 return do_WriteAll();
3194 return aioP->
Write(
IO.Offset,
IO.IOLen);
3205int XrdXrootdProtocol::do_WriteAll()
3211 if (!
argp || Quantum < halfBSize || Quantum >
argp->bsize)
3212 {
if ((rc = getBuff(0, Quantum)) <= 0)
return rc;}
3220 {
Resume = &XrdXrootdProtocol::do_WriteCont;
3225 if ((rc =
IO.File->XrdSfsp->write(
IO.Offset,
argp->buff, Quantum)) < 0)
3226 {
IO.IOLen =
IO.IOLen-Quantum;
IO.EInfo[0] = rc;
IO.EInfo[1] = 0;
3227 return do_WriteNone();
3229 IO.Offset += Quantum;
IO.IOLen -= Quantum;
3230 if (
IO.IOLen < Quantum) Quantum =
IO.IOLen;
3247int XrdXrootdProtocol::do_WriteCont()
3253 if ((rc =
IO.File->XrdSfsp->write(
IO.Offset,
argp->buff,
myBlast)) < 0)
3255 return do_WriteNone();
3261 if (
IO.IOLen > 0)
return do_WriteAll();
3269int XrdXrootdProtocol::do_WriteNone()
3271 char *buff, dbuff[4096];
3276 if (
argp &&
argp->bsize > (
int)
sizeof(dbuff))
3281 blen =
sizeof(dbuff);
3283 if (
IO.IOLen < blen) blen =
IO.IOLen;
3287 TRACEP(REQ,
"discarding " <<
IO.IOLen <<
" bytes");
3290 if (rlen < 0)
return Link->setEtext(
"link read error");
3294 Resume = &XrdXrootdProtocol::do_WriteNone;
3297 if (
IO.IOLen < blen) blen =
IO.IOLen;
3302 return do_WriteNoneMsg();
3307int XrdXrootdProtocol::do_WriteNone(
int pathID,
XErrorCode ec,
3315 else do_WriteNoneMsg();
3316 return Link->setEtext(
"write protocol violation");
3325 IO.File->XrdSfsp->error.setErrInfo(0,
emsg);
3331 return do_WriteNone();
3338int XrdXrootdProtocol::do_WriteNoneMsg()
3342 if (!
IO.File)
return
3347 IO.File->XrdSfsp->error.getErrText());
3349 if (
IO.EInfo[0])
return fsError(
IO.EInfo[0], 0,
IO.File->XrdSfsp->error, 0, 0);
3374 return do_WriteNone(
Request.write.pathid);
3382 IO.File->Stats.wrOps(
IO.IOLen);
3392 return do_WriteNone();
3398 if (
IO.IOLen > 0)
return do_WriteAll();
3406int XrdXrootdProtocol::do_WriteV()
3419 ~trackInfo() {
if (doit && *wvInfo) {free(*wvInfo); *wvInfo = 0;}}
3422 struct XrdProto::write_list *wrLst;
3424 long long totSZ, maxSZ;
3425 int curFH, k, Quantum, wrVecNum, wrVecLen =
Request.header.dlen;
3430 wrVecNum = wrVecLen / wveSZ;
3431 if ( (wrVecLen <= 0) || (wrVecNum*wveSZ != wrVecLen) )
3447 wvInfo = (XrdXrootdWVInfo *)malloc(
sizeof(XrdXrootdWVInfo) +
3448 sizeof(XrdOucIOVec)*(wrVecNum-1));
3449 memset(
wvInfo, 0,
sizeof(XrdXrootdWVInfo) -
sizeof(XrdOucIOVec));
3456 wrLst = (XrdProto::write_list *)
argp->buff;
3457 totSZ = 0; maxSZ = 0; k = 0; Quantum =
maxTransz; curFH = 0;
3458 for (
int i = 0; i < wrVecNum; i++)
3459 {
if (wrLst[i].wlen == 0)
continue;
3460 memcpy(&wrVec[k].info, wrLst[i].fhandle,
sizeof(
int));
3461 wrVec[k].
size = ntohl(wrLst[i].wlen);
3462 if (wrVec[k].size < 0)
3466 if (wrVec[k].size > Quantum)
3470 wrVec[k].
offset = ntohll(wrLst[i].offset);
3471 if (wrVec[k].info == curFH) totSZ += wrVec[k].
size;
3472 else {
if (maxSZ < totSZ) maxSZ = totSZ;
3473 totSZ = wrVec[k].
size;
3480 if (maxSZ < totSZ) maxSZ = totSZ;
3481 if (maxSZ == 0)
return Response.Send();
3491 else Quantum =
static_cast<int>(maxSZ);
3495 if ((Quantum < halfBSize && Quantum > 1024) || Quantum >
argp->bsize)
3496 {
if (getBuff(0, Quantum) <= 0)
return -1;}
3501 if (!
FTab || !(
IO.File =
FTab->Get(wrVec[0].info)))
3518 IO.IOLen = wrVec[0].
size;
3525 freeInfo.doit =
false;
3534int XrdXrootdProtocol::do_WriteVec()
3537 int rc, wrVNum, vNow =
wvInfo->vPos;
3547 {
if (rc < 0)
return rc;
3549 Resume = &XrdXrootdProtocol::do_WriteVec;
3557 done = newfile =
false;
3558 if (vNow >=
wvInfo->vEnd) done =
true;
3559 else if (
wvInfo->wrVec[vNow].info !=
wvInfo->curFH) newfile =
true;
3561 {
IO.IOLen =
wvInfo->wrVec[vNow].size;
3569 wrVNum = vNow -
wvInfo->vBeg;
3570 xfrSZ =
IO.File->XrdSfsp->writev(&(
wvInfo->wrVec[
wvInfo->vBeg]), wrVNum);
3571 TRACEP(FSIO,
"fh=" <<
wvInfo->curFH <<
" writeV " << xfrSZ <<
':' <<wrVNum);
3577 if (done || newfile)
3578 {
int monVnum = vNow -
wvInfo->vMon;
3579 IO.File->Stats.wvOps(
IO.WVBytes, monVnum);
3592 {
IO.File->XrdSfsp->error.setErrCB(0,0);
3593 xfrSZ =
IO.File->XrdSfsp->sync();
3594 if (xfrSZ< 0)
break;
3619 IO.IOLen =
wvInfo->wrVec[vNow].size;
3628 return fsError((
int)xfrSZ, 0,
IO.File->XrdSfsp->error, 0, 0);
3640 if (!
IO.IOLen)
return 1;
3656 if (!
IO.IOLen)
return 1;
3660 for (i = 1; i < sfvnum; i++) xframt += sfvec[i].sendsz;
3661 if (xframt >
IO.IOLen)
return 1;
3665 if (xframt)
IO.IOLen =
Response.Send(sfvec, sfvnum, xframt);
3676 if (fildes < 0)
IO.File->sfEnabled = 0;
3677 else IO.File->fdNum = fildes;
3687int XrdXrootdProtocol::fsError(
int rc,
char opC,
XrdOucErrInfo &myError,
3688 const char *
Path,
char *Cgi)
3690 int ecode, popt, rs;
3702 return fsOvrld(opC,
Path, Cgi);
3712 if (Cgi) rs = fsRedirNoEnt(
eMsg, Cgi, popt);
3735 <<
eMsg <<
':' <<ecode);
3750 if (ecode <= 0) ecode = 1800;
3751 TRACEI(STALL,
Response.ID() <<
"delaying client up to " <<ecode <<
" sec");
3755 return (rc ? rc : 1);
3770 {
if (ecode < 2) rs =
Response.Send();
3781 TRACEI(STALL,
Response.ID() <<
"stalling client for " <<rc <<
" sec");
3791 sprintf(buff,
"%d", rc);
3792 eDest.Emsg(
"Xeq",
"Unknown error code", buff,
eMsg);
3803int XrdXrootdProtocol::fsOvrld(
char opC,
const char *
Path,
char *Cgi)
3805 static const char *prot =
"root://";
3806 static int negOne = -1;
3807 static char quest =
'?', slash =
'/';
3809 struct iovec rdrResp[8];
3810 char *destP=0, dest[512];
3811 int iovNum=0, pOff, port;
3819 { rdrResp[1].iov_base = (
char *)&negOne;
3820 rdrResp[1].iov_len =
sizeof(negOne);
3821 rdrResp[2].iov_base = (
char *)prot;
3822 rdrResp[2].iov_len = 7;
3823 rdrResp[3].iov_base = (
char *)dest;
3824 rdrResp[3].iov_len = strlen(dest);
3825 rdrResp[4].iov_base = (
char *)&slash;
3826 rdrResp[4].iov_len = (*
Path ==
'/' ? 1 : 0);
3827 rdrResp[5].iov_base = (
char *)(
Path+pOff);
3828 rdrResp[5].iov_len = strlen(
Path+pOff);
3830 {rdrResp[6].iov_base = (
char *)?
3831 rdrResp[6].iov_len =
sizeof(quest);
3832 rdrResp[7].iov_base = (
char *)Cgi;
3833 rdrResp[7].iov_len = strlen(Cgi);
3851 TRACEI(REDIR,
Response.ID() <<
"redirecting to "<<destP<<
':'<<port);
3873int XrdXrootdProtocol::fsRedirNoEnt(
const char *
eMsg,
char *Cgi,
int popt)
3875 struct iovec ioV[4];
3876 char *tried, *trend, *ptried = 0;
3883 {
do {
if (!(tried = strstr(Cgi,
"tried=")))
break;
3884 if (tried == trend || *(tried-1) ==
'&')
3885 {
if (!ptried || (*(tried+6) && *(tried+6) !=
'&')) ptried=tried;}
3886 Cgi = index(tried+6,
'&');
3893 if ((tried = ptried))
3895 while(*(tried+1) && *(tried+1) ==
',') tried++;
3896 trend = index(tried,
'&');
3897 if (trend) {tlen = trend - tried; *trend = 0;}
3898 else tlen = strlen(tried);
3905 if ((trend = tried) &&
eMsg)
3906 do {
if ((trend = strstr(trend,
myCName)))
3909 trend = index(trend+
myCNlen,
',');
3917 if (!tried || !tlen || tlen > 16384)
3925 ioV[1].iov_base = (
char *)&pnum;
3926 ioV[1].iov_len =
sizeof(pnum);
3929 ioV[3].iov_base = tried;
3930 ioV[3].iov_len = tlen;
3945int XrdXrootdProtocol::getBuff(
const int isRead,
int Quantum)
3964 "insufficient memory to read file" :
3965 "insufficient memory to write file"));
3976char *XrdXrootdProtocol::getCksType(
char *opaque,
char *cspec,
int cslen)
3982 if (opaque && *opaque)
3983 {XrdOucEnv jobEnv(opaque);
3984 if ((cksT = jobEnv.Get(
"cks.type")))
3986 while(tP && strcasecmp(tP->
text, cksT)) tP = tP->
next;
3987 if (!tP && cspec) snprintf(cspec, cslen,
"%s", cksT);
3988 return (tP ? tP->
text : 0);
4001bool XrdXrootdProtocol::logLogin(
bool xauth)
4003 const char *uName, *ipName, *tMsg, *zMsg =
"";
4004 char lBuff[512], pBuff[512];
4014 if (xauth) uName = (
Client->name ?
Client->name :
"nobody");
4019 tMsg =
Link->verTLS();
4020 if (*tMsg) zMsg =
" ";
4024 snprintf(lBuff,
sizeof(lBuff),
"%s %s %s%slogin%s%s",
4027 (xauth ?
" as " :
""),
4028 (uName ? uName :
""));
4033 {snprintf(pBuff,
sizeof(pBuff),
"via %s auth for %s",
4044 {
Link->setProtName(
"xroots");
4047 eDest.Emsg(
"Xeq",
"Unable to require TLS for",
Link->ID);
4051 eDest.Emsg(
"Xeq",
"session requires TLS but",
Link->ID,
"is incapable.");
4075#define Map_Mode(x,y) if (Mode & kXR_ ## x) newmode |= S_I ## y
4077int XrdXrootdProtocol::mapMode(
int Mode)
4099 const char *bP = Buff;
4102 else {snprintf(Buff,
sizeof(Buff),
4103 "&p=%s&n=%s&h=%s&o=%s&r=%s&g=%s&m=%s%s&I=%c",
4125int XrdXrootdProtocol::rpCheck(
char *fn,
char **opaque)
4134 if (!(cp = index(fn,
'?'))) *opaque = 0;
4135 else {*cp =
'\0'; *opaque = cp+1;
4136 if (!**opaque) *opaque = 0;
4139 if (*fn !=
'/')
return 0;
4141 while ((cp = index(fn,
'/')))
4143 if (fn[0] ==
'.' && fn[1] ==
'.' && fn[2] ==
'/')
return 1;
4152int XrdXrootdProtocol::rpEmsg(
const char *op,
char *fn)
4155 snprintf(buff,
sizeof(buff)-1,
"%s relative path '%s' is disallowed.",op,fn);
4156 buff[
sizeof(buff)-1] =
'\0';
4174 else if (theFile->fdNum >= 0) theFile->
sfEnabled = 1;
4185int XrdXrootdProtocol::Squash(
char *fn)
4187 char *ofn, *ifn = fn;
4194 || (*(ifn+1) ==
'.' && *(ifn+1) && *(ifn+2) ==
'/'))
break;
4198 if (!*ifn)
return XPList.Validate(fn, ifn-fn);
4201 while(*ifn) {*ofn = *ifn++;
4203 {
while(*ifn ==
'/') ifn++;
4204 if (ifn[0] ==
'.' && ifn[1] ==
'/') ifn += 2;
4211 return XPList.Validate(fn, ofn-fn);
4218int XrdXrootdProtocol::vpEmsg(
const char *op,
char *fn)
4221 snprintf(buff,
sizeof(buff)-1,
"%s path '%s' is disallowed.",op,fn);
4222 buff[
sizeof(buff)-1] =
'\0';
#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