XrdConfig Class Reference

#include <XrdConfig.hh>

Collaboration diagram for XrdConfig:

Public Member Functions
	XrdConfig ()
	~XrdConfig ()
int	Configure (int argc, char **argv)
int	ConfigXeq (char *var, XrdOucStream &Config, XrdSysError *eDest=0)

Public Attributes
XrdInet *	NetADM
std::vector< XrdInet * >	NetTCP
XrdProtocol_Config	ProtInfo

Detailed Description

Definition at line 47 of file XrdConfig.hh.

Constructor & Destructor Documentation

XrdConfig()

XrdConfig::XrdConfig

(

)

Definition at line 249 of file XrdConfig.cc.

{
 
// Preset all variables with common defaults
//
   PortTCP  = -1;
   PortUDP  = -1;
   PortTLS  = -1;
   ConfigFN = 0;
   tmoInfo  = 0;
   myInsName= 0;
   mySitName= 0;
   AdminPath= strdup("/tmp");
   HomePath = 0;
   PidPath  = strdup("/tmp");
   tlsCert  = 0;
   tlsKey   = 0;
   caDir    = 0;
   caFile   = 0;
   AdminMode= S_IRWXU;
   HomeMode = S_IRWXU;
   Police   = 0;
   Net_Opts = XRDNET_KEEPALIVE;
   TLS_Blen = 0;  // Accept OS default (leave Linux autotune in effect)
   TLS_Opts = XRDNET_KEEPALIVE | XRDNET_USETLS;
   repDest[0] = 0;
   repDest[1] = 0;
   repInt     = 600;
   ppNet      = 0;
   tlsOpts    = 9ULL | XrdTlsContext::servr | XrdTlsContext::logVF;
   tlsNoVer   = false;
   tlsNoCAD   = true;
   NetADM     = 0;
   coreV      = 1;
   Specs      = 0;
   isStrict   = false;
   maxFD      = 256*1024;  // 256K default
 
   Firstcp = Lastcp = 0;
 
   ProtInfo.eDest   = &Log;             // Stable -> Error Message/Logging Handler
   ProtInfo.NetTCP  = 0;                // Stable -> Network Object
   ProtInfo.BPool   = &BuffPool;        // Stable -> Buffer Pool Manager
   ProtInfo.Sched   = &Sched;           // Stable -> System Scheduler
   ProtInfo.ConfigFN= 0;                // We will fill this in later
   ProtInfo.Stats   = 0;                // We will fill this in later
   ProtInfo.AdmPath = AdminPath;        // Stable -> The admin path
   ProtInfo.AdmMode = AdminMode;        // Stable -> The admin path mode
   ProtInfo.theEnv  = &theEnv;          // Additional information
   ProtInfo.xrdFlags= 0;                // Additional information
 
   ProtInfo.Format   = XrdFORMATB;
   memset(ProtInfo.rsvd3, 0, sizeof(ProtInfo.rsvd3));
   ProtInfo.WSize    = 0;
   ProtInfo.ConnMax  = -1;     // Max       connections (fd limit)
   ProtInfo.readWait = 3*1000; // Wait time for data before we reschedule
   ProtInfo.idleWait = 0;      // Seconds connection may remain idle (0=off)
   ProtInfo.hailWait =30*1000; // Wait time for data before we drop connection
   ProtInfo.DebugON  = 0;      // 1 if started with -d
   ProtInfo.argc     = 0;
   ProtInfo.argv     = 0;
   ProtInfo.tlsPort  = 0;
   ProtInfo.tlsCtx   = 0;
   ProtInfo.totalCF  = &totalCF;
 
   XrdNetAddr::SetCache(3*60*60); // Cache address resolutions for 3 hours
 
   // This may reset the NPROC resource limit, which is done here as we
   // expect to be operating as a daemon. We set the argument limlower=true
   // to potentially set a more restrictive limit than the current one.
   Sched.setNproc(true);
}

References XrdGlobal::BuffPool, XrdGlobal::Log, XrdTlsContext::logVF, XrdGlobal::Sched, XrdTlsContext::servr, XrdNetAddr::SetCache(), XrdScheduler::setNproc(), XrdScheduler::Stats(), XrdCms::theEnv, XrdGlobal::totalCF, XrdFORMATB, XRDNET_KEEPALIVE, and XRDNET_USETLS.

Here is the call graph for this function:

~XrdConfig()

XrdConfig::~XrdConfig ( )

inline

Definition at line 56 of file XrdConfig.hh.

{}

Member Function Documentation

Configure()

int XrdConfig::Configure	(	int	argc,
		char **	argv
	)

Definition at line 326 of file XrdConfig.cc.

{
/*
  Function: Establish configuration at start up time.
 
  Input:    None.
 
  Output:   0 upon success or !0 otherwise.
*/
   const char *xrdInst="XRDINSTANCE=";
 
   int retc, NoGo = 0, clPort = -1;
   const char *temp;
   char c, buff[512], *dfltProt, *libProt = 0;
   uid_t myUid = 0;
   gid_t myGid = 0;
   extern char *optarg;
   extern int optind, opterr;
   struct XrdOucLogging::configLogInfo LogInfo;
   int pipeFD[2] = {-1, -1};
   const char *pidFN = 0;
   static const int myMaxc = 80;
   char **urArgv, *myArgv[myMaxc], argBuff[myMaxc*3+8];
   char *argbP = argBuff, *argbE = argbP+sizeof(argBuff)-4;
   char *ifList = 0;
   int   myArgc = 1, urArgc = argc, i;
   bool noV6, ipV4 = false, ipV6 = false, rootChk = true, optbg = false;
 
// Reconstruct the command line so we can put it in the log
//
   XrdOucString CmdLine(argv[0]);
   for (int k = 1; k < argc; k++)
       {CmdLine += ' '; CmdLine += argv[k];}
 
// Obtain the program name we will be using
//
    retc = strlen(argv[0]);
    while(retc--) if (argv[0][retc] == '/') break;
    myProg = &argv[0][retc+1];
 
// Setup the initial required protocol. The program name matches the protocol
// name but may be arbitrarily suffixed. We need to ignore this suffix. So we
// look for it here and it it exists we duplicate argv[0] (yes, loosing some
// bytes - sorry valgrind) without the suffix.
//
  {char *p = dfltProt = strdup(myProg);
   while(*p && (*p == '.' || *p == '-')) p++;
   if (*p)
      {char *dot = index(p, '.'), *dash = index(p, '-');
       if (dot  && (dot < dash || !dash)) p = dot;
          else if (dash) p = dash;
                  else   p = 0;
       if (p) *p = '\0';
            if (!strcmp("xrootd", dfltProt)) dfltProt[5] = 0;
       else if (!strcmp("cmsd",   dfltProt)) dfltProt[3] = 0;
      }
  }
   myArgv[0] = argv[0];
 
// Prescan the argument list to see if there is a passthrough option. In any
// case, we will set the ephemeral argv/arg in the environment.
//
  i = 1;
  while(i < argc)
      {if (*(argv[i]) == '-' && *(argv[i]+1) == '+')
          {int n = strlen(argv[i]+2), j = i+1, k = 1;
           if (urArgc == argc) urArgc = i;
           if (n) memcpy(buff, argv[i]+2, (n > 256 ? 256 : n));
           strcpy(&(buff[n]), ".argv**");
           while(j < argc && (*(argv[j]) != '-' || *(argv[j]+1) != '+')) j++;
           urArgv = new char*[j-i+1];
           urArgv[0] = argv[0];
           i++;
           while(i < j) urArgv[k++] = argv[i++];
           urArgv[k] = 0;
           theEnv.PutPtr(buff, urArgv);
           strcpy(&(buff[n]), ".argc");
           theEnv.PutInt(buff, static_cast<long>(k));
          } else i++;
      }
   theEnv.PutPtr("argv[0]", argv[0]);
 
// Process the options. Note that we cannot passthrough long options or
// options that take arguments because getopt permutes the arguments.
//
   opterr = 0;
   if (argc > 1 && '-' == *argv[1])
      while ((c = getopt(urArgc,argv,":a:A:bc:dhHI:k:l:L:n:N:p:P:R:s:S:vw:W:z"))
             && ((unsigned char)c != 0xff))
     { switch(c)
       {
       case 'a': if (AdminPath) free(AdminPath);
                 AdminPath = strdup(optarg);
                 AdminMode = ProtInfo.AdmMode = S_IRWXU;
                 ProtInfo.xrdFlags |= XrdProtocol_Config::admPSet;
                 break;
       case 'A': if (AdminPath) free(AdminPath);
                 AdminPath = strdup(optarg);
                 AdminMode = ProtInfo.AdmMode = S_IRWXU | S_IRWXG;
                 ProtInfo.xrdFlags |= XrdProtocol_Config::admPSet;
                 break;
       case 'b': optbg = true;
                 break;
       case 'c': if (ConfigFN) free(ConfigFN);
                 ConfigFN = strdup(optarg);
                 break;
       case 'd': XrdTrace.What |= TRACE_ALL;
                 ProtInfo.DebugON = 1;
                 XrdOucEnv::Export("XRDDEBUG",  "1");
                 break;
       case 'h': Usage(0);
                 break;
       case 'H': Usage(-1);
                 break;
       case 'I':      if (!strcmp("v4", optarg)) {ipV4 = true;  ipV6 = false;}
                 else if (!strcmp("v6", optarg)) {ipV4 = false; ipV6 = true;}
                 else {Log.Emsg("Config", "Invalid -I argument -",optarg);
                       Usage(1);
                      }
                 break;
       case 'k': if (!(LogInfo.keepV = Log.logger()->ParseKeep(optarg)))
                    {Log.Emsg("Config","Invalid -k argument -",optarg);
                     Usage(1);
                    }
                 break;
       case 'l': LogInfo.logArg = optarg;
                 break;
       case 'L': if (!*optarg)
                    {Log.Emsg("Config", "Protocol library path not specified.");
                     Usage(1);
                    }
                 if (libProt) free(libProt);
                 libProt = strdup(optarg);
                 break;
       case 'n': myInsName = (!strcmp(optarg,"anon")||!strcmp(optarg,"default")
                           ? 0 : optarg);
                 break;
       case 'N': XrdNetIdentity::SetFQN(optarg);
                 break;
       case 'p': if ((clPort = XrdOuca2x::a2p(Log,"tcp",optarg)) < 0) Usage(1);
                 break;
       case 'P': if (dfltProt) free(dfltProt);
                 dfltProt = strdup(optarg);
                 break;
       case 'R': if (!(getUG(optarg, myUid, myGid))) Usage(1);
                 rootChk = false;
                 break;
       case 's': pidFN = optarg;
                 break;
       case 'S': mySitName = optarg;
                 break;
       case ':': buff[0] = '-'; buff[1] = optopt; buff[2] = 0;
                 Log.Emsg("Config", buff, "parameter not specified.");
                 Usage(1);
                 break;
       case 'v': std::cerr <<XrdVSTRING <<std::endl;
                 _exit(0);
                 break;
       case 'w': if (HomePath) free(HomePath);
                 HomePath = strdup(optarg);
                 HomeMode = S_IRWXU;
                 Specs |= hpSpec;
                 break;
       case 'W': if (HomePath) free(HomePath);
                 HomePath = strdup(optarg);
                 HomeMode = S_IRWXU | S_IRGRP | S_IXGRP;
                 Specs |= hpSpec;
                 break;
       case 'z': LogInfo.hiRes = true;
                 break;
 
       default: if (optopt == '-' && *(argv[optind]+1) == '-')
                   {Log.Emsg("Config", "Long options are not supported.");
                    Usage(1);
                   }
                if (myArgc >= myMaxc || argbP >= argbE)
                   {Log.Emsg("Config", "Too many command line arguments.");
                    Usage(1);
                   }
                myArgv[myArgc++] = argbP;
                *argbP++ = '-'; *argbP++ = optopt; *argbP++ = 0;
                break;
       }
     }
 
// If an adminpath specified, make sure it's absolute
//
   if ((ProtInfo.xrdFlags & XrdProtocol_Config::admPSet) && *AdminPath != '/')
      {Log.Emsg("Config", "Command line adminpath is not absolute.");
       exit(17);
      }
 
// If an homepath specified, make sure it's absolute
//
   if (HomePath && *HomePath != '/')
      {Log.Emsg("Config", "Command line home path is not absolute.");
       exit(17);
      }
 
// If the configuration file is relative to where we are, get the absolute
// path as we may be changing the home path. This also starts capturing.
//
   if (ConfigFN) setCFG(true);
 
// The first thing we must do is to set the correct networking mode
//
   noV6 = XrdNetAddr::IPV4Set();
        if (ipV4) XrdNetAddr::SetIPV4();
   else if (ipV6){if (noV6) Log.Say("Config warning: ipV6 appears to be broken;"
                                    " forced ipV6 mode not advised!");
                  XrdNetAddr::SetIPV6();
                 }
   else if (noV6) Log.Say("Config warning: ipV6 is misconfigured or "
                          "unavailable; reverting to ipV4.");
 
// Set the site name if we have one
//
   if (mySitName) mySitName = XrdOucSiteName::Set(mySitName, 63);
 
// Drop into non-privileged state if so requested
//
   if (myGid && setegid(myGid))
      {Log.Emsg("Config", errno, "set effective gid"); exit(17);}
   if (myUid && seteuid(myUid))
      {Log.Emsg("Config", errno, "set effective uid"); exit(17);}
 
// Prohibit this program from executing as superuser unless -R was specified.
//
   if (rootChk && geteuid() == 0)
      {Log.Emsg("Config", "Security reasons prohibit running as "
                "superuser; program is terminating.");
       _exit(8);
      }
 
// Pass over any parameters
//
   if (urArgc-optind+2 >= myMaxc)
      {Log.Emsg("Config", "Too many command line arguments.");
       Usage(1);
      }
   for ( ; optind < urArgc; optind++) myArgv[myArgc++] = argv[optind];
 
// Record the actual arguments that we will pass on
//
   myArgv[myArgc] = 0;
   ProtInfo.argc = myArgc;
   ProtInfo.argv = myArgv;
 
// Resolve background/foreground issues
//
   if (optbg)
   {
#ifdef WIN32
      XrdOucUtils::Undercover(&Log, !LogInfo.logArg);
#else
      if (pipe( pipeFD ) == -1)
         {Log.Emsg("Config", errno, "create a pipe"); exit(17);}
      XrdOucUtils::Undercover(Log, !LogInfo.logArg, pipeFD);
#endif
   }
 
// Get the full host name. We must define myIPAddr here because we may need to
// run in v4 mode and that doesn't get set until after the options are scanned.
//
   static XrdNetAddr *myIPAddr = new XrdNetAddr((int)0);
   if (!(myName = myIPAddr->Name(0, &temp))) myName = "";
 
// Get our IP address and FQN
//
   ProtInfo.myName = myName;
   ProtInfo.myAddr = myIPAddr->SockAddr();
   ProtInfo.myInst = XrdOucUtils::InstName(myInsName);
   ProtInfo.myProg = myProg;
 
// Set the Environmental variable to hold the instance name
// XRDINSTANCE=<pgm> <instance name>@<host name>
//                 XrdOucEnv::Export("XRDINSTANCE")
//
   sprintf(buff,"%s%s %s@%s", xrdInst, myProg, ProtInfo.myInst, myName);
   myInstance = strdup(buff);
   putenv(myInstance);   // XrdOucEnv::Export("XRDINSTANCE",...)
   myInstance += strlen(xrdInst);
   XrdOucEnv::Export("XRDHOST", myName);
   XrdOucEnv::Export("XRDNAME", ProtInfo.myInst);
   XrdOucEnv::Export("XRDPROG", myProg);
 
// Bind the log file if we have one
//
   if (LogInfo.logArg)
      {LogInfo.xrdEnv = &theEnv;
       LogInfo.iName  = myInsName;
       LogInfo.cfgFn  = ConfigFN;
       if (!XrdOucLogging::configLog(Log, LogInfo)) _exit(16);
       Log.logger()->AddMsg(CmdLine.c_str());
       Log.logger()->AddMsg(XrdBANNER);
      }
 
// We now test for host name. In theory, we should always get some kind of name.
// We can't really continue without some kind of name at this point. Note that
// vriable temp should still be valid from the previous NetAddr call.
//
   if (!(*myName))
      {Log.Emsg("Config", "Unable to determine host name; ",
                           (temp ? temp : "reason unknown"),
                           "; execution terminated.");
       _exit(16);
      }
 
// Tell NetIF what logger to use as it's been properly setup by now.
//
   XrdNetIF::SetMsgs(&Log);
 
// Put out the herald
//
   strcpy(buff, "Starting on ");
   retc = strlen(buff);
   XrdSysUtils::FmtUname(buff+retc, sizeof(buff)-retc);
   Log.Say(0, buff);
   Log.Say(0, CmdLine.c_str());
   Log.Say(XrdBANNER);
 
// Verify that we have a real name. We've had problems with people setting up
// bad /etc/hosts files that can cause connection failures if "allow" is used.
// Otherwise, determine our domain name.
//
   if (!myIPAddr->isRegistered())
      {Log.Emsg("Config",myName,"does not appear to be registered in the DNS.");
       Log.Emsg("Config","Verify that the '/etc/hosts' file is correct and "
                         "this machine is registered in DNS.");
       Log.Emsg("Config", "Execution continues but connection failures may occur.");
       myDomain = 0;
      } else if (!(myDomain = index(myName, '.')))
                Log.Say("Config warning: this hostname, ", myName,
                            ", is registered without a domain qualification.");
 
// Setup the initial required protocol.
//
   Firstcp = Lastcp = new XrdConfigProt(strdup(dfltProt), libProt, 0);
 
// Let start it up!
//
   Log.Say("++++++ ", myInstance, " initialization started.");
 
// Allocate /dev/null as we need it and can't live without it
//
   devNull = XrdSysFD_Open("/dev/null", O_RDONLY);
   if (devNull < 0)
      {Log.Emsg("Config", errno, "open '/dev/null' which is required!");
       NoGo = 1;
      }
 
// Process the configuration file, if one is present
//
   if (ConfigFN)
      {Log.Say("Config using configuration file ", ConfigFN);
       ProtInfo.ConfigFN = ConfigFN;
       NoGo = ConfigProc();
      }
   if (clPort >= 0) PortTCP = clPort;
   if (ProtInfo.DebugON)
      {XrdTrace.What = TRACE_ALL;
       XrdSysThread::setDebug(&Log);
      }
 
// Setup the admin path now
//
   NoGo |= SetupAPath();
 
// If tls enabled, set it up. We skip this if we failed to avoid confusing msgs
//
   if (!NoGo)
      {if (!tlsCert) ProtInfo.tlsCtx= 0;
          else {Log.Say("++++++ ", myInstance, " TLS initialization started.");
                if (SetupTLS())
                   {Log.Say("------ ",myInstance," TLS initialization ended.");
                    if ((ProtInfo.tlsCtx = XrdGlobal::tlsCtx))
                       theEnv.PutPtr("XrdTlsContext*", XrdGlobal::tlsCtx);
                   } else {
                    NoGo = 1;
                    Log.Say("------ ",myInstance," TLS initialization failed.");
                   }
               }
      }
 
// If there is TLS port verify that it can be used. We ignore this if we
// will fail anyway so as to not issue confusing messages.
//
   if (!NoGo)
      {if (PortTLS > 0 && !XrdGlobal::tlsCtx)
          {Log.Say("Config TLS port specification ignored; TLS not configured!");
           PortTLS = -1;
          } else {
           ProtInfo.tlsCtx  = XrdGlobal::tlsCtx;
           ProtInfo.tlsPort = (PortTLS > 0 ? PortTLS : 0);
         }
      }
 
// Put largest buffer size in the env
//
   theEnv.PutInt("MaxBuffSize", XrdGlobal::xlBuff.MaxSize());
 
// Export the network interface list at this point
//
   if (ppNet && XrdNetIF::GetIF(ifList, 0, true))
      XrdOucEnv::Export("XRDIFADDRS",ifList);
 
// Configure network routing
//
   if (!XrdInet::netIF.SetIF(myIPAddr, ifList))
      {Log.Emsg("Config", "Unable to determine interface addresses!");
       NoGo = 1;
      }
 
// If we have an instance name change the working directory
//
   if ((myInsName || HomePath)
   &&  !XrdOucUtils::makeHome(Log, myInsName, HomePath, HomeMode)) NoGo = 1;
 
// Start the UDP network address refresher.
//
   XrdNetRefresh::Start(&Logger, &Sched);
 
// Create the pid file
//
   if (!PidFile(pidFN, optbg)) NoGo = 1;
 
// Establish a manifest file for auto-collection
//
   if (!NoGo) Manifest(pidFN);
 
// Now initialize the protocols and other stuff
//
   if (!NoGo) NoGo = Setup(dfltProt, libProt);
 
// End config capture
//
   setCFG(false);
 
// If we have a tcpmon plug-in try loading it now. We won't do that unless
// tcp monitoring was enabled by the monitoring framework.
//
   if (tmoInfo && !NoGo)
      {void *theGS = theEnv.GetPtr("TcpMon.gStream*");
       if (!theGS) Log.Say("Config warning: TCP monitoring not enabled; "
                   "tcpmonlib plugin not loaded!");
           else {tmoInfo->theEnv.PutPtr("TcpMon.gStream*", theGS);
                 TcpMonPin = tmoInfo->KingPin.Load("TcpMonPin");
                 if (!TcpMonPin) NoGo = 1;
                }
      }
 
   // if we call this it means that the daemon has forked and we are
   // in the child process
#ifndef WIN32
   if (optbg)
   {
      int status = NoGo ? 1 : 0;
      if(write( pipeFD[1], &status, sizeof( status ) )) {};
      close( pipeFD[1]);
   }
#endif
 
// All done, close the stream and return the return code.
//
   temp = (NoGo ? " initialization failed." : " initialization completed.");
   sprintf(buff, "%s:%d", myInstance, PortTCP);
   Log.Say("------ ", buff, temp);
   if (LogInfo.logArg)
      {strcat(buff, " running ");
       retc = strlen(buff);
       XrdSysUtils::FmtUname(buff+retc, sizeof(buff)-retc);
       Log.logger()->AddMsg(buff);
      }
   return NoGo;
}

References XrdOuca2x::a2p(), XrdSysLogger::AddMsg(), XrdProtocol_Config::admPSet, XrdOucString::c_str(), XrdOucLogging::configLogInfo::cfgFn, close, XrdOucLogging::configLog(), XrdGlobal::devNull, XrdSysError::Emsg(), XrdOucEnv::Export(), XrdSysUtils::FmtUname(), XrdNetIF::GetIF(), XrdOucEnv::GetPtr(), XrdOucLogging::configLogInfo::hiRes, XrdOucLogging::configLogInfo::iName, XrdOucUtils::InstName(), XrdNetAddr::IPV4Set(), XrdNetAddrInfo::isRegistered(), XrdOucLogging::configLogInfo::keepV, XrdGlobal::Log, XrdOucLogging::configLogInfo::logArg, XrdGlobal::Logger, XrdSysError::logger(), XrdOucUtils::makeHome(), XrdNetPMarkConfig::myDomain, XrdNetAddrInfo::Name(), XrdInet::netIF, optind, optopt, XrdSysLogger::ParseKeep(), XrdOucEnv::PutInt(), XrdOucEnv::PutPtr(), XrdSysError::Say(), XrdGlobal::Sched, XrdOucSiteName::Set(), XrdSysThread::setDebug(), XrdNetIdentity::SetFQN(), XrdNetAddr::SetIPV4(), XrdNetAddr::SetIPV6(), XrdNetIF::SetMsgs(), XrdNetAddrInfo::SockAddr(), XrdNetRefresh::Start(), XrdGlobal::TcpMonPin, XrdCms::theEnv, XrdGlobal::tlsCtx, TRACE_ALL, XrdOucUtils::Undercover(), Usage(), XrdSysTrace::What, write(), XrdGlobal::xlBuff, XrdBANNER, XrdOucLogging::configLogInfo::xrdEnv, and XrdGlobal::XrdTrace.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigXeq()

int XrdConfig::ConfigXeq	(	char *	var,
		XrdOucStream &	Config,
		XrdSysError *	eDest = 0
	)

Definition at line 806 of file XrdConfig.cc.

{
   int dynamic;
 
   // Determine whether is is dynamic or not
   //
   if (eDest) dynamic = 1;
      else   {dynamic = 0; eDest = &Log;}
 
   // Process common items
   //
   TS_Xeq("buffers",       xbuf);
   TS_Xeq("network",       xnet);
   TS_Xeq("sched",         xsched);
   TS_Xeq("trace",         xtrace);
 
   // Process items that can only be processed once
   //
   if (!dynamic)
   {
   TS_Xeq("adminpath",     xapath);
   TS_Xeq("allow",         xallow);
   TS_Xeq("homepath",      xhpath);
   TS_Xeq("maxfd",         xmaxfd);
   TS_Xeq("pidpath",       xpidf);
   TS_Xeq("port",          xport);
   TS_Xeq("protocol",      xprot);
   TS_Xeq("report",        xrep);
   TS_Xeq("sitename",      xsit);
   TS_Xeq("tcpmonlib",     xtcpmon);
   TS_Xeq("timeout",       xtmo);
   TS_Xeq("tls",           xtls);
   TS_Xeq("tlsca",         xtlsca);
   TS_Xeq("tlsciphers",    xtlsci);
   }
 
   // No match found, complain.
   //
   eDest->Say("Config warning: ignoring unknown xrd directive '",var,"'.");
   Config.Echo();
   return 0;
}

References XrdCms::Config, eDest, XrdGlobal::Log, XrdSysError::Say(), and TS_Xeq.

Here is the call graph for this function:

Member Data Documentation

NetADM

XrdInet* XrdConfig::NetADM

Definition at line 59 of file XrdConfig.hh.

Referenced by main().

NetTCP

std::vector<XrdInet*> XrdConfig::NetTCP

Definition at line 60 of file XrdConfig.hh.

Referenced by main().

ProtInfo

XrdProtocol_Config XrdConfig::ProtInfo

Definition at line 58 of file XrdConfig.hh.

Referenced by main(), mainAccept(), and mainAdmin().

---

The documentation for this class was generated from the following files:

• XrdConfig.hh
• XrdConfig.cc