diff --git a/proof/proofd/inc/XrdProofdManager.h b/proof/proofd/inc/XrdProofdManager.h
index d55009e36367c4895419c69b8b48dcb7c910955b..ae27d47fae32509e7b80cb856b470dede806f256 100644
--- a/proof/proofd/inc/XrdProofdManager.h
+++ b/proof/proofd/inc/XrdProofdManager.h
@@ -96,12 +96,6 @@ class XrdProofdManager : public XrdProofdConfig {
const char *DataSetExp() const { return fDataSetExp.c_str(); }
const char *StageReqRepo() const { return fStageReqRepo.c_str(); }
- const char *RootdExe() const { return fRootdExe.c_str(); }
- const char **RootdArgs() const { return fRootdArgsPtrs; }
- bool IsRootdAllowed(const char *host);
- rpdunixsrv *RootdUnixSrv() const { return fRootdUnixSrv; }
- bool RootdFork() const { return fRootdFork; }
-
bool RemotePLite() const { return fRemotePLite; }
std::list<XrdProofdDSInfo *> *DataSetSrcs() { return &fDataSetSrcs; }
@@ -152,14 +146,6 @@ class XrdProofdManager : public XrdProofdConfig {
XrdOucString fDataSetExp; // List of local dataset repositories to be asserted
XrdOucString fStageReqRepo; // Directive for staging requests
-
- XrdOucString fRootdExe; // Path to 'rootd' to be use for protocol 'rootd://'
- std::list<XrdOucString> fRootdArgs;// Rootd arguments
- const char **fRootdArgsPtrs; // Null terminated array of arguments to execv 'rootd'
- std::list<XrdOucString> fRootdAllow;// Host allowed to open files via 'rootd'
- rpdunixsrv *fRootdUnixSrv; // Unix socket for rootd callbacks
- bool fRootdFork; // If true use fork to start rootd
-
XrdProtocol *fXrootd; // Reference instance of XrdXrootdProtocol
XrdOucString fXrootdLibPath; // Path to 'xrootd' plug-in
XrdSysPlugin *fXrootdPlugin; // 'xrootd' plug-in handler
diff --git a/proof/proofd/inc/XrdProofdProtocol.h b/proof/proofd/inc/XrdProofdProtocol.h
index 6d26eb9f8cefc47e73a6f85940b79ea4cb04f31e..d61b1e7219889d578a39e04489ce4910e97ac331 100644
--- a/proof/proofd/inc/XrdProofdProtocol.h
+++ b/proof/proofd/inc/XrdProofdProtocol.h
@@ -124,7 +124,6 @@ public:
int SendDataN(XrdProofdProofServ *xps, XrdSrvBuffer **buf = 0, bool sb = 0);
int SendMsg();
int CtrlC();
- int StartRootd(XrdLink *lp, XrdOucString &emsg);
void TouchAdminPath();
int Urgent();
diff --git a/proof/proofd/src/XrdProofdManager.cxx b/proof/proofd/src/XrdProofdManager.cxx
index aa0007eab646b5b5c495cb7f4bb9ed454b0c8c94..37082f272252fadc3b7e7669b87f21562247402b 100644
--- a/proof/proofd/src/XrdProofdManager.cxx
+++ b/proof/proofd/src/XrdProofdManager.cxx
@@ -250,28 +250,6 @@ XrdProofdManager::XrdProofdManager(char *parms, XrdProtocol_Config *pi, XrdSysEr
fDataDirOpts = ""; // Default: no action
fDataDirUrlOpts = ""; // Default: none
- ////// This is deprecated: see fXrootd below
- // Rootd file serving enabled by default in readonly mode
- fRootdExe = "";
- // Add mandatory arguments
- fRootdArgs.push_back(XrdOucString("-i"));
- fRootdArgs.push_back(XrdOucString("-nologin"));
- fRootdArgs.push_back(XrdOucString("-r")); // Readonly
- fRootdArgs.push_back(XrdOucString("-noauth")); // No auth
- // Build the argument list
- fRootdArgsPtrs = new const char *[fRootdArgs.size() + 2];
- fRootdArgsPtrs[0] = fRootdExe.c_str();
- int i = 1;
- std::list<XrdOucString>::iterator ia = fRootdArgs.begin();
- while (ia != fRootdArgs.end()) {
- fRootdArgsPtrs[i] = (*ia).c_str();
- ++i; ++ia;
- }
- fRootdArgsPtrs[fRootdArgs.size() + 1] = 0;
- // Started with 'system' (not 'fork')
- fRootdFork = 0;
- /////////////////////////////////////////////////////////////////
-
// Tools to enable xrootd file serving
fXrootdLibPath = "<>";
fXrootdPlugin = 0;
@@ -330,7 +308,6 @@ XrdProofdManager::~XrdProofdManager()
SafeDelete(fProofSched);
SafeDelete(fROOTMgr);
SafeDelete(fSessionMgr);
- SafeDelArray(fRootdArgsPtrs);
SafeDelete(fXrootdPlugin);
}
@@ -1241,61 +1218,8 @@ int XrdProofdManager::Config(bool rcf)
}
// Xrootd protocol service
- if ((fXrootd = LoadXrootd(fParms, fPi, fEDest))) {
- // If enabled, Xrootd takes precedence
- fRootdExe = "";
- }
-
- // File server
- if (fRootdExe.length() > 0) {
- // Absolute or relative?
- if (!fRootdExe.beginswith("/")) {
- if (fROOTMgr) {
- XrdOucString rtag;
- if (fRootdExe.beginswith("<") && fRootdExe.endswith(">")) {
- if (fRootdExe.length() > 2) rtag.assign(fRootdExe, 1, fRootdExe.length() - 2);
- fRootdExe = "rootd";
- fRootdArgsPtrs[0] = fRootdExe.c_str();
- }
- XrdROOT *roo = 0;
- if (rtag.length() <= 0 || !(roo = fROOTMgr->GetVersion(rtag.c_str())))
- roo = fROOTMgr->DefaultVersion();
- if (roo && strlen(roo->BinDir()) > 0) {
- XrdOucString bindir(roo->BinDir());
- if (!bindir.endswith("/")) bindir += "/";
- fRootdExe.insert(bindir, 0);
- fRootdArgsPtrs[0] = fRootdExe.c_str();
- }
- }
- }
- // Create unix socket where to accepts callbacks from rootd launchers
- XrdOucString sockpath;
- XPDFORM(sockpath, "%s/xpd.%d.%d.rootd", fSockPathDir.c_str(), fPort, getpid());
- fRootdUnixSrv = new rpdunixsrv(sockpath.c_str());
- if (!fRootdUnixSrv || (fRootdUnixSrv && !fRootdUnixSrv->isvalid(0))) {
- XPDERR("could not start unix server connection on path "<<
- sockpath<<" - errno: "<<(int)errno);
- fRootdExe = "";
- return -1;
- }
- TRACE(ALL, "unix socket path for rootd call backs: "<<sockpath);
- // Check if access is controlled
- if (fRootdAllow.size() > 0) {
- XrdOucString hhs;
- std::list<XrdOucString>::iterator ia = fRootdAllow.begin();
- while (ia != fRootdAllow.end()) {
- if (hhs.length() > 0) hhs += ",";
- hhs += (*ia).c_str();
- ++ia;
- }
- TRACE(ALL, "serving files with: '" << fRootdExe <<"' (protocol: 'rootd://') to ALLOWED hosts");
- TRACE(ALL, "rootd-allowed hosts: "<< hhs);
- } else {
- TRACE(ALL, "serving files with: '" << fRootdExe <<"' (protocol: 'rootd://') to ALL hosts");
- }
-
- } else {
- TRACE(ALL, "file serving (protocol: 'rootd://') explicitly disabled");
+ if (!(fXrootd = LoadXrootd(fParms, fPi, fEDest))) {
+ TRACE(ALL, "file serving (protocol: 'root://') not available");
}
if (!rcf) {
@@ -1425,8 +1349,6 @@ void XrdProofdManager::RegisterDirectives()
Register("port", new XrdProofdDirective("port", this, &DoDirectiveClass));
Register("datadir", new XrdProofdDirective("datadir", this, &DoDirectiveClass));
Register("datasetsrc", new XrdProofdDirective("datasetsrc", this, &DoDirectiveClass));
- Register("rootd", new XrdProofdDirective("rootd", this, &DoDirectiveClass));
- Register("rootdallow", new XrdProofdDirective("rootdallow", this, &DoDirectiveClass));
Register("xrd.protocol", new XrdProofdDirective("xrd.protocol", this, &DoDirectiveClass));
Register("filterlibpaths", new XrdProofdDirective("filterlibpaths", this, &DoDirectiveClass));
Register("xrootd", new XrdProofdDirective("xrootd", this, &DoDirectiveClass));
@@ -2015,68 +1937,11 @@ int XrdProofdManager::DoDirectiveXrootd(char *val, XrdOucStream *, bool)
/// xpd.rootd deny|allow [rootsys:<tag>] [path:abs-path/] [mode:ro|rw]
/// [auth:none|full] [other_rootd_args]
-int XrdProofdManager::DoDirectiveRootd(char *val, XrdOucStream *cfg, bool)
+int XrdProofdManager::DoDirectiveRootd(char *, XrdOucStream *, bool)
{
XPDLOC(ALL, "Manager::DoDirectiveRootd")
- if (!val)
- // undefined inputs
- return -1;
-
- // Rebuild arguments list
- fRootdArgs.clear();
- SafeDelArray(fRootdArgsPtrs);
-
- TRACE(ALL, "val: "<< val);
-
- // Parse directive
- XrdOucString mode("ro"), auth("none"), fork("0");
- bool denied = 1;
- char *nxt = val;
- do {
- if (!strcmp(nxt, "deny") || !strcmp(nxt, "disable") || !strcmp(nxt, "off")) {
- denied = 1;
- fRootdExe = "";
- } else if (!strcmp(nxt, "allow") || !strcmp(nxt, "enable") || !strcmp(nxt, "on")) {
- denied = 0;
- fRootdExe = "<>";
- TRACE(ALL, "Use of this directive is deprecated: use xpd.xrootd instead");
- } else if (!strncmp(nxt, "mode:", 5)) {
- mode = nxt + 5;
- } else if (!strncmp(nxt, "auth:", 5)) {
- auth = nxt + 5;
- } else if (!strncmp(nxt, "fork:", 5)) {
- fork = nxt + 5;
- } else {
- // Assume rootd argument
- fRootdArgs.push_back(XrdOucString(nxt));
- }
- } while ((nxt = cfg->GetWord()));
-
- if (!denied) {
- // If no exec given assume 'rootd' in the default path
- if (fRootdExe.length() <= 0) fRootdExe = "<>";
- // Add mandatory arguments
- fRootdArgs.push_back(XrdOucString("-i"));
- fRootdArgs.push_back(XrdOucString("-nologin"));
- if (mode == "ro") fRootdArgs.push_back(XrdOucString("-r"));
- if (auth == "none") fRootdArgs.push_back(XrdOucString("-noauth"));
- fRootdFork = (fork == "1" || fork == "yes") ? 1 : 0;
- } else {
- // Nothing else to do, if denied
- return 0;
- }
-
- // Build the argument list
- fRootdArgsPtrs = new const char *[fRootdArgs.size() + 2];
- fRootdArgsPtrs[0] = fRootdExe.c_str();
- int i = 1;
- std::list<XrdOucString>::iterator ia = fRootdArgs.begin();
- while (ia != fRootdArgs.end()) {
- fRootdArgsPtrs[i] = (*ia).c_str();
- ++i; ++ia;
- }
- fRootdArgsPtrs[fRootdArgs.size() + 1] = 0;
+ TRACE(ALL, "unsupported!!! ");
// Done
return 0;
@@ -2087,28 +1952,11 @@ int XrdProofdManager::DoDirectiveRootd(char *val, XrdOucStream *cfg, bool)
/// xpd.rootdallow host1,host2 host3
/// Host names may contain the wild card '*'
-int XrdProofdManager::DoDirectiveRootdAllow(char *val, XrdOucStream *cfg, bool)
+int XrdProofdManager::DoDirectiveRootdAllow(char *, XrdOucStream *, bool)
{
XPDLOC(ALL, "Manager::DoDirectiveRootdAllow")
- if (!val)
- // undefined inputs
- return -1;
-
- TRACE(ALL, "Use of this and 'xpd.rootd' directives is deprecated: use xpd.xrootd instead");
-
- TRACE(ALL, "val: "<< val);
-
- // Parse directive
- XrdOucString hosts, h;
- char *nxt = val;
- do {
- hosts = nxt;
- int from = 0;
- while ((from = hosts.tokenize(h, from, ',')) != -1) {
- if (h.length() > 0) fRootdAllow.push_back(h);
- }
- } while ((nxt = cfg->GetWord()));
+ TRACE(ALL, "unsupported!!! ");
// Done
return 0;
@@ -2153,32 +2001,6 @@ int XrdProofdManager::DoDirectiveFilterLibPaths(char *val, XrdOucStream *cfg, bo
return 0;
}
-////////////////////////////////////////////////////////////////////////////////
-/// Check if 'host' is allowed to access files via rootd
-
-bool XrdProofdManager::IsRootdAllowed(const char *host)
-{
- XPDLOC(ALL, "Manager::IsRootdAllowed")
-
- // Check if access is controlled
- if (fRootdAllow.size() <= 0) return 1;
-
- // Need an host name
- if (!host || strlen(host) <= 0) return 0;
-
- TRACE(DBG, "checking host: "<< host);
-
- XrdOucString h(host);
- std::list<XrdOucString>::iterator ia = fRootdAllow.begin();
- while (ia != fRootdAllow.end()) {
- if (h.matches((*ia).c_str(), '*') > 0) return 1;
- ++ia;
- }
-
- // Done
- return 0;
-}
-
////////////////////////////////////////////////////////////////////////////////
/// Process manager request
diff --git a/proof/proofd/src/XrdProofdProofServMgr.cxx b/proof/proofd/src/XrdProofdProofServMgr.cxx
index 040b9e6bcab4d3fcad0b4b244bc0e15769e1b553..7fad635914a9622a659679feef1927cae8903257 100644
--- a/proof/proofd/src/XrdProofdProofServMgr.cxx
+++ b/proof/proofd/src/XrdProofdProofServMgr.cxx
@@ -3538,17 +3538,8 @@ int XrdProofdProofServMgr::CreateProofServEnvFile(XrdProofdProtocol *p, void *in
// Local data server
XrdOucString locdatasrv;
- if (strlen(fMgr->RootdExe()) <= 0) {
- XPDFORM(locdatasrv, "root://%s", fMgr->Host());
- } else {
- XrdOucString uh(fMgr->Host());
- if (fMgr->MultiUser()) {
- XPDFORM(uh, "%s@%s", fMgr->EffectiveUser(), fMgr->Host());
- } else {
- XPDFORM(uh, "<effuser>@%s", fMgr->Host());
- }
- XPDFORM(locdatasrv, "rootd://%s:%d", uh.c_str(), fMgr->Port());
- }
+ XPDFORM(locdatasrv, "root://%s", fMgr->Host());
+
int nrk = fMgr->ResolveKeywords(locdatasrv, p->Client());
TRACE(HDBG, nrk << " placeholders resolved for LOCALDATASERVER");
len = strlen("LOCALDATASERVER=") + locdatasrv.length() + 2;
diff --git a/proof/proofd/src/XrdProofdProtocol.cxx b/proof/proofd/src/XrdProofdProtocol.cxx
index ed0d5a67d7c23eb284187641e6017e6bf650795a..2d7bd294e7f54c11f0a21d689665d03e1358f170 100644
--- a/proof/proofd/src/XrdProofdProtocol.cxx
+++ b/proof/proofd/src/XrdProofdProtocol.cxx
@@ -306,23 +306,10 @@ XrdProtocol *XrdProofdProtocol::Match(XrdLink *lp)
if ((dlen = lp->Peek(hsbuff,sizeof(hsdata),fgReadWait)) != sizeof(hsdata)) {
if (dlen <= 0) lp->setEtext("Match: handshake not received");
if (dlen == 12) {
- // Check if it is a request to open a file via 'rootd'
+ // Check if it is a request to open a file via 'rootd', unsupported
hsdata.first = ntohl(hsdata.first);
if (hsdata.first == 8) {
- if (strlen(fgMgr->RootdExe()) > 0) {
- if (fgMgr->IsRootdAllowed((const char *)lp->Host())) {
- TRACE(ALL, "matched rootd protocol on link: executing "<<fgMgr->RootdExe());
- XrdOucString em;
- if (StartRootd(lp, em) != 0) {
- emsg = "rootd: failed to start daemon: ";
- emsg += em;
- }
- } else {
- XPDFORM(emsg, "rootd-file serving not authorized for host '%s'", lp->Host());
- }
- } else {
- emsg = "rootd-file serving not enabled";
- }
+ emsg = "rootd-file serving not supported any-longer";
}
if (emsg.length() > 0) {
lp->setEtext(emsg.c_str());
@@ -386,105 +373,6 @@ XrdProtocol *XrdProofdProtocol::Match(XrdLink *lp)
return xp;
}
-////////////////////////////////////////////////////////////////////////////////
-/// Transfer the connection to a rootd daemon to serve a file access request
-/// Return 0 on success, -1 on failure
-
-int XrdProofdProtocol::StartRootd(XrdLink *lp, XrdOucString &emsg)
-{
- XPDLOC(ALL, "Protocol::StartRootd")
-
- const char *prog = fgMgr->RootdExe();
- const char **progArg = fgMgr->RootdArgs();
-
- if (fgMgr->RootdFork()) {
-
- // Start rootd using fork()
-
- pid_t pid;
- if ((pid = fgMgr->Sched()->Fork(lp->Name()))) {
- if (pid < 0) {
- emsg = "rootd fork failed";
- return -1;
- }
- return 0;
- }
- // In the child ...
-
- // Restablish standard error for the program we will exec
- dup2(fStdErrFD, STDERR_FILENO);
- close(fStdErrFD);
-
- // Force stdin/out to point to the socket FD (this will also bypass the
- // close on exec setting for the socket)
- dup2(lp->FDnum(), STDIN_FILENO);
- dup2(lp->FDnum(), STDOUT_FILENO);
-
- // Do the exec
- execv((const char *)prog, (char * const *)progArg);
- TRACE(XERR, "rootd: Oops! Exec(" <<prog <<") failed; errno: " <<errno);
- _exit(17);
-
- } else {
-
- // Start rootd using system + proofexecv
-
- // ROOT version
- XrdROOT *roo = fgMgr->ROOTMgr()->DefaultVersion();
- if (!roo) {
- emsg = "ROOT version undefined!";
- return -1;
- }
- // The path to the executable
- XrdOucString pexe;
- XPDFORM(pexe, "%s/proofexecv", roo->BinDir());
- if (access(pexe.c_str(), X_OK) != 0) {
- XPDFORM(emsg, "path '%s' does not exist or is not executable (errno: %d)",
- pexe.c_str(), (int)errno);
- return -1;
- }
-
- // Start the proofexecv
- XrdOucString cmd, exp;
- XPDFORM(cmd, "export ROOTBINDIR=\"%s\"; %s 20 0 %s %s", roo->BinDir(),
- pexe.c_str(), fgMgr->RootdUnixSrv()->path(), prog);
- int n = 1;
- while (progArg[n] != 0) {
- cmd += " "; cmd += progArg[n]; n++;
- }
- cmd += " &";
- TRACE(HDBG, cmd);
- if (system(cmd.c_str()) == -1) {
- XPDFORM(emsg, "failure from 'system' (errno: %d)", (int)errno);
- return -1;
- }
-
- // Accept a connection from the second server
- int err = 0;
- rpdunix *uconn = fgMgr->RootdUnixSrv()->accept(-1, &err);
- if (!uconn || !uconn->isvalid(0)) {
- XPDFORM(emsg, "failure accepting callback (errno: %d)", -err);
- if (uconn) delete uconn;
- return -1;
- }
- TRACE(HDBG, "proofexecv connected!");
-
- int rcc = 0;
- // Transfer the open descriptor to be used in rootd
- int fd = dup(lp->FDnum());
- if (fd < 0 || (rcc = uconn->senddesc(fd)) != 0) {
- XPDFORM(emsg, "failure sending descriptor '%d' (original: %d); (errno: %d)", fd, lp->FDnum(), -rcc);
- if (uconn) delete uconn;
- return -1;
- }
- // Close the connection to the parent
- delete uconn;
- }
-
- // Done
- return 0;
-}
-
////////////////////////////////////////////////////////////////////////////////
/// Return statistics info about the protocol.
/// Not really implemented yet: this is a reduced XrdXrootd version.
diff --git a/proof/proofd/src/proofexecv.cxx b/proof/proofd/src/proofexecv.cxx
index 74d14e53e5977710d6478e6bc92d34bd212461e0..598a3000388f9c0deb8067da7ea1ca5f3df5bb24 100644
--- a/proof/proofd/src/proofexecv.cxx
+++ b/proof/proofd/src/proofexecv.cxx
@@ -62,7 +62,6 @@ int setproofservenv(const std::string &envfile,
int redirectoutput(const std::string &logfile);
void start_ps(int argc, char **argv);
-void start_rootd(int argc, char **argv);
////////////////////////////////////////////////////////////////////////////////
/// Write info message to syslog.
@@ -107,8 +106,8 @@ int main(int argc, char **argv)
start_ps(argc, argv);
exit(1);
} else if (gType == 20) {
- // Start a rootd to serve a file
- start_rootd(argc, argv);
+ // rootd not supported anylonger
+ Info("ERROR: 'rootd' has been removed from ROOT");
exit(1);
} else {
Info("ERROR: process type %d not yet implemented", gType);
@@ -119,71 +118,6 @@ int main(int argc, char **argv)
exit(0);
}
-////////////////////////////////////////////////////////////////////////////////
-/// Process a request to start a rootd server
-
-void start_rootd(int argc, char **argv)
-{
- if (argc < 6) {
- Info("argc=%d: at least 5 additional arguments required - exit", argc);
- return;
- }
-
- // Parse arguments:
- // 1 process type (2=top-master, 1=sub-master 0=worker, 3=test, 10=admin, 20=rootd)
- // 2 debug level
- // 3 path to unix socket to the parent to receive the open descriptor
- // 4 path to rootd executable
- // >=5 arguments to rootd
-
- // Call back the parent, so that it can move to other processes
- std::string sockpath = argv[3];
- rpdunix *uconn = new rpdunix(sockpath.c_str());
- if (!uconn || (uconn && !uconn->isvalid(0))) {
- Info("ERROR: failure calling back parent on '%s'", sockpath.c_str());
- return;
- }
-
- int rcc = 0;
- // Receive the open descriptor to be used in rootd
- int fd = -1;
- if ((rcc = uconn->recvdesc(fd)) != 0) {
- Info("ERROR: failure receiving open descriptor from parent (errno: %d)", -rcc);
- delete uconn;
- return;
- }
- // Close the connection to the parent
- delete uconn;
-
- // Force stdin/out to point to the socket FD (this will also bypass the
- // close on exec setting for the socket)
- if (dup2(fd, STDIN_FILENO) != 0)
- Info("WARNING: failure duplicating STDIN (errno: %d)", errno);
- if (dup2(fd, STDOUT_FILENO) != 0)
- Info("WARNING: failure duplicating STDOUT (errno: %d)", errno);
-
- // Prepare execv
- int na = argc - 4;
- char **argvv = new char *[na + 1];
-
- // Fill arguments
- argvv[0] = argv[4];
- int ia = 5, ka = 1;
- while (ia < argc) {
- argvv[ka] = argv[ia];
- ka++; ia++;
- }
- argvv[na] = 0;
-
- // Run the program
- execv(argv[4], argvv);
-
- // We should not be here!!!
- Info("ERROR: returned from execv: bad, bad sign !!!");
- delete [] argvv;
- return;
-}
-
////////////////////////////////////////////////////////////////////////////////
/// Process a request to start a proofserv process
@@ -195,7 +129,7 @@ void start_ps(int argc, char **argv)
}
// Parse arguments:
- // 1 process type (2=top-master, 1=sub-master 0=worker, 3=test, 10=admin, 20=rootd)
+ // 1 process type (2=top-master, 1=sub-master 0=worker, 3=test, 10=admin)
// 2 debug level
// 3 user name
// 4 root path for relevant directories and files (to be completed with PID)