XrdSecProtocolztn.cc File Reference

#include <cctype>
#include <cerrno>
#include <fcntl.h>
#include <cinttypes>
#include <iostream>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <vector>
#include <alloca.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <strings.h>
#include <unistd.h>
#include "XrdVersion.hh"
#include "XrdNet/XrdNetAddrInfo.hh"
#include "XrdOuc/XrdOucEnv.hh"
#include "XrdOuc/XrdOucErrInfo.hh"
#include "XrdOuc/XrdOucPinLoader.hh"
#include "XrdOuc/XrdOucString.hh"
#include "XrdOuc/XrdOucTokenizer.hh"
#include "XrdSciTokens/XrdSciTokensHelper.hh"
#include "XrdSys/XrdSysE2T.hh"
#include "XrdSys/XrdSysHeaders.hh"
#include "XrdSec/XrdSecInterface.hh"

Include dependency graph for XrdSecProtocolztn.cc:

Go to the source code of this file.

Classes
class	XrdSecProtocolztn

Namespaces
namespace	XrdSecztn

Macros
#define	__STDC_FORMAT_MACROS   1
#define	EAUTH   EBADE

Functions
bool	XrdSecztn::isJWT (const char *)
char *	XrdSecProtocolztnInit (const char mode, const char *parms, XrdOucErrInfo *erp)
XrdSecProtocol *	XrdSecProtocolztnObject (const char mode, const char *hostname, XrdNetAddrInfo &endPoint, const char *parms, XrdOucErrInfo *erp)
	XrdVERSIONINFO (XrdSecProtocolztnObject, secztn)

Macro Definition Documentation

__STDC_FORMAT_MACROS

#define __STDC_FORMAT_MACROS   1

Definition at line 31 of file XrdSecProtocolztn.cc.

EAUTH

#define EAUTH   EBADE

Definition at line 70 of file XrdSecProtocolztn.cc.

Referenced by XrdSecProtocolztn::Authenticate().

Function Documentation

XrdSecProtocolztnInit()

char * XrdSecProtocolztnInit	(	const char	mode,
		const char *	parms,
		XrdOucErrInfo *	erp )

Definition at line 704 of file XrdSecProtocolztn.cc.

{
   static char nilstr = 0;
   XrdOucString accPlugin("libXrdAccSciTokens.so");
   uint64_t opts = XrdSecProtocolztn::ztnVersion;
 
// This only makes sense for server initialization
//
   if (mode == 'c') return &nilstr;
 
// If there are no parameters, return the defaults
//
   if (!parms || !(*parms))
      {char buff[256];
       if (!getLinkage(erp, accPlugin.c_str())) return 0;
       snprintf(buff, sizeof(buff), "TLS:%" PRIu64 ":%d:", opts, MaxTokSize);
       return strdup(buff);
      }
 
// Copy the parameters as we will need modify them
//
   std::vector<XrdOucString> useVec;
   XrdOucString    cfgParms(parms);
   XrdOucTokenizer cfg(const_cast<char *>(cfgParms.c_str()));
   char *endP, *val;
 
// Setup to parse parameters
//
   cfg.GetLine();
 
// Parse the parameters: -expiry {none|optional|required} -maxsz <num>
//                       -tokenlib <libpath>
//
   while((val = cfg.GetToken()))
        {     if (!strcmp(val, "-maxsz"))
                 {if (!(val = cfg.GetToken()))
                     {Fatal(erp, "-maxsz argument missing", EINVAL);
                      return 0;
                     }
                  MaxTokSize = strtol(val, &endP, 10);
                  if (*endP == 'k' || *endP == 'K')
                     {MaxTokSize *= 1024; endP++;}
                  if (MaxTokSize <= 0 || MaxTokSize > 524288 || *endP)
                     {Fatal(erp, "-maxsz argument is invalid", EINVAL);
                      return 0;
                     }
                 }
         else if (!strcmp(val, "-expiry"))
                 {if (!(val = cfg.GetToken()))
                     {Fatal(erp, "-expiry argument missing", EINVAL);
                      return 0;
                     }
                       if (strcmp(val, "ignore"))   expiry =  0;
                  else if (strcmp(val, "optional")) expiry = -1;
                  else if (strcmp(val, "required")) expiry =  1;
                  else {Fatal(erp, "-expiry argument invalid", EINVAL);
                        return 0;
                       }
                 }
 
         else if (!strcmp(val, "-tokenlib"))
                 {if (!(val = cfg.GetToken()))
                     {Fatal(erp, "-acclib plugin path missing", EINVAL);
                      return 0;
                     }
                  if (strcmp(val,"none"))
                     {accPlugin = val;
                     }
                     else
                     {tokenlib = false;
                     }
                 }
 
         else {XrdOucString eTxt("Invalid parameter - "); eTxt += val;
               Fatal(erp, eTxt.c_str(), EINVAL);
               return 0;
              }
        }
 
// We rely on the token authorization plugin to validate tokens unless
// it is disabled using '-tokenlib none'. If active load it to
// get the validation object pointer. This will be filled in later but we
// want to know that it's actually present.
//
   if (tokenlib && !getLinkage(erp, accPlugin.c_str())) return 0;
 
// Assemble the parameter line and return it
//
   char buff[256];
   snprintf(buff, sizeof(buff), "TLS:%" PRIu64 ":%d:", opts, MaxTokSize);
   return strdup(buff);
}

References XrdOucString::c_str(), Fatal(), XrdOucTokenizer::GetLine(), XrdOucTokenizer::GetToken(), opts, and XrdSecProtocolztn::ztnVersion.

Here is the call graph for this function:

XrdSecProtocolztnObject()

XrdSecProtocol * XrdSecProtocolztnObject	(	const char	mode,
		const char *	hostname,
		XrdNetAddrInfo &	endPoint,
		const char *	parms,
		XrdOucErrInfo *	erp )

Definition at line 806 of file XrdSecProtocolztn.cc.

{
   XrdSecProtocolztn *protP;
 
// Whether this is a client of server, the connection must be using TLS.
//
   if (!endPoint.isUsingTLS())
      {Fatal(erp,"security protocol 'ztn' disallowed for non-TLS connections.",
             ENOTSUP, false);
       return 0;
      }
 
// Get a protocol object appropriate for the mode
//
   if (mode == 'c')
      {bool aOK;
       protP = new XrdSecProtocolztn(parms, erp, aOK);
       if (aOK) return protP;
       delete protP;
       return 0;
      }
 
   XrdSciTokensHelper *sthP= nullptr;
   if (tokenlib)
      {
// In server mode we need to make sure the token plugin was actually
// loaded and initialized as we need a pointer to the helper.
//
       sthP= *sth_Linkage;
       if (!sthP)
          {char msg[1024];
           snprintf(msg,sizeof(msg),"ztn required plugin (%s) has not been loaded!",
                    sth_piName);
           Fatal(erp, msg, EIDRM,false);
           return 0;
          }
      }
 
// Get an authentication object and return it
//
   if (!(protP = new XrdSecProtocolztn(hostname, endPoint, sthP)))
      Fatal(erp, "insufficient memory for protocol.", ENOMEM, false);
 
// All done
//
   return protP;
}

References Fatal(), and XrdNetAddrInfo::isUsingTLS().

Referenced by XrdVERSIONINFO().

Here is the call graph for this function:

Here is the caller graph for this function:

XrdVERSIONINFO()

XrdVERSIONINFO	(	XrdSecProtocolztnObject	,
		secztn	)

References eMsg, and XrdSecProtocolztnObject().

Here is the call graph for this function: