XRootD
Loading...
Searching...
No Matches
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

XrdInetNetADM
 
std::vector< XrdInet * > NetTCP
 
XrdProtocol_Config ProtInfo
 

Detailed Description

Definition at line 46 of file XrdConfig.hh.

Constructor & Destructor Documentation

◆ XrdConfig()

XrdConfig::XrdConfig ( )

Definition at line 245 of file XrdConfig.cc.

246{
247
248// Preset all variables with common defaults
249//
250 PortTCP = -1;
251 PortUDP = -1;
252 PortTLS = -1;
253 ConfigFN = 0;
254 tmoInfo = 0;
255 myInsName= 0;
256 mySitName= 0;
257 AdminPath= strdup("/tmp");
258 HomePath = 0;
259 PidPath = strdup("/tmp");
260 tlsCert = 0;
261 tlsKey = 0;
262 caDir = 0;
263 caFile = 0;
264 AdminMode= S_IRWXU;
265 HomeMode = S_IRWXU;
266 Police = 0;
267 Net_Opts = XRDNET_KEEPALIVE;
268 TLS_Blen = 0; // Accept OS default (leave Linux autotune in effect)
269 TLS_Opts = XRDNET_KEEPALIVE | XRDNET_USETLS;
270 repDest[0] = 0;
271 repDest[1] = 0;
272 repInt = 600;
273 repOpts = 0;
274 ppNet = 0;
276 tlsNoVer = false;
277 tlsNoCAD = true;
278 NetADM = 0;
279 coreV = 1;
280 Specs = 0;
281 isStrict = false;
282 maxFD = 256*1024; // 256K default
283
284 Firstcp = Lastcp = 0;
285
286 ProtInfo.eDest = &Log; // Stable -> Error Message/Logging Handler
287 ProtInfo.NetTCP = 0; // Stable -> Network Object
288 ProtInfo.BPool = &BuffPool; // Stable -> Buffer Pool Manager
289 ProtInfo.Sched = &Sched; // Stable -> System Scheduler
290 ProtInfo.ConfigFN= 0; // We will fill this in later
291 ProtInfo.Stats = 0; // We will fill this in later
292 ProtInfo.AdmPath = AdminPath; // Stable -> The admin path
293 ProtInfo.AdmMode = AdminMode; // Stable -> The admin path mode
294 ProtInfo.theEnv = &theEnv; // Additional information
295 ProtInfo.xrdFlags= 0; // Additional information
296
297 ProtInfo.Format = XrdFORMATB;
298 memset(ProtInfo.rsvd3, 0, sizeof(ProtInfo.rsvd3));
299 ProtInfo.WSize = 0;
300 ProtInfo.ConnMax = -1; // Max connections (fd limit)
301 ProtInfo.readWait = 3*1000; // Wait time for data before we reschedule
302 ProtInfo.idleWait = 0; // Seconds connection may remain idle (0=off)
303 ProtInfo.hailWait =30*1000; // Wait time for data before we drop connection
304 ProtInfo.DebugON = 0; // 1 if started with -d
305 ProtInfo.argc = 0;
306 ProtInfo.argv = 0;
307 ProtInfo.tlsPort = 0;
308 ProtInfo.tlsCtx = 0;
309 ProtInfo.totalCF = &totalCF;
310
311 XrdNetAddr::SetCache(3*60*60); // Cache address resolutions for 3 hours
312}
#define XrdFORMATB
Definition XrdInfo.hh:36
#define XRDNET_KEEPALIVE
Definition XrdNetOpts.hh:63
#define XRDNET_USETLS
Definition XrdNetOpts.hh:91
XrdInet * NetADM
Definition XrdConfig.hh:58
static void SetCache(int keeptime)
int Stats(char *buff, int blen, int do_sync=0)
static const uint64_t servr
This is a server context.
static const uint64_t logVF
Log verify failures.
XrdOucEnv theEnv
XrdSysError Log
Definition XrdConfig.cc:112
XrdScheduler Sched
Definition XrdLinkCtl.cc:54
XrdOucString totalCF
Definition XrdConfig.cc:110
XrdBuffManager BuffPool
Definition XrdGlobals.cc:51

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

+ Here is the call graph for this function:

◆ ~XrdConfig()

XrdConfig::~XrdConfig ( )
inline

Definition at line 55 of file XrdConfig.hh.

55{}

Member Function Documentation

◆ Configure()

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

Definition at line 318 of file XrdConfig.cc.

319{
320/*
321 Function: Establish configuration at start up time.
322
323 Input: None.
324
325 Output: 0 upon success or !0 otherwise.
326*/
327 const char *xrdInst="XRDINSTANCE=";
328
329 int retc, NoGo = 0, clPort = -1;
330 const char *temp;
331 char c, buff[512], *dfltProt, *libProt = 0;
332 uid_t myUid = 0;
333 gid_t myGid = 0;
334 extern char *optarg;
335 extern int optind, opterr;
336 struct XrdOucLogging::configLogInfo LogInfo;
337 int pipeFD[2] = {-1, -1};
338 const char *pidFN = 0;
339 static const int myMaxc = 80;
340 char **urArgv, *myArgv[myMaxc], argBuff[myMaxc*3+8];
341 char *argbP = argBuff, *argbE = argbP+sizeof(argBuff)-4;
342 char *ifList = 0;
343 int myArgc = 1, urArgc = argc, i;
344 bool noV6, ipV4 = false, ipV6 = false, rootChk = true, optbg = false;
345
346// Reconstruct the command line so we can put it in the log
347//
348 XrdOucString CmdLine(argv[0]);
349 for (int k = 1; k < argc; k++)
350 {CmdLine += ' '; CmdLine += argv[k];}
351
352// Obtain the program name we will be using
353//
354 retc = strlen(argv[0]);
355 while(retc--) if (argv[0][retc] == '/') break;
356 myProg = &argv[0][retc+1];
357
358// Setup the initial required protocol. The program name matches the protocol
359// name but may be arbitrarily suffixed. We need to ignore this suffix. So we
360// look for it here and it it exists we duplicate argv[0] (yes, loosing some
361// bytes - sorry valgrind) without the suffix.
362//
363 {char *p = dfltProt = strdup(myProg);
364 while(*p && (*p == '.' || *p == '-')) p++;
365 if (*p)
366 {char *dot = index(p, '.'), *dash = index(p, '-');
367 if (dot && (dot < dash || !dash)) p = dot;
368 else if (dash) p = dash;
369 else p = 0;
370 if (p) *p = '\0';
371 if (!strcmp("xrootd", dfltProt)) dfltProt[5] = 0;
372 else if (!strcmp("cmsd", dfltProt)) dfltProt[3] = 0;
373 }
374 }
375 myArgv[0] = argv[0];
376
377// Prescan the argument list to see if there is a passthrough option. In any
378// case, we will set the ephemeral argv/arg in the environment.
379//
380 i = 1;
381 while(i < argc)
382 {if (*(argv[i]) == '-' && *(argv[i]+1) == '+')
383 {int n = strlen(argv[i]+2), j = i+1, k = 1;
384 if (urArgc == argc) urArgc = i;
385 if (n) memcpy(buff, argv[i]+2, (n > 256 ? 256 : n));
386 strcpy(&(buff[n]), ".argv**");
387 while(j < argc && (*(argv[j]) != '-' || *(argv[j]+1) != '+')) j++;
388 urArgv = new char*[j-i+1];
389 urArgv[0] = argv[0];
390 i++;
391 while(i < j) urArgv[k++] = argv[i++];
392 urArgv[k] = 0;
393 theEnv.PutPtr(buff, urArgv);
394 strcpy(&(buff[n]), ".argc");
395 theEnv.PutInt(buff, static_cast<long>(k));
396 } else i++;
397 }
398 theEnv.PutPtr("argv[0]", argv[0]);
399
400// Process the options. Note that we cannot passthrough long options or
401// options that take arguments because getopt permutes the arguments.
402//
403 opterr = 0;
404 if (argc > 1 && '-' == *argv[1])
405 while ((c = getopt(urArgc,argv,":a:A:bc:dhHI:k:l:L:n:N:p:P:R:s:S:vw:W:z"))
406 && ((unsigned char)c != 0xff))
407 { switch(c)
408 {
409 case 'a': if (AdminPath) free(AdminPath);
410 AdminPath = strdup(optarg);
411 AdminMode = ProtInfo.AdmMode = S_IRWXU;
412 ProtInfo.xrdFlags |= XrdProtocol_Config::admPSet;
413 break;
414 case 'A': if (AdminPath) free(AdminPath);
415 AdminPath = strdup(optarg);
416 AdminMode = ProtInfo.AdmMode = S_IRWXU | S_IRWXG;
417 ProtInfo.xrdFlags |= XrdProtocol_Config::admPSet;
418 break;
419 case 'b': optbg = true;
420 break;
421 case 'c': if (ConfigFN) free(ConfigFN);
422 ConfigFN = strdup(optarg);
423 break;
424 case 'd': XrdTrace.What |= TRACE_ALL;
425 ProtInfo.DebugON = 1;
426 XrdOucEnv::Export("XRDDEBUG", "1");
427 break;
428 case 'h': Usage(0);
429 break;
430 case 'H': Usage(-1);
431 break;
432 case 'I': if (!strcmp("v4", optarg)) {ipV4 = true; ipV6 = false;}
433 else if (!strcmp("v6", optarg)) {ipV4 = false; ipV6 = true;}
434 else {Log.Emsg("Config", "Invalid -I argument -",optarg);
435 Usage(1);
436 }
437 break;
438 case 'k': if (!(LogInfo.keepV = Log.logger()->ParseKeep(optarg)))
439 {Log.Emsg("Config","Invalid -k argument -",optarg);
440 Usage(1);
441 }
442 break;
443 case 'l': LogInfo.logArg = optarg;
444 break;
445 case 'L': if (!*optarg)
446 {Log.Emsg("Config", "Protocol library path not specified.");
447 Usage(1);
448 }
449 if (libProt) free(libProt);
450 libProt = strdup(optarg);
451 break;
452 case 'n': myInsName = (!strcmp(optarg,"anon")||!strcmp(optarg,"default")
453 ? 0 : optarg);
454 break;
455 case 'N': XrdNetIdentity::SetFQN(optarg);
456 break;
457 case 'p': if ((clPort = XrdOuca2x::a2p(Log,"tcp",optarg)) < 0) Usage(1);
458 break;
459 case 'P': if (dfltProt) free(dfltProt);
460 dfltProt = strdup(optarg);
461 break;
462 case 'R': if (!(getUG(optarg, myUid, myGid))) Usage(1);
463 rootChk = false;
464 break;
465 case 's': pidFN = optarg;
466 break;
467 case 'S': mySitName = optarg;
468 break;
469 case ':': buff[0] = '-'; buff[1] = optopt; buff[2] = 0;
470 Log.Emsg("Config", buff, "parameter not specified.");
471 Usage(1);
472 break;
473 case 'v': std::cerr <<XrdVSTRING <<std::endl;
474 _exit(0);
475 break;
476 case 'w': if (HomePath) free(HomePath);
477 HomePath = strdup(optarg);
478 HomeMode = S_IRWXU;
479 Specs |= hpSpec;
480 break;
481 case 'W': if (HomePath) free(HomePath);
482 HomePath = strdup(optarg);
483 HomeMode = S_IRWXU | S_IRGRP | S_IXGRP;
484 Specs |= hpSpec;
485 break;
486 case 'z': LogInfo.hiRes = true;
487 break;
488
489 default: if (optopt == '-' && *(argv[optind]+1) == '-')
490 {Log.Emsg("Config", "Long options are not supported.");
491 Usage(1);
492 }
493 if (myArgc >= myMaxc || argbP >= argbE)
494 {Log.Emsg("Config", "Too many command line arguments.");
495 Usage(1);
496 }
497 myArgv[myArgc++] = argbP;
498 *argbP++ = '-'; *argbP++ = optopt; *argbP++ = 0;
499 break;
500 }
501 }
502
503// If an adminpath specified, make sure it's absolute
504//
505 if ((ProtInfo.xrdFlags & XrdProtocol_Config::admPSet) && *AdminPath != '/')
506 {Log.Emsg("Config", "Command line adminpath is not absolute.");
507 exit(17);
508 }
509
510// If an homepath specified, make sure it's absolute
511//
512 if (HomePath && *HomePath != '/')
513 {Log.Emsg("Config", "Command line home path is not absolute.");
514 exit(17);
515 }
516
517// If the configuration file is relative to where we are, get the absolute
518// path as we may be changing the home path. This also starts capturing.
519//
520 if (ConfigFN) setCFG(true);
521
522// The first thing we must do is to set the correct networking mode
523//
524 noV6 = XrdNetAddr::IPV4Set();
525 if (ipV4) XrdNetAddr::SetIPV4();
526 else if (ipV6){if (noV6) Log.Say("Config warning: ipV6 appears to be broken;"
527 " forced ipV6 mode not advised!");
529 }
530 else if (noV6) Log.Say("Config warning: ipV6 is misconfigured or "
531 "unavailable; reverting to ipV4.");
532
533// Set the site name if we have one
534//
535 if (mySitName) mySitName = XrdOucSiteName::Set(mySitName, 63);
536
537// Drop into non-privileged state if so requested
538//
539 if (myGid && setegid(myGid))
540 {Log.Emsg("Config", errno, "set effective gid"); exit(17);}
541 if (myUid && seteuid(myUid))
542 {Log.Emsg("Config", errno, "set effective uid"); exit(17);}
543
544// Prohibit this program from executing as superuser unless -R was specified.
545//
546 if (rootChk && geteuid() == 0)
547 {Log.Emsg("Config", "Security reasons prohibit running as "
548 "superuser; program is terminating.");
549 _exit(8);
550 }
551
552// Pass over any parameters
553//
554 if (urArgc-optind+2 >= myMaxc)
555 {Log.Emsg("Config", "Too many command line arguments.");
556 Usage(1);
557 }
558 for ( ; optind < urArgc; optind++) myArgv[myArgc++] = argv[optind];
559
560// Record the actual arguments that we will pass on
561//
562 myArgv[myArgc] = 0;
563 ProtInfo.argc = myArgc;
564 ProtInfo.argv = myArgv;
565
566// Resolve background/foreground issues
567//
568 if (optbg)
569 {
570#ifdef WIN32
571 XrdOucUtils::Undercover(&Log, !LogInfo.logArg);
572#else
573 if (pipe( pipeFD ) == -1)
574 {Log.Emsg("Config", errno, "create a pipe"); exit(17);}
575 XrdOucUtils::Undercover(Log, !LogInfo.logArg, pipeFD);
576#endif
577 }
578
579// Get the full host name. We must define myIPAddr here because we may need to
580// run in v4 mode and that doesn't get set until after the options are scanned.
581//
582 static XrdNetAddr *myIPAddr = new XrdNetAddr((int)0);
583 if (!(myName = myIPAddr->Name(0, &temp))) myName = "";
584
585// Get our IP address and FQN
586//
587 ProtInfo.myName = myName;
588 ProtInfo.myAddr = myIPAddr->SockAddr();
589 ProtInfo.myInst = XrdOucUtils::InstName(myInsName);
590 ProtInfo.myProg = myProg;
591
592// Set the Environmental variable to hold the instance name
593// XRDINSTANCE=<pgm> <instance name>@<host name>
594// XrdOucEnv::Export("XRDINSTANCE")
595//
596 sprintf(buff,"%s%s %s@%s", xrdInst, myProg, ProtInfo.myInst, myName);
597 myInstance = strdup(buff);
598 putenv(myInstance); // XrdOucEnv::Export("XRDINSTANCE",...)
599 myInstance += strlen(xrdInst);
600 XrdOucEnv::Export("XRDHOST", myName);
601 XrdOucEnv::Export("XRDNAME", ProtInfo.myInst);
602 XrdOucEnv::Export("XRDPROG", myProg);
603
604// Bind the log file if we have one
605//
606 if (LogInfo.logArg)
607 {LogInfo.xrdEnv = &theEnv;
608 LogInfo.iName = myInsName;
609 LogInfo.cfgFn = ConfigFN;
610 if (!XrdOucLogging::configLog(Log, LogInfo)) _exit(16);
611 Log.logger()->AddMsg(CmdLine.c_str());
613 }
614
615// We now test for host name. In theory, we should always get some kind of name.
616// We can't really continue without some kind of name at this point. Note that
617// vriable temp should still be valid from the previous NetAddr call.
618//
619 if (!(*myName))
620 {Log.Emsg("Config", "Unable to determine host name; ",
621 (temp ? temp : "reason unknown"),
622 "; execution terminated.");
623 _exit(16);
624 }
625
626// Tell NetIF what logger to use as it's been properly setup by now.
627//
629
630// Put out the herald
631//
632 strcpy(buff, "Starting on ");
633 retc = strlen(buff);
634 XrdSysUtils::FmtUname(buff+retc, sizeof(buff)-retc);
635 Log.Say(0, buff);
636 Log.Say(0, CmdLine.c_str());
638
639// Verify that we have a real name. We've had problems with people setting up
640// bad /etc/hosts files that can cause connection failures if "allow" is used.
641// Otherwise, determine our domain name.
642//
643 if (!myIPAddr->isRegistered())
644 {Log.Emsg("Config",myName,"does not appear to be registered in the DNS.");
645 Log.Emsg("Config","Verify that the '/etc/hosts' file is correct and "
646 "this machine is registered in DNS.");
647 Log.Emsg("Config", "Execution continues but connection failures may occur.");
648 myDomain = 0;
649 } else if (!(myDomain = index(myName, '.')))
650 Log.Say("Config warning: this hostname, ", myName,
651 ", is registered without a domain qualification.");
652
653// Setup the initial required protocol.
654//
655 Firstcp = Lastcp = new XrdConfigProt(strdup(dfltProt), libProt, 0);
656
657// Let start it up!
658//
659 Log.Say("++++++ ", myInstance, " initialization started.");
660
661// Allocate /dev/null as we need it and can't live without it
662//
663 devNull = XrdSysFD_Open("/dev/null", O_RDONLY);
664 if (devNull < 0)
665 {Log.Emsg("Config", errno, "open '/dev/null' which is required!");
666 NoGo = 1;
667 }
668
669// Process the configuration file, if one is present
670//
671 if (ConfigFN)
672 {Log.Say("Config using configuration file ", ConfigFN);
673 ProtInfo.ConfigFN = ConfigFN;
674 NoGo = ConfigProc();
675 }
676 if (clPort >= 0) PortTCP = clPort;
677 if (ProtInfo.DebugON)
680 }
681
682// Setup the admin path now
683//
684 NoGo |= SetupAPath();
685
686// If tls enabled, set it up. We skip this if we failed to avoid confusing msgs
687//
688 if (!NoGo)
689 {if (!tlsCert) ProtInfo.tlsCtx= 0;
690 else {Log.Say("++++++ ", myInstance, " TLS initialization started.");
691 if (SetupTLS())
692 {Log.Say("------ ",myInstance," TLS initialization ended.");
693 if ((ProtInfo.tlsCtx = XrdGlobal::tlsCtx))
694 theEnv.PutPtr("XrdTlsContext*", XrdGlobal::tlsCtx);
695 } else {
696 NoGo = 1;
697 Log.Say("------ ",myInstance," TLS initialization failed.");
698 }
699 }
700 }
701
702// If there is TLS port verify that it can be used. We ignore this if we
703// will fail anyway so as to not issue confusing messages.
704//
705 if (!NoGo)
706 {if (PortTLS > 0 && !XrdGlobal::tlsCtx)
707 {Log.Say("Config TLS port specification ignored; TLS not configured!");
708 PortTLS = -1;
709 } else {
710 ProtInfo.tlsCtx = XrdGlobal::tlsCtx;
711 ProtInfo.tlsPort = (PortTLS > 0 ? PortTLS : 0);
712 }
713 }
714
715// Put largest buffer size in the env
716//
717 theEnv.PutInt("MaxBuffSize", XrdGlobal::xlBuff.MaxSize());
718
719// Export the network interface list at this point
720//
721 if (ppNet && XrdNetIF::GetIF(ifList, 0, true))
722 XrdOucEnv::Export("XRDIFADDRS",ifList);
723
724// Configure network routing
725//
726 if (!XrdInet::netIF.SetIF(myIPAddr, ifList))
727 {Log.Emsg("Config", "Unable to determine interface addresses!");
728 NoGo = 1;
729 }
730
731// If we have an instance name change the working directory
732//
733 if ((myInsName || HomePath)
734 && !XrdOucUtils::makeHome(Log, myInsName, HomePath, HomeMode)) NoGo = 1;
735
736// Create the pid file
737//
738 if (!PidFile(pidFN, optbg)) NoGo = 1;
739
740// Establish a manifest file for auto-collection
741//
742 if (!NoGo) Manifest(pidFN);
743
744// Now initialize the protocols and other stuff
745//
746 if (!NoGo) NoGo = Setup(dfltProt, libProt);
747
748// End config capture
749//
750 setCFG(false);
751
752// If we have a tcpmon plug-in try loading it now. We won't do that unless
753// tcp monitoring was enabled by the monitoring framework.
754//
755 if (tmoInfo && !NoGo)
756 {void *theGS = theEnv.GetPtr("TcpMon.gStream*");
757 if (!theGS) Log.Say("Config warning: TCP monitoring not enabled; "
758 "tcpmonlib plugin not loaded!");
759 else {tmoInfo->theEnv.PutPtr("TcpMon.gStream*", theGS);
760 TcpMonPin = tmoInfo->KingPin.Load("TcpMonPin");
761 if (!TcpMonPin) NoGo = 1;
762 }
763 }
764
765 // if we call this it means that the daemon has forked and we are
766 // in the child process
767#ifndef WIN32
768 if (optbg)
769 {
770 int status = NoGo ? 1 : 0;
771 if(write( pipeFD[1], &status, sizeof( status ) )) {};
772 close( pipeFD[1]);
773 }
774#endif
775
776// All done, close the stream and return the return code.
777//
778 temp = (NoGo ? " initialization failed." : " initialization completed.");
779 sprintf(buff, "%s:%d", myInstance, PortTCP);
780 Log.Say("------ ", buff, temp);
781 if (LogInfo.logArg)
782 {strcat(buff, " running ");
783 retc = strlen(buff);
784 XrdSysUtils::FmtUname(buff+retc, sizeof(buff)-retc);
785 Log.logger()->AddMsg(buff);
786 }
787 return NoGo;
788}
void Usage(const char *msg)
#define XrdBANNER
Definition XrdInfo.hh:38
int optopt
int optind
#define close(a)
Definition XrdPosix.hh:43
#define write(a, b, c)
Definition XrdPosix.hh:110
#define TRACE_ALL
Definition XrdTrace.hh:35
static XrdNetIF netIF
Definition XrdInet.hh:68
const sockaddr * SockAddr()
const char * Name(const char *eName=0, const char **eText=0)
static void SetIPV4()
static void SetIPV6()
static bool IPV4Set()
Definition XrdNetAddr.hh:61
static int GetIF(XrdOucTList **ifList, const char **eText=0)
Definition XrdNetIF.cc:413
static void SetMsgs(XrdSysError *erp)
Definition XrdNetIF.cc:871
static void SetFQN(const char *fqn)
void PutInt(const char *varname, long value)
Definition XrdOucEnv.cc:250
static int Export(const char *Var, const char *Val)
Definition XrdOucEnv.cc:170
void * GetPtr(const char *varname)
Definition XrdOucEnv.cc:263
void PutPtr(const char *varname, void *value)
Definition XrdOucEnv.cc:298
static bool configLog(XrdSysError &eDest, configLogInfo &logInfo)
T * Load(const char *Symbol)
static const char * Set(const char *name, int maxlen=15)
static const char * InstName(int TranOpt=0)
static void makeHome(XrdSysError &eDest, const char *inst)
static void Undercover(XrdSysError &eDest, int noLog, int *pipeFD=0)
static int a2p(XrdSysError &, const char *ptype, const char *val, bool anyOK=true)
Definition XrdOuca2x.cc:140
static const int admPSet
int Emsg(const char *esfx, int ecode, const char *text1, const char *text2=0)
void Say(const char *text1, const char *text2=0, const char *txt3=0, const char *text4=0, const char *text5=0, const char *txt6=0)
XrdSysLogger * logger(XrdSysLogger *lp=0)
void AddMsg(const char *msg)
int ParseKeep(const char *arg)
static void setDebug(XrdSysError *erp)
static int FmtUname(char *buff, int blen)
XrdOucPinKing< XrdTcpMonPin > KingPin
Definition XrdConfig.cc:230
XrdOucEnv theEnv
Definition XrdConfig.cc:238
XrdTlsContext * tlsCtx
Definition XrdGlobals.cc:52
XrdTcpMonPin * TcpMonPin
Definition XrdLinkXeq.cc:80
XrdBuffXL xlBuff
Definition XrdBuffer.cc:68
XrdSysTrace XrdTrace
Definition XrdTrace.hh:56

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, XrdTcpMonInfo::KingPin, XrdOucPinKing< T >::Load(), XrdGlobal::Log, XrdOucLogging::configLogInfo::logArg, XrdSysError::logger(), XrdOucUtils::makeHome(), XrdNetAddrInfo::Name(), XrdInet::netIF, optind, optopt, XrdSysLogger::ParseKeep(), XrdOucEnv::PutInt(), XrdOucEnv::PutPtr(), XrdSysError::Say(), XrdOucSiteName::Set(), XrdSysThread::setDebug(), XrdNetIdentity::SetFQN(), XrdNetAddr::SetIPV4(), XrdNetAddr::SetIPV6(), XrdNetIF::SetMsgs(), XrdNetAddrInfo::SockAddr(), XrdGlobal::TcpMonPin, XrdTcpMonInfo::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 794 of file XrdConfig.cc.

795{
796 int dynamic;
797
798 // Determine whether is is dynamic or not
799 //
800 if (eDest) dynamic = 1;
801 else {dynamic = 0; eDest = &Log;}
802
803 // Process common items
804 //
805 TS_Xeq("buffers", xbuf);
806 TS_Xeq("network", xnet);
807 TS_Xeq("sched", xsched);
808 TS_Xeq("trace", xtrace);
809
810 // Process items that can only be processed once
811 //
812 if (!dynamic)
813 {
814 TS_Xeq("adminpath", xapath);
815 TS_Xeq("allow", xallow);
816 TS_Xeq("homepath", xhpath);
817 TS_Xeq("maxfd", xmaxfd);
818 TS_Xeq("pidpath", xpidf);
819 TS_Xeq("port", xport);
820 TS_Xeq("protocol", xprot);
821 TS_Xeq("report", xrep);
822 TS_Xeq("sitename", xsit);
823 TS_Xeq("tcpmonlib", xtcpmon);
824 TS_Xeq("timeout", xtmo);
825 TS_Xeq("tls", xtls);
826 TS_Xeq("tlsca", xtlsca);
827 TS_Xeq("tlsciphers", xtlsci);
828 }
829
830 // No match found, complain.
831 //
832 eDest->Say("Config warning: ignoring unknown xrd directive '",var,"'.");
833 Config.Echo();
834 return 0;
835}
#define TS_Xeq(x, m)
Definition XrdConfig.cc:156
static XrdSysError eDest(0,"crypto_")
XrdCmsConfig Config

References 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 58 of file XrdConfig.hh.

Referenced by XrdConfig(), and main().

◆ NetTCP

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

Definition at line 59 of file XrdConfig.hh.

Referenced by main().

◆ ProtInfo

XrdProtocol_Config XrdConfig::ProtInfo

Definition at line 57 of file XrdConfig.hh.

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


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