XrdNetPMarkCfg Class Reference

#include <XrdNetPMarkCfg.hh>

Inheritance diagram for XrdNetPMarkCfg:

Collaboration diagram for XrdNetPMarkCfg:

Public Member Functions
	XrdNetPMarkCfg ()
XrdNetPMark::Handle *	Begin (XrdNetAddrInfo &addr, XrdNetPMark::Handle &handle, const char *tident) override
XrdNetPMark::Handle *	Begin (XrdSecEntity &Client, const char *path=0, const char *cgi=0, const char *app=0) override
Public Member Functions inherited from XrdNetPMark
	XrdNetPMark ()
virtual	~XrdNetPMark ()

Static Public Member Functions
static XrdNetPMark *	Config (XrdSysError *eLog, XrdScheduler *sched, XrdSysTrace *trc, bool &fatal)
static int	Parse (XrdSysError *eLog, XrdOucStream &Config)
Static Public Member Functions inherited from XrdNetPMark
static bool	getEA (const char *cgi, int &ecode, int &acode)

Additional Inherited Members
Static Public Attributes inherited from XrdNetPMark
static const int	maxTotID = 65535
static const int	minTotID = 65
Static Protected Attributes inherited from XrdNetPMark
static const int	btsActID = 6
static const int	maxActID = maxTotID & mskActID
static const int	maxExpID = maxTotID >> btsActID
static const int	minActID = minTotID & mskActID
static const int	minExpID = minTotID >> btsActID
static const int	mskActID = 63

Detailed Description

Definition at line 43 of file XrdNetPMarkCfg.hh.

Constructor & Destructor Documentation

XrdNetPMarkCfg()

XrdNetPMarkCfg::XrdNetPMarkCfg ( )

inline

Definition at line 61 of file XrdNetPMarkCfg.hh.

{}

Referenced by Config().

Here is the caller graph for this function:

Member Function Documentation

Begin() [1/2]

XrdNetPMark::Handle * XrdNetPMarkCfg::Begin ( XrdNetAddrInfo &  addr, XrdNetPMark::Handle &  handle, const char *  tident  )

overridevirtual

Implements XrdNetPMark.

Definition at line 235 of file XrdNetPMarkCfg.cc.

{
 
// If we are allowed to use the flow label set on the incoming connection
// then try to do so. This is only valid for IPv6 connections. Currently,
// this is not implemented.
//
// if (useFLbl && addrInfo.isIPType(XrdNetAddrInfo::IPv6)
// && !addrInfo.isMapped())
//    {
//    TODO???
//    }
 
// If we are allowed to use firefly, return a firefly handle
//
   if (handle.Valid() && useFFly)
      {XrdNetPMarkFF *pmFF = new XrdNetPMarkFF(handle, tident);
       if (pmFF->Start(addrInfo)) return pmFF;
       delete pmFF;
       eDest->Emsg("PMark_Begin", "Unable to start pmark for session",tident);
      } else {
       if (useFFly)
          eDest->Emsg("PMark_Begin", "Flow value is invalid; "
                                     "pmark disabled for session", tident);
      }
 
// All done, nothing will be pmarked
//
   return 0;
}

References eDest, XrdSysError::Emsg(), XrdNetPMarkFF::Start(), tident, XrdNetPMarkConfig::useFFly, and XrdNetPMark::Handle::Valid().

Here is the call graph for this function:

Begin() [2/2]

XrdNetPMark::Handle * XrdNetPMarkCfg::Begin ( XrdSecEntity &  Client, const char *  path = 0, const char *  cgi = 0, const char *  app = 0  )

overridevirtual

Implements XrdNetPMark.

Definition at line 175 of file XrdNetPMarkCfg.cc.

{
   EPName("PMBegin");
   XrdOucString altApp;
   int eCode, aCode;
 
// If we need to screen out domains, do that
//
   if (chkDom)
      {XrdNetAddrInfo &addrInfo = *client.addrInfo;
       char domType = (addrInfo.isPrivate() ? domLcl : domRmt);
       if (domType == domRmt && *myDomain)
          {const char *urName = addrInfo.Name();
           if (urName && XrdNetAddrInfo::isHostName(urName))
              {const char *dot = index(urName, '.');
               if (dot && !strcmp(dot+1, myDomain)) domType = domLcl;
              }
          }
       if (domType != chkDom)
          {DBGID(client.tident, "Skipping sending flow info; unwanted domain");
           return 0;
          }
      }
 
// Now get the experiment and activity code. If we can't get at least the
// experiment code, then proceed without marking the flow.
//
   if (!getCodes(client, path, cgi, eCode, aCode))
      {TRACE("Unable to determine experiment; flow not marked.");
       return 0;
      }
 
// Obtain the appname overridefrom the cgi
//
   if (cgi)                        // 01234567890123
      {const char *apP = strstr(cgi, "pmark.appname=");
       if (apP)
          {apP += 14;
           const char* aP = apP;
           while(*aP && *aP != '&') aP++;
           int apLen = aP - apP;
           if (apLen > 0)
              {altApp = "";
               altApp.insert(apP, 0, apLen);
               app = altApp.c_str();
              }
          }
      }
 
// Continue with successor function to complete the logic
//
   XrdNetPMark::Handle handle(app, eCode, aCode);
   return Begin(*client.addrInfo, handle, client.tident);
}

References XrdSecEntity::addrInfo, Begin(), XrdOucString::c_str(), XrdNetPMarkConfig::chkDom, DBGID, XrdNetPMarkConfig::domLcl, XrdNetPMarkConfig::domRmt, EPName, XrdOucString::insert(), XrdNetAddrInfo::isHostName(), XrdNetAddrInfo::isPrivate(), XrdNetPMarkConfig::myDomain, XrdNetAddrInfo::Name(), XrdSecEntity::tident, and TRACE.

Referenced by Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

Config()

XrdNetPMark * XrdNetPMarkCfg::Config ( XrdSysError *  eLog, XrdScheduler *  sched, XrdSysTrace *  trc, bool &  fatal  )

static

Definition at line 272 of file XrdNetPMarkCfg.cc.

{
   class DelCfgInfo
        {public: DelCfgInfo(CfgInfo *&cfg) : cfgInfo(cfg) {}
                ~DelCfgInfo() {if (cfgInfo) {delete cfgInfo; cfgInfo = 0;}}
         private:
         CfgInfo *&cfgInfo;
        } cleanup(Cfg);
 
// If we have not been configured then simply retrn nil
//
   if (!Cfg)
      {useFFly = false;
       return 0;
      }
 
// Save the message handler
//
   eDest = eLog;
   Sched = sched;
   Trace = trc;
   fatal = false;
 
// If firefly is enabled, make sure we have an ffdest
//
   if (useFFly < 0)
      {if (ffPortD || ffPortO)
          {useFFly = true;
           if (!ffPortO) ffPortO = ffPORT;
          } else {
           useFFly = false;
           eLog->Say("Config warning: firefly disabled; "
                     "configuration incomplete!");
           return 0;
          }
      } else if (useFFly && !ffPortO) ffPortO = ffPORT;
 
// Resolve trace and debug settings
//
   if (doDebug) doTrace = true;
 
// Check if we need a defsfile, if so, construct the map.
//
   if (Cfg->x2aSet.size() == 0 && Cfg->x2eSet.size() == 0)
      {if (Cfg->defsFile.length())
          eLog->Say("Config warning: ignoring defsfile; "
                                    "no mappings have been specified!");
       useDefs = false;
      } else {
       if (!Cfg->defsFile.length())
          {eLog->Say("Config invalid: pmark mappings cannot be resolved "
                     "without specifying defsfile!");
           fatal = true;
           return 0;
          }
       useDefs = true;
       if (!ConfigDefs())
          {if (useDefs)
              {fatal = true;
               return 0;
              }
           eLog->Say("Config warning: pmark ignoring defsfile; "
                     "unable to process and nofail is in effect!");
          }
      }
 
// At this point either we still enabled or not. We can be disabled for a
// number of reasons and appropriate messages will have been issued.
//
   if (!useFFly) return 0;
 
// Create a netmsg object for firefly reporting if a dest was specified
//
   bool aOK = false;
   if (ffDest)
      {XrdNetAddr spec;
       char buff[1024];
       const char *eTxt = spec.Set(ffDest, -ffPortD);
       if (eTxt)
          {snprintf(buff, sizeof(buff), "%s:%d; %s", ffDest, ffPortD, eTxt);
           eLog->Emsg("Config", "pmark unable to create UDP tunnel to", buff);
           useFFly = false;
           fatal   = true;
           return 0;
          }
       if (spec.Format(buff, sizeof(buff)))
          netMsg = new XrdNetMsg(eDest, buff, &aOK);
       if (!aOK)
          {eLog->Emsg("Config", "pmark unable to create UDP tunnel to", ffDest);
           fatal = true;
           delete netMsg;
           netMsg = 0;
           useFFly= false;
           return 0;
          }
       }
 
// Handle the firefly messages to origin
//
   if (ffPortO)
      {netOrg = new XrdNetMsg(eDest, 0, &aOK);
       if (!aOK)
          {eLog->Emsg("Config","pmark unable to create origin UDP tunnel");
           fatal = true;
           useFFly= false;
           return 0;
          }
      }
 
// Get our host name.
//
   myHostName = XrdNetUtils::MyHostName("-"); // Never deleted!
 
// Setup for domain checking
//
   if (chkDom)
      {const char *dot = index(myHostName, '.');
       if (dot) myDomain = dot+1;
          else eDest->Say("Config warning: Unable to determine local domain; "
                          " domain check restricted to IP address type!");
      }
 
// Finally, we are done. Return the packet markling stub.
//
   return new XrdNetPMarkCfg;
}

References XrdNetPMarkCfg(), XrdNetPMarkConfig::Cfg, XrdNetPMarkConfig::chkDom, XrdNetPMarkConfig::CfgInfo::defsFile, XrdNetPMarkConfig::doDebug, XrdNetPMarkConfig::doTrace, eDest, XrdSysError::Emsg(), XrdNetPMarkConfig::ffDest, XrdNetPMarkConfig::ffPORT, XrdNetPMarkConfig::ffPortD, XrdNetPMarkConfig::ffPortO, XrdNetAddrInfo::Format(), XrdOucString::length(), XrdNetPMarkConfig::myDomain, XrdNetPMarkConfig::myHostName, XrdNetUtils::MyHostName(), XrdNetPMarkConfig::netMsg, XrdNetPMarkConfig::netOrg, XrdSysError::Say(), XrdNetPMarkConfig::Sched, XrdNetAddr::Set(), XrdNetPMarkConfig::Trace, XrdNetPMarkConfig::useDefs, XrdNetPMarkConfig::useFFly, XrdNetPMarkConfig::CfgInfo::x2aSet, and XrdNetPMarkConfig::CfgInfo::x2eSet.

Referenced by XrdXrootdProtocol::Configure(), and Parse().

Here is the call graph for this function:

Here is the caller graph for this function:

Parse()

int XrdNetPMarkCfg::Parse ( XrdSysError *  eLog, XrdOucStream &  Config  )

static

Definition at line 972 of file XrdNetPMarkCfg.cc.

{
// Parse pmark directive parameters:
//
// [[no]debug] [defsfile [[no]fail] {<path> | {curl | wget} [tmo] <url>}]
// [domain {any | local | remote}] [[no]fail] [ffdest <udpdest>]
// [ffecho <intvl>]
// [map2act <ename> {default | {role | user} <name>} <aname>]
// [map2exp {default | {path <path> | vo <vo>} <ename>}] [[no]trace]
// [use {[no]flowlabel | flowlabel+ff | [no]firefly | [no]scitag}
//
// <udpdest>: {origin[:<port>] | <host>[:port]} [,<udpdest>]
//
   std::string name;
   char *val;
 
// If this is the first time here, allocate config info object
//
   if (!Cfg) Cfg = new CfgInfo;
 
// Make sure we have something to parse
//
   if (!(val = Config.GetWord()))
      {eLog->Say("Config invalid: pmark argument not specified"); return 1;}
 
// Parse the directive options
//
do{if (!strcmp("debug", val) || !strcmp("nodebug", val))
      {doDebug =  (*val != 'n');
       continue;
      }
 
   if (!strcmp("defsfile", val))
      {if (!(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark defsfile value not specified");
           return 1;
          }
 
       if (!strcmp("fail", val) || !strcmp("nofail", val))
          {noFail = (*val == 'n');
           if (!(val = Config.GetWord()))
              {eLog->Say("Config invalid: pmark defsfile location not specified");
               return 1;
              }
          }
 
       if (*val == '/')
          {Cfg->defsFile = val;
           continue;
          }
 
       if (strcmp("curl", val) && strcmp("wget", val))
          {eLog->Say("Config invalid: unknown defsfile transfer agent '",val,"'");
           return 1;
          }
       if (!XrdOucUtils::findPgm(val, Cfg->pgmPath))
          {eLog->Say("Config invalid: defsfile transfer agent '",val,"' not found.");
           return 1;
          }
 
       if (*val == 'c')
          {Cfg->pgmOpts[0]="-m"; Cfg->pgmOpts[2]="-s"; Cfg->pgmOpts[3]="-o";
          } else {
           Cfg->pgmOpts[0]="-T"; Cfg->pgmOpts[2]="-q"; Cfg->pgmOpts[3]="-O";
          }
 
       val = Config.GetWord();
       if (val && isdigit(*val))
          {if (XrdOuca2x::a2tm(*eLog,"defsfile timeout",val,&Cfg->defsTO,10))
              return 1;
           val = Config.GetWord();
          }
 
       if (!val) {eLog->Say("Config invalid: pmark defsfile url not specified");
                  return 1;
                 }
       Cfg->defsFile = val;
       continue;
      }
 
   if (!strcmp("domain", val))
      {if (!(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark domain value not specified");
           return 1;
          }
            if (!strcmp(val, "any"   )
            ||  !strcmp(val, "all"   )) chkDom = domAny;
       else if (!strcmp(val, "local" )) chkDom = domLcl;
       else if (!strcmp(val, "remote")) chkDom = domRmt;
       else {eLog->Say("Config invalid: pmark invalid domain determinant '",
                       val, "'");
             return 1;
            }
       continue;
      }
 
    if (!strcmp("fail", val) || !strcmp("nofail", val))
       {noFail = (*val == 'n');
        continue;
       }
 
   // We accept 'origin' as a dest for backward compatibility. That is the
   // enforced default should 'use firefly' be specified.
   //
   if (!strcmp("ffdest", val))
      {const char *addtxt = "";
       char *colon, *comma;
       int  xPort;
       val = Config.GetWord();
       do {if (!val || *val == 0 || *val == ',' || *val == ':')
              {eLog->Say("Config invalid: pmark ffdest value not specified",
                         addtxt); return 1;
              }
           if ((comma = index(val, ','))) *comma++ = 0;
           if ((colon = index(val, ':')))
              {*colon++ = 0;
               if ((xPort = XrdOuca2x::a2p(*eLog, "udp", colon, false)) <= 0)
                  return 1;
              } else xPort = ffPORT;
           if (!strcmp(val, "origin")) ffPortO = xPort;
              else {if (ffDest) free(ffDest);
                    ffDest  = strdup(val);
                    ffPortD = xPort;
                   }
           addtxt = " after comma";
          } while((val = comma));
       if (useFFly < 0) useFFly = 1;
       continue;
      }
 
   if (!strcmp("ffecho", val))
      {if (!(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark ffecho value not specified");
           return 1;
          }
       if (XrdOuca2x::a2tm(*eLog,"ffecho interval", val, &ffEcho, 0)) return 1;
       if (ffEcho < 30) ffEcho = 0;
       continue;
      }
 
   if (!strcmp("map2act", val))
      {if (!(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark activity experiment not specified");
           return 1;
          }
       name = val;
 
       if (!(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark activity determinant not specified");
           return 1;
          }
 
       const char *adet;
            if (!strcmp(val, "default")) adet = "dflt";
       else if (!strcmp(val, "role"))    adet = "role";
       else if (!strcmp(val, "user"))    adet = "user";
       else {eLog->Say("Config invalid: pmark invalid activity determinant '",
                       val, "'");
             return 1;
            }
       name += ' '; name += val;
 
       if (*adet != 'd' && !(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark activity", adet, "not specified");
           return 1;
          }
       name += ' '; name += val;
 
       if (!(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark", adet, "activity not specified");
           return 1;
          }
       name += ' '; name += val;
 
       Cfg->x2aSet.insert(name);
       continue;
      }
 
   if (!strcmp("map2exp", val))
      {if (!(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark map2exp type not specified");
           return 1;
          }
       if (strcmp("default", val) && strcmp("path", val)
       &&  strcmp("vo", val) && strcmp("vorg", val))
          {eLog->Say("Config invalid: invalid pmark map2exp type, '",val,"'.");
           return 1;
          }
       name = val;
 
       if (*val != 'd' && !(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark map2exp ", name.c_str(),
                     "not  specified");
           return 1;
          }
       name += ' '; name += val;
 
       if (!(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark map2exp expirement not specified");
           return 1;
          }
       name += ' '; name += val;
 
       Cfg->x2eSet.insert(name);
       continue;
      }
 
   if (!strcmp("trace", val) || !strcmp("notrace", val))
      {doTrace = (*val != 'n');
       continue;
      }
 
   if (!strcmp("use", val))
      {if (!(val = Config.GetWord()))
          {eLog->Say("Config invalid: pmark use argument not specified");
           return 1;
          }
       bool argOK = false;
       char *arg;
       do {bool theval = strncmp(val, "no", 2) != 0;
           arg = (!theval ? val += 2 : val);
                if (!strcmp("flowlabel",  arg))
                   {useFLbl = theval; addFLFF = false; argOK = true;}
           else if (!strcmp("flowlabel+ff",  arg))
                   {addFLFF = useFLbl = theval; argOK = true;}
           else if (!strcmp("firefly", arg))
                   {useFFly = (theval ? 1 : 0); argOK = true;}
           else if (!strcmp("scitag",  arg)) {useSTag = theval; argOK = true;}
           else if (argOK) {Config.RetToken(); break;}
           else {eLog->Say("Config invalid: 'use ",val,"' is invalid");
                 return 1;
                }
          } while((val = Config.GetWord()));
       if (!val) break;
       continue;
      }
 
   eLog->Say("Config warning: ignoring unknown pmark argument'",val,"'.");
 
  } while ((val = Config.GetWord()));
 
   return 0;
}

References XrdOuca2x::a2p(), XrdOuca2x::a2tm(), XrdNetPMarkConfig::addFLFF, XrdNetPMarkConfig::Cfg, XrdNetPMarkConfig::chkDom, Config(), XrdNetPMarkConfig::CfgInfo::defsFile, XrdNetPMarkConfig::CfgInfo::defsTO, XrdNetPMarkConfig::doDebug, XrdNetPMarkConfig::domAny, XrdNetPMarkConfig::domLcl, XrdNetPMarkConfig::domRmt, XrdNetPMarkConfig::doTrace, XrdNetPMarkConfig::ffDest, XrdNetPMarkConfig::ffEcho, XrdNetPMarkConfig::ffPORT, XrdNetPMarkConfig::ffPortD, XrdNetPMarkConfig::ffPortO, XrdOucUtils::findPgm(), XrdNetPMarkConfig::noFail, XrdNetPMarkConfig::CfgInfo::pgmOpts, XrdNetPMarkConfig::CfgInfo::pgmPath, XrdSysError::Say(), XrdNetPMarkConfig::useFFly, XrdNetPMarkConfig::useFLbl, XrdNetPMarkConfig::useSTag, XrdNetPMarkConfig::CfgInfo::x2aSet, and XrdNetPMarkConfig::CfgInfo::x2eSet.

Here is the call graph for this function:

---

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

• XrdNetPMarkCfg.hh
• XrdNetPMarkCfg.cc