Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbPud/pud_Config.cc

Go to the documentation of this file.

/******************************************************************************/
/*                                                                            */
/*                          p u d _ C o n f i g . C                           */
/*                                                                            */
/* (C) 2001 by the Board of Trustees of the Leland Stanford, Jr., University  */
/*                            All Rights Reserved                             */
/*   Produced by Andrew Hanushevsky for Stanford University under contract    */
/*               DE-AC03-76-SFO0515 with the Deprtment of Energy              */
/******************************************************************************/

#include <unistd.h>
#include <ctype.h>
#include <errno.h>
#include <iostream.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <time.h>
#include <sys/param.h>
#include <sys/time.h>
#include <sys/types.h>

#include "pud_Config.h"
#include "pud_Debug.h"
#include "pud_Emsg.h"
#include "pud_Network.h"

/******************************************************************************/
/*                               d e f i n e s                                */
/******************************************************************************/

#define Duplicate(x,y) if (y) free(y); y = strdup(x)

#define TS_Xeq(x,m)    if (!strcmp(x,var)) return m(Config);

#define TS_String(x,m) if (!strcmp(x,var)) {free(m); m = strdup(val); return 0;}

#define TS_List(x,m,v) if (!strcmp(x,var)) \
                          {m.Insert(new oouc_PList(val, v); return 0;}

#define TS_Char(x,m)   if (!strcmp(x,var)) {m = val[0]; return 0;}

#define TS_Add(x,m,v)  if (!strcmp(x,var)) {m |= v; return 0;}

#define TS_Set(x,m,v)  if (!strcmp(x,var)) {m = v; return 0;}

#define max(a,b)       (a < b ? b : a)

#define CVT pud_Config

/******************************************************************************/
/*                        G l o b a l   O b j e c t s                         */
/******************************************************************************/

       pud_Debug   pud_Debug;

extern pud_Network pud_Net;

/******************************************************************************/
/*                      C o p y   C o n s t r u c t o r                       */
/******************************************************************************/

pud_Config::pud_Config(pud_Config &rv)
{
   int i, j;
   pud_Host *php=0, *chp;

// Copy all constants
//
   CT_num   = rv.CT_num;
   CT_minw  = rv.CT_minw;
   CT_maxw  = rv.CT_maxw;
   CT_randw = rv.CT_randw;
   XT_num   = rv.XT_num;
   XT_minw  = rv.XT_minw;
   XT_maxw  = rv.XT_maxw;
   XT_randw = rv.XT_randw;
   HostVnum = rv.HostVnum;
   Sport    = rv.Sport;
   if (rv.ServName) ServName = strdup(rv.ServName);
   if (rv.AutheTyp) AutheTyp = strdup(rv.AutheTyp);
   if (rv.AutheCmd) AutheCmd = strdup(rv.AutheCmd);

// Now copy the host list
//
   for (i = 0; i < HostVnum; i++)
       {chp = rv.HostVec[i];
        while(chp)
             { php = new pud_Host(php);
              *php = *chp;
               chp = chp->next;
             }
        HostVec[i] = php;
       }
}

/******************************************************************************/
/*                                  a 2 x x                                   */
/******************************************************************************/

int pud_Config::a2sz(const char *etxt, char *item, long &result,
                      long minv, long maxv)
{   int i = strlen(item)-1; char cmult = item[i];
    long val, qmult = 1;
         if (cmult == 'k' || cmult == 'K') qmult = 1024;
    else if (cmult == 'm' || cmult == 'M') qmult = 1024*1024;
    else if (cmult == 'g' || cmult == 'G') qmult = 1024*1024*1024;
    if (qmult > 1) item[i] = '\0';
    errno = 0;
    val  = strtol(item, (char **)NULL, 10) * qmult;
    if (qmult > 1) item[i] = cmult;
    if (errno || (maxv != -1 && (val > maxv || val < 1)) || val < minv)
       return pud_Fmsg("Config", "Invalid", (char *)etxt, (char *)" - ",item);
    result = val;
    return 0;
}

int pud_Config::a2l(const char *etxt, char *item, long &result,
                     long minv, long maxv)
{   long val;
    errno = 0;
    val  = strtol(item, (char **)NULL, 10);
    if (errno || (maxv != -1 && val > maxv) || val  < minv)
       return pud_Fmsg("Config", "Invalid", (char *)etxt, (char *)" - ", item);
    result = val;
    return 0;
}

int pud_Config::a2i(const char *etxt, char *item, int &result,
                     int minv, int maxv)
{   int val;
    errno = 0;
    val  = (int)strtol(item, (char **)NULL, 10);
    if (errno || (maxv != -1 && val > maxv) || val  < minv)
       return pud_Fmsg("Config", "Invalid", (char *)etxt, (char *)" - ", item);
    result = val;
    return 0;
}

int pud_Config::a2o(const char *etxt, char *item, long &result, 
                     long minv, long maxv)
{   long val;
    errno = 0;
    val  = strtol(item, (char **)NULL, 8);
    if (errno || (maxv != -1 && val > maxv) || val < minv)
       return pud_Fmsg("Config", "Invalid", (char *)etxt, (char *)" - ", item);
    result = val;
    return 0;
}

/******************************************************************************/
/*                                   n 2 a                                    */
/******************************************************************************/

char *pud_Config::n2a(int  val, char *buff, const char *fmt)
      {return buff + sprintf(buff, fmt, val);}

char *pud_Config::n2a(long val, char *buff, const char *fmt)
      {return buff + sprintf(buff, fmt, val);}

/******************************************************************************/
/*                          H o s t A n d   P o r t                           */
/******************************************************************************/
  
int pud_Config::HostAndPort(const char *what, char *path, char *buff, int bsz)
{   int hlen, pnum = 0;
    char *hn = path;

 // Extract the host name from the path
 //
    while (*hn && *hn != ':') hn++;
    if (!(hlen = hn - path))
       {pud_Fmsg("Config", what, (char *)"host not specified in", path); 
        return -1;
       }
    if (hlen >= bsz)
       {pud_Fmsg("Config", what, (char *)"hostname too long in", path);
        return -1;
       }
    if (path != buff) strncpy(buff, path, hlen);

 // Extract the port number from the path
 //
    if (*hn == ':' && hn++ && *hn)
       {errno = 0;
        pnum = strtol((const char *)hn, (char **)NULL, 10);
        if ((!pnum && errno || pnum > 65535)
        && ((pnum = pud_Net.findPort(hn)) <= 0))
           {pud_Fmsg("Config",what,(char *)"port invalid -", hn); return -1;}
       }

// All done.
//
    buff[hlen] = '\0';
    return pnum;
}

/******************************************************************************/
/*                             C o n f i g X e q                              */
/******************************************************************************/

int pud_Config::ConfigXeq(char *var, pud_Stream *Config)
{
    char  buff[2048], *bp, *val;
    int vlen, blen;

   TS_Xeq("authe",         xauthe);
   TS_Xeq("ctries",        xctries);
   TS_Xeq("eom",           xeom);
   TS_Xeq("port",          xport);
   TS_Xeq("shost",         xshost);
   TS_Xeq("xtries",        xxtries);

   // At this point, make sure we have a value
   //
   if (!(val = Config->GetWord()))
      {pud_Fmsg("config", "no value for", var); return 1;}

   // Now assign the appropriate global variable
   //
   TS_String("sname",      ServName);

   // No match found, simply ignore it
   //
   return 0;
}
  
/******************************************************************************/
/*                           s e t D e f a u l t s                            */
/******************************************************************************/

void pud_Config::setDefaults()
{
   if (InitDone) Reset();

   AutheTyp = 0;
   AutheCmd = 0;

   memset((void *)HostVec, 0, sizeof(HostVec));
   HostVnum = 0;
   Sport    = 0;

   CT_num   = pud_CT_NUM;
   CT_minw  = pud_CT_MINW;
   CT_maxw  = pud_CT_MAXW;
   CT_randw = pud_CT_RANDW;

   Resp_eom = pud_EOM;

   ServName = strdup(pud_SERVNAME);

   XT_num   = pud_XT_NUM;
   XT_minw  = pud_XT_MINW;
   XT_maxw  = pud_XT_MAXW;
   XT_randw = pud_XT_RANDW;
}

/******************************************************************************/
/*                       P r i v a t e   M e t h o d s                        */
/******************************************************************************/
/******************************************************************************/
/*                                x a u t h e                                 */
/******************************************************************************/

/* Function: xauthe

   Purpose:  To parse the directive:  authe type cmd [ parms ]

             The authe directive specifies how authentication infor-
             mation is to be encoded. The receiver must have a
             matching authd directive to be able to successfully
             decode the authentication information.  If you use the
             sample authentication method (i.e., Kerberos version 4)
             then you would use the katix command to encode the
             credentials. Parameters are:

             type   - the type of authentication that cmd provides.
                      Examples are K4, K5, PGP, etc. In fact, type
                      can be aything as long as it matches an authd
                      type in the server's configuration file.
             cmd    - is the command to invoke to encode the authen-
                      tication informtion to be sent to the server.
                      The information returned must be a hexa-
                      decimal ASCII string and must be returned via
                      standard out.
*/
int pud_Config::xauthe(pud_Stream *Config)
{
    char *atype, *val, buff[2048], *bp = buff;
    int blen = sizeof(buff);

    if (!(atype = Config->GetWord()))
       {pud_Fmsg("config", "authe type not specified"); return 1;}
    if (strlen(atype) > 4)
       {pud_Fmsg("config", "authe type too long -", atype); return 1;}

    *buff = '\0';

    while((blen > 0) && (val = Config->GetWord()))
         {if (bp != buff) {*bp = ' '; bp++; blen--;}
          do {*bp = *val; bp++; val++; blen--;} while(*val && blen > 0);
         }

    if (!*buff)
       {pud_Fmsg("config", "authe command not specified"); return 1;}
    if (blen <= 0)
       {pud_Fmsg("config", "authe command too long"); return 1;}

    if (AutheTyp) free(AutheTyp);
    AutheTyp = strdup(atype);
    if (AutheCmd) free(AutheCmd);
    AutheCmd = strdup(buff);

    return 0;
}
  
/******************************************************************************/
/*                               x c t r i e s                                */
/******************************************************************************/

/* Function: xctries

   Purpose:  To parse the directive: ctries num minw maxw randw

             num   is the maximum number of times to try a connec-
                   tion. The # actual number is num times the number
                   of shosts since pudc tries to connect to each
                   possible host before failing.  The default is
                   nine (9).
             minw  is the minimum number of seconds to wait between
                   connection failures. The wait is imposed after
                   all possible hosts are tried.  The default is 60.
             maxw  the maximum number of seconds to wait between
                   connection failures. The default is 180.
             randw is the number of seconds to stretch the maximum
                   wait time on each successive failure. After each
                   failure, pudc waits
                         rand(maxw-minw+randw*(try-1))+minw seconds.
                   This allows multiple clients to retry at dif-
                   ferent times.  The default is 30.

   Output: 0 upon success or !0 upon failure.
*/

int pud_Config::xctries(pud_Stream *Config)
{
    char *val;
    int num, minw, maxw, randw;

    if (!(val = Config->GetWord()))
       {pud_Fmsg("config", "ctries num not specified"); return 1;}
    if (a2i("invalid ctries num", val, num, 1)) return 1;

    if (!(val = Config->GetWord()))
       {pud_Fmsg("config", "ctries minw not specified"); return 1;}
    if (a2i("invalid ctries minw", val, minw, 1)) return 1;

    if (!(val = Config->GetWord()))
       {pud_Fmsg("config", "ctries maxw not specified"); return 1;}
    if (a2i("invalid ctries maxw", val, maxw, minw)) return 1;

    if (!(val = Config->GetWord()))
       {pud_Fmsg("config", "ctries randw not specified"); return 1;}
    if (a2i("invalid ctries randw", val, randw, 1)) return 1;

    CT_num   = num;
    CT_minw  = minw;
    CT_maxw  = maxw;
    CT_randw = randw;
    return 0;
}

/******************************************************************************/
/*                                  x e o m                                   */
/******************************************************************************/

/* Function: xeom

   Purpose:  To parse the directive: eom <char>

             <char>   the character the indicates end of line.

   Output: 0 upon success or !0 upon failure.
*/

int pud_Config::xeom(pud_Stream *Config)
{
    char *val;

    if (!(val = Config->GetWord()))
       {pud_Fmsg("config", "eom character not specified"); return 1;}

    if (strlen(val) == 1) {Resp_eom = *val; return 0;}

    if (*val == '\\')
       switch(val[1])
             {case '0': Resp_eom = '\0'; return 0;
              case 'b': Resp_eom = '\b'; return 0;
              case 'f': Resp_eom = '\f'; return 0;
              case 'n': Resp_eom = '\n'; return 0;
              case 'r': Resp_eom = '\r'; return 0;
              case 's': Resp_eom = ' ' ; return 0;
              case 't': Resp_eom = '\t'; return 0;
              default:  break;
             }

     pud_Fmsg("config", "invalid eom character - ", val);
     return 1;
}

/******************************************************************************/
/*                                x p o r t                                   */
/******************************************************************************/

/* Function: xport

   Purpose:  To parse the directive: port <num>

             <num>     the port number to connect to.

   Output: 0 upon success or !0 upon failure.
*/
int pud_Config::xport(pud_Stream *Config)
{   int pnum;
    char *val;

    if (!(val = Config->GetWord()))
       {pud_Fmsg("config", "port not specified"); return 1;}
    if (a2i("invalid port", val, pnum, 0)) return 1;
    Sport = pnum;
    return 0;
}

/******************************************************************************/
/*                               x s h o s t                                  */
/******************************************************************************/

/* Function: xshost

   Purpose:  To parse the directive: shost hostlist [ | hostlist [...]]
             is the list one one or more blank-separated hosts
             that provide the pud service. It is assumed that
             each host provides exactly the same service and
             that any of them can be used interchangeably.  In
             fact, pudc attempts connections to a random ord-
             You can prioritize host selection by partitioning
             the host list using an "or" (|). In a partitioned
             list, only after all hosts are randomly tried in
             the first partition does random selection proceed
             to the next partition.  A strict ordering is
             imposed if each sublist has only one member.  For
             example, while
                    shost host1 host2 | host3 host4
             would try host1 and host2, in some order, fol-
             lowed by host3 and host4, in some order;
                    shost host1 | host2 | host3 | host4
             would try the hosts in the exact order that they
             were specified.

   Output: 0 upon success or !0 upon failure.
*/

int pud_Config::xshost(pud_Stream *Config)
{
    char *val, *vp, vx;
    char *shlist[pud_MAXSHOST];
    int   svnow = 0;

// Start parsing the shost parameters
//
   while (val = Config->GetWord())
         {if (*val == '|' && !svnow)
             {pud_Fmsg("config", "Invalid shost -", val); return 1;}

          do {vp = val;
              while(*vp && *vp != '|') vp++;
              vx = *vp; *vp = '\0';
              if (svnow == pud_MAXSHOST)
                {pud_Fmsg("config", "maximum shost limit exceeded."); return 1;}
              shlist[svnow++] = strdup(val);
              if (vx)
                 {while(*val) {*val = ' '; val++;}
                  *val = ' ';
                  Config->RetToken();
                 }
                 else break;
              } while(val && !vx);
          if (Order(shlist, svnow)) return 1;
          svnow = 0;
         }

// Check if we really have any hosts
//
   if (!HostVec[0])
      {pud_Fmsg("config", "No shosts specified."); return 1;}
   return 0;
}


/******************************************************************************/
/*                               x x t r i e s                                */
/******************************************************************************/

/* Function: xctries

   Purpose:  To parse the directive: xtries num minw maxw randw

             num   is the maximum number of times to retry a
                   request. The # actual number is num times
                   the number of shosts since pudc tries to
                   send the failing request to each possible
                   host before failing itself.  The default is
                   nine (2).
             minw  is the minimum number of seconds to wait
                   between request failures. The wait is
                   imposed after all possible hosts are tried.
                   The default is 30.
             maxw  the maximum number of seconds to wait
                   between request failures. The default is 90.
             randw is the number of seconds to stretch the max-
                   imum wait time on each successive failure.
                   After each failure, pudc waits
                         rand(maxw-minw+randw*(try-1))+minw
                   seconds. This allows multiple clients to
                   retry at different times.  The default is
                   15.

   Output: 0 upon success or !0 upon failure.
*/

int pud_Config::xxtries(pud_Stream *Config)
{
    char *val;
    int num, minw, maxw, randw;

    if (!(val = Config->GetWord()))
       {pud_Fmsg("config", "xtries num not specified"); return 1;}
    if (a2i("invalid xtries num", val, num, 1)) return 1;

    if (!(val = Config->GetWord()))
       {pud_Fmsg("config", "xtries minw not specified"); return 1;}
    if (a2i("invalid xtries minw", val, minw, 1)) return 1;

    if (!(val = Config->GetWord()))
       {pud_Fmsg("config", "xtries maxw not specified"); return 1;}
    if (a2i("invalid xtries maxw", val, maxw, minw)) return 1;

    if (!(val = Config->GetWord()))
       {pud_Fmsg("config", "xtries randw not specified"); return 1;}
    if (a2i("invalid xtries randw", val, randw, 1)) return 1;

    XT_num   = num;
    XT_minw  = minw;
    XT_maxw  = maxw;
    XT_randw = randw;
    return 0;
}

/******************************************************************************/
/*                             U t i l i t i e s                              */
/******************************************************************************/
/******************************************************************************/
/*                                 O r d e r                                  */
/******************************************************************************/

int pud_Config::Order(char **shlist, int shend)
{
   int i, shnow, shcnt = shend;
   pud_Host *php;

// Make sure shost level wasn't exceeded
//
   if (HostVnum >= pud_MAXSHOST)
      {pud_Fmsg("config", "maximum shost level limit exceeded."); return 1;}

// Get the random starting point
//
   if (shend == 1) shnow = 0;
      {srand((unsigned int)time(0));
       shnow = random();
      }

// Resolve each host in the vector
//
   while (shcnt--)
         {i = shnow++ % shend;
          if (shlist[i])
             {php = new pud_Host(HostVec[HostVnum], shlist[i]);
              HostVec[HostVnum] = php;
             }
         }

// All done;
//
   HostVnum++;
   return 0;
}

/******************************************************************************/
/*                                 R e s e t                                  */
/******************************************************************************/

void pud_Config::Reset()
{
   int i = 0;
   pud_Host *php, *nhp;

   while ((i < HostVnum) && (nhp = HostVec[i++]))
         while (php=nhp) {nhp = php->next; delete php;}

   if (ServName) free(ServName);
   if (AutheTyp) free(AutheTyp);
   if (AutheCmd) free(AutheCmd);
}

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002