// @(#)root/auth:$Id: f2cfa663e232707e1201467b5805ff1d13575326 $
// Author: Fons Rademakers   26/11/2000

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TAuthenticate                                                        //
//                                                                      //
// An authentication module for ROOT based network services, like rootd //
// and proofd.                                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "RConfigure.h"

#include "TAuthenticate.h"
#include "TApplication.h"
#include "THostAuth.h"
#include "TRootSecContext.h"
#include "TPluginManager.h"
#include "TNetFile.h"
#include "TPSocket.h"
#include "TMessage.h"
#include "TSystem.h"
#include "TError.h"
#include "Getline.h"
#include "TROOT.h"
#include "TEnv.h"
#include "TList.h"
#include "NetErrors.h"
#include "TRegexp.h"
#include "TVirtualMutex.h"
#include "TTimer.h"
#include "TBase64.h"

#ifndef R__LYNXOS
#include <sys/stat.h>
#endif
#include <errno.h>
#include <sys/types.h>
#include <time.h>
#if !defined(R__WIN32) && !defined(R__MACOSX) && !defined(R__FBSD) && \
    !defined(R__OBSD)
#include <crypt.h>
#endif
#ifdef WIN32
#  include <io.h>
#endif /* WIN32 */
#if defined(R__LINUX) || defined(R__FBSD) || defined(R__OBSD)
#  include <unistd.h>
#endif
#include <stdlib.h>
#ifndef WIN32
#  include <sys/time.h>
#endif /* WIN32 */

#if defined(R__MACOSX)
extern "C" char *crypt(const char *, const char *);
#endif

#ifdef R__GLBS
#   include <sys/ipc.h>
#   include <sys/shm.h>
#endif

#ifdef R__SSL
// SSL specific headers
#   include <openssl/bio.h>
#   include <openssl/err.h>
#   include <openssl/pem.h>
#   include <openssl/rand.h>
#   include <openssl/rsa.h>
#   include <openssl/ssl.h>
#endif

// Statics initialization
TList          *TAuthenticate::fgAuthInfo = 0;
TString         TAuthenticate::fgAuthMeth[] = { "UsrPwd", "SRP", "Krb5",
                                                "Globus", "SSH", "UidGid" };
Bool_t          TAuthenticate::fgAuthReUse;
TString         TAuthenticate::fgDefaultUser;
TDatime         TAuthenticate::fgExpDate;
GlobusAuth_t    TAuthenticate::fgGlobusAuthHook;
Krb5Auth_t      TAuthenticate::fgKrb5AuthHook;
TString         TAuthenticate::fgKrb5Principal;
TDatime         TAuthenticate::fgLastAuthrc;    // Time of last reading of fgRootAuthrc
TString         TAuthenticate::fgPasswd;
TPluginHandler *TAuthenticate::fgPasswdDialog = (TPluginHandler *)(-1);
Bool_t          TAuthenticate::fgPromptUser;
TList          *TAuthenticate::fgProofAuthInfo = 0;
Bool_t          TAuthenticate::fgPwHash;
Bool_t          TAuthenticate::fgReadHomeAuthrc = kTRUE; // on/off search for $HOME/.rootauthrc
TString         TAuthenticate::fgRootAuthrc;    // Path to last rootauthrc-like file read
Int_t           TAuthenticate::fgRSAKey  = -1;  // Default RSA key type to be used
Int_t           TAuthenticate::fgRSAInit = 0;
rsa_KEY         TAuthenticate::fgRSAPriKey;
rsa_KEY_export  TAuthenticate::fgRSAPubExport[2] = {{0,0},{0,0}};
rsa_KEY         TAuthenticate::fgRSAPubKey;
#ifdef R__SSL
BF_KEY          TAuthenticate::fgBFKey;
#endif
SecureAuth_t    TAuthenticate::fgSecAuthHook;
Bool_t          TAuthenticate::fgSRPPwd;
TString         TAuthenticate::fgUser;
Bool_t          TAuthenticate::fgUsrPwdCrypt;
Int_t           TAuthenticate::fgLastError = -1;
Int_t           TAuthenticate::fgAuthTO = -2;       // Timeout value

// ID of the main thread as unique identifier
Int_t           TAuthenticate::fgProcessID = -1;

TVirtualMutex *gAuthenticateMutex = 0;

// Standard version of Sec Context match checking
Int_t StdCheckSecCtx(const char *, TRootSecContext *);


ClassImp(TAuthenticate)

//______________________________________________________________________________
static int auth_rand()
{
   // rand() implementation using /udev/random or /dev/random, if available

#ifndef WIN32
   int frnd = open("/dev/urandom", O_RDONLY);
   if (frnd < 0) frnd = open("/dev/random", O_RDONLY);
   int r;
   if (frnd >= 0) {
      ssize_t rs = read(frnd, (void *) &r, sizeof(int));
      close(frnd);
      if (r < 0) r = -r;
      if (rs == sizeof(int)) return r;
   }
   Printf("+++ERROR+++ : auth_rand: neither /dev/urandom nor /dev/random are available or readable!");
   struct timeval tv;
   if (gettimeofday(&tv,0) == 0) {
      int t1, t2;
      memcpy((void *)&t1, (void *)&tv.tv_sec, sizeof(int));
      memcpy((void *)&t2, (void *)&tv.tv_usec, sizeof(int));
      r = t1 + t2;
      if (r < 0) r = -r;
      return r;
   }
   return -1;
#else
   // No special random device available: use rand()
   return rand();
#endif
}

//______________________________________________________________________________
TAuthenticate::TAuthenticate(TSocket *sock, const char *remote,
                             const char *proto, const char *user)
{
   // Create authentication object.

   if (gDebug > 2 && gAuthenticateMutex)
      Info("Authenticate", "locking mutex (pid:  %d)",gSystem->GetPid());
   R__LOCKGUARD2(gAuthenticateMutex);

   // In PROOF decode the buffer sent by the client, if any
   if (gROOT->IsProofServ())
      ProofAuthSetup();

   // Use the ID of the starting thread as unique identifier
   if (fgProcessID < 0)
      fgProcessID = gSystem->GetPid();

   if (fgAuthTO == -2)
      fgAuthTO = gEnv->GetValue("Auth.Timeout",-1);

   fSocket   = sock;
   fRemote   = remote;
   fHostAuth = 0;
   fVersion  = 5;                // The latest, by default
   fSecContext = 0;

   if (gDebug > 2)
      Info("TAuthenticate", "Enter: local host: %s, user is: %s (proto: %s)",
           gSystem->HostName(), user, proto);

   // Set protocol string.
   // Check if version should be different ...
   char *pdd;
   Int_t servtype = TSocket::kSOCKD;
   if (proto && strlen(proto) > 0) {
      char *sproto = StrDup(proto);
      if ((pdd = strstr(sproto, ":")) != 0) {
         int rproto = atoi(pdd + 1);
         *pdd = '\0';
         if (strstr(sproto, "root") != 0) {
            if (rproto < 12 ) {
               fVersion = 4;
               if (rproto < 11 ) {
                  fVersion = 3;
                  if (rproto < 9 ) {
                     fVersion = 2;
                     if (rproto < 8) {
                        fVersion = 1;
                        if (rproto < 6)
                           fVersion = 0;
                     }
                  }
               }
            }
            servtype = TSocket::kROOTD;
         }
         if (strstr(sproto, "proof") != 0) {
            if (rproto < 11) {
               fVersion = 4;
               if (rproto < 10) {
                  fVersion = 3;
                  if (rproto < 8) {
                     fVersion = 2;
                     if (rproto < 7)
                        fVersion = 1;
                  }
               }
            }
            servtype = TSocket::kPROOFD;
         }
         if (gDebug > 3)
            Info("TAuthenticate",
                 "service: %s (remote protocol: %d): fVersion: %d", sproto,
                 rproto, fVersion);
      }
      fProtocol = sproto;
      delete [] sproto;
   }

   // Check or get user name
   fUser = "";
   TString checkUser;
   if (user && strlen(user) > 0) {
      fUser = user;
      checkUser = user;
   } else {
      UserGroup_t *u = gSystem->GetUserInfo();
      if (u)
         checkUser = u->fUser;
      delete u;
   }
   fPasswd = "";
   fPwHash = kFALSE;
   fSRPPwd = kFALSE;

   // Type of RSA key
   if (fgRSAKey < 0) {
      fgRSAKey  = 0;                // Default key
#ifdef R__SSL
      // Another choice possible: check user preferences
      if (gEnv->GetValue("RSA.KeyType",0) == 1)
         fgRSAKey = 1;
#endif
   }
   // This is the key actually used: we propose the default
   // to the server, and behave according to its reply
   fRSAKey = fgRSAKey;
   if (gDebug > 3)
      Info("TAuthenticate","RSA key: default type %d", fgRSAKey);

   // RSA key generation (one per session)
   if (!fgRSAInit) {
      GenRSAKeys();
      fgRSAInit = 1;
   }

   // Check and save the host FQDN ...
   TString fqdn;
   TInetAddress addr = gSystem->GetHostByName(fRemote);
   if (addr.IsValid())
      fqdn = addr.GetHostName();
   TString fqdnsrv;
   fqdnsrv.Form("%s:%d",fqdn.Data(),servtype);

   // Read directives from files; re-read if files have changed
   TAuthenticate::ReadRootAuthrc();

   if (gDebug > 3) {
      Info("TAuthenticate",
           "number of HostAuth Instantiations in memory: %d",
           GetAuthInfo()->GetSize());
      TAuthenticate::Show("H");
      TAuthenticate::Show("P");
   }

   // Check the list of auth info for already loaded info about this host
   fHostAuth = GetHostAuth(fqdnsrv, checkUser);

   // If for whatever (and unlikely) reason nothing has been found
   // we look for the old envs defaulting to method 0 (UsrPwd)
   // if they are missing or meaningless
   if (!fHostAuth) {

      TString tmp;
      if (fProtocol.Contains("proof")) {
         tmp = TString(gEnv->GetValue("Proofd.Authentication", "0"));
      } else if (fProtocol.Contains("root")) {
         tmp = TString(gEnv->GetValue("Rootd.Authentication", "0"));
      }
      char am[kMAXSEC][10];
      Int_t nw = sscanf(tmp.Data(), "%5s %5s %5s %5s %5s %5s",
                        am[0], am[1], am[2], am[3], am[4], am[5]);

      Int_t i = 0, nm = 0, me[kMAXSEC];
      for( ; i < nw; i++) {
         Int_t met = -1;
         if (strlen(am[i]) > 1) {
            met = GetAuthMethodIdx(am[i]);
         } else {
            met = atoi(am[i]);
         }
         if (met > -1 && met < kMAXSEC) {
            me[nm++] = met;
         }
      }

      // Create THostAuth
      if (nm)
         fHostAuth = new THostAuth(fRemote,fUser,nm,me,0);
      else
         fHostAuth = new THostAuth(fRemote,fUser,0,(const char *)0);
   }

   //
   // If generic THostAuth (i.e. with wild card or user == any)
   // make a personalized memory copy of this THostAuth
   if (strchr(fHostAuth->GetHost(),'*') || strchr(fHostAuth->GetHost(),'*') ||
       fHostAuth->GetServer() == -1 ) {
      fHostAuth = new THostAuth(*fHostAuth);
      fHostAuth->SetHost(fqdn);
      fHostAuth->SetUser(checkUser);
      fHostAuth->SetServer(servtype);
   }

   // If a specific method has been requested via the protocol
   // set it as first
   Int_t sec = -1;
   TString tmp = fProtocol;
   tmp.ReplaceAll("root",4,"",0);
   tmp.ReplaceAll("proof",5,"",0);
   tmp.ReplaceAll("sock",4,"",0);
   if (!strncmp(tmp.Data(),"up",2))
      sec = 0;
   else if (!strncmp(tmp.Data(),"s",1))
      sec = 1;
   else if (!strncmp(tmp.Data(),"k",1))
      sec = 2;
   else if (!strncmp(tmp.Data(),"g",1))
      sec = 3;
   else if (!strncmp(tmp.Data(),"h",1))
      sec = 4;
   else if (!strncmp(tmp.Data(),"ug",2))
      sec = 5;
   if (sec > -1 && sec < kMAXSEC) {
      if (fHostAuth->HasMethod(sec)) {
         fHostAuth->SetFirst(sec);
      } else {
         char *dtmp = GetDefaultDetails(sec, 1, checkUser);
         TString det(dtmp);
         fHostAuth->AddFirst(sec, det);
         if (dtmp)
            delete [] dtmp;
      }
   }

   // This is what we have in memory
   if (gDebug > 3) {
      TIter next(fHostAuth->Established());
      TRootSecContext *ctx;
      while ((ctx = (TRootSecContext *) next()))
         ctx->Print("0");
   }
}

//_____________________________________________________________________________
void TAuthenticate::CatchTimeOut()
{
   // Called in connection with a timer timeout

   Info("CatchTimeOut", "%d sec timeout expired (protocol: %s)",
        fgAuthTO, fgAuthMeth[fSecurity].Data());

   fTimeOut = 1;
   if (fSocket)
      fSocket->Close("force");

   return;
}

//______________________________________________________________________________
Bool_t TAuthenticate::Authenticate()
{
   // Authenticate to remote rootd or proofd server. Return kTRUE if
   // authentication succeeded.

   if (gDebug > 2 && gAuthenticateMutex)
      Info("Authenticate", "locking mutex (pid:  %d)",gSystem->GetPid());
   R__LOCKGUARD2(gAuthenticateMutex);

   Bool_t rc = kFALSE;
   Int_t st = -1;
   Int_t remMeth = 0, rMth[kMAXSEC], tMth[kMAXSEC] = {0};
   Int_t meth = 0;
   char noSupport[80] = { 0 };
   char triedMeth[80] = { 0 };
   Int_t ntry = 0;

   TString user, passwd;
   Bool_t pwhash;

   if (gDebug > 2)
      Info("Authenticate", "enter: fUser: %s", fUser.Data());

   //
   // Setup timeout timer, if required
   TTimer *alarm = 0;
   if (fgAuthTO > 0) {
      alarm = new TTimer(0, kFALSE);
      alarm->SetInterruptSyscalls();
      // The method CatchTimeOut will be called at timeout
      alarm->Connect("Timeout()", "TAuthenticate", this, "CatchTimeOut()");
   }

negotia:
   st = -1;
   tMth[meth] = 1;
   ntry++;
   if (gDebug > 2)
      Info("Authenticate", "try #: %d", ntry);

   user = "";
   passwd = "";
   pwhash = kFALSE;

   // Security level from the list (if not in cleanup mode ...)
   fSecurity = (ESecurity) fHostAuth->GetMethod(meth);
   fDetails = fHostAuth->GetDetails((Int_t) fSecurity);
   if (gDebug > 2)
      Info("Authenticate",
           "trying authentication: method:%d, default details:%s",
           fSecurity, fDetails.Data());

   // Keep track of tried methods in a list
   if (strlen(triedMeth) > 0)
      snprintf(triedMeth, 80, "%s %s", triedMeth, fgAuthMeth[fSecurity].Data());
   else
      snprintf(triedMeth, 80, "%s", fgAuthMeth[fSecurity].Data());

   // Set environments
   SetEnvironment();

   st = -1;

   //
   // Reset timeout variables and start timer
   fTimeOut = 0;
   if (fgAuthTO > 0 && alarm) {
      alarm->Start(fgAuthTO*1000, kTRUE);
   }

   // Auth calls depend of fSec
   if (fSecurity == kClear) {

      rc = kFALSE;

      // UsrPwd Authentication
      user = fgDefaultUser;
      if (user != "")
         CheckNetrc(user, passwd, pwhash, kFALSE);
      if (passwd == "") {
         if (fgPromptUser)
            user = PromptUser(fRemote);
         rc = GetUserPasswd(user, passwd, pwhash, kFALSE);
      }
      fUser = user;
      fPasswd = passwd;

      if (!rc) {

         if (fUser != "root")
            st = ClearAuth(user, passwd, pwhash);
      } else {
         Error("Authenticate",
               "unable to get user name for UsrPwd authentication");
      }

   } else if (fSecurity == kSRP) {

      rc = kFALSE;

      // SRP Authentication
      user = fgDefaultUser;
      if (user != "")
         CheckNetrc(user, passwd, pwhash, kTRUE);
      if (passwd == "") {
         if (fgPromptUser) {
            char *p = PromptUser(fRemote);
            user = p;
            delete [] p;
         }
         rc = GetUserPasswd(user, passwd, pwhash, kTRUE);
      }
      fUser = user;
      fPasswd = passwd;

      if (!fgSecAuthHook) {

         char *p;
         TString lib = "libSRPAuth";
         if ((p = gSystem->DynamicPathName(lib, kTRUE))) {
            delete [] p;
            gSystem->Load(lib);
         }
      }
      if (!rc && fgSecAuthHook) {

         st = (*fgSecAuthHook) (this, user, passwd, fRemote, fDetails,
                                fVersion);
      } else {
         if (!fgSecAuthHook)
            Error("Authenticate",
                  "no support for SRP authentication available");
         if (rc)
            Error("Authenticate",
                  "unable to get user name for SRP authentication");
      }
      // Fill present user info ...
      if (st == 1) {
         fPwHash = kFALSE;
         fSRPPwd = kTRUE;
      }

   } else if (fSecurity == kKrb5) {

      if (fVersion > 0) {

         // Kerberos 5 Authentication
         if (!fgKrb5AuthHook) {
            char *p;
            TString lib = "libKrb5Auth";
            if ((p = gSystem->DynamicPathName(lib, kTRUE))) {
               delete [] p;
               gSystem->Load(lib);
            }
         }
         if (fgKrb5AuthHook) {
            fUser = fgDefaultUser;
            st = (*fgKrb5AuthHook) (this, fUser, fDetails, fVersion);
         } else {
            Error("Authenticate",
                  "support for kerberos5 auth locally unavailable");
         }
      } else {
         if (gDebug > 0)
            Info("Authenticate",
                 "remote daemon does not support Kerberos authentication");
         if (strlen(noSupport) > 0)
            snprintf(noSupport, 80, "%s/Krb5", noSupport);
         else
            snprintf(noSupport, 80, "Krb5");
      }

   } else if (fSecurity == kGlobus) {
      if (fVersion > 1) {

         // Globus Authentication
         if (!fgGlobusAuthHook) {
            char *p;
            TString lib = "libGlobusAuth";
            if ((p = gSystem->DynamicPathName(lib, kTRUE))) {
               delete [] p;
               gSystem->Load(lib);
            }
         }
         if (fgGlobusAuthHook) {
            st = (*fgGlobusAuthHook) (this, fUser, fDetails);
         } else {
            Error("Authenticate",
                  "no support for Globus authentication available");
         }
      } else {
         if (gDebug > 0)
            Info("Authenticate",
                 "remote daemon does not support Globus authentication");
         if (strlen(noSupport) > 0)
            snprintf(noSupport, 80, "%s/Globus", noSupport);
         else
            snprintf(noSupport, 80, "Globus");
      }


   } else if (fSecurity == kSSH) {

      if (fVersion > 1) {

         // SSH Authentication
         st = SshAuth(fUser);

      } else {
         if (gDebug > 0)
            Info("Authenticate",
                 "remote daemon does not support SSH authentication");
         if (strlen(noSupport) > 0)
            snprintf(noSupport, 80, "%s/SSH", noSupport);
         else
            snprintf(noSupport, 80, "SSH");
      }

   } else if (fSecurity == kRfio) {

      if (fVersion > 1) {

         // UidGid Authentication
         st = RfioAuth(fUser);

      } else {
         if (gDebug > 0)
            Info("Authenticate",
                 "remote daemon does not support UidGid authentication");
         if (strlen(noSupport) > 0)
            snprintf(noSupport, 80, "%s/UidGid", noSupport);
         else
            snprintf(noSupport, 80, "UidGid");
      }
   }
   //
   // Stop timer
   if (alarm) alarm->Stop();

   // Flag timeout condition
   st = (fTimeOut > 0) ? -3 : st;

   //
   // Analyse the result now ...
   // Type of action after the analysis:
   // 0 = return, 1 = negotiation, 2 = send kROOTD_BYE + 3,
   // 3 = print failure and return
   Int_t action = 0;
   Int_t nmet = fHostAuth->NumMethods();
   Int_t remloc = nmet - ntry;
   if (gDebug > 0)
      Info("Authenticate","remloc: %d, ntry: %d, meth: %d, fSecurity: %d",
                           remloc, ntry, meth, fSecurity);
   Int_t kind, stat;
   switch (st) {

   case 1:
      //
      // Success
      fHostAuth->CountSuccess((Int_t)fSecurity);
      if (gDebug > 2)
         fSecContext->Print();
      if (fSecContext->IsActive())
         fSecContext->AddForCleanup(fSocket->GetPort(),
                                    fSocket->GetRemoteProtocol(),fSocket->GetServType());
      rc = kTRUE;
      break;

   case 0:
      //
      // Failure
      fHostAuth->CountFailure((Int_t)fSecurity);
      if (fVersion < 2) {
         //
         // Negotiation not supported by old daemons ...
         if (gDebug > 2)
            Info("Authenticate",
                 "negotiation not supported remotely: try next method, if any");
         if (meth < nmet - 1) {
            meth++;
            action = 1;
         } else {
            action = 2;
         }
         rc = kFALSE;
         break;
      }
      //
      // Attempt negotiation ...
      if (fSocket->Recv(stat, kind) < 0) {
         action = 0;
         rc = kFALSE;
      }
      if (gDebug > 2)
         Info("Authenticate",
              "after failed attempt: kind= %d, stat= %d", kind, stat);
      if (kind == kROOTD_ERR) {
         action = 2;
         rc = kFALSE;
      } else if (kind == kROOTD_NEGOTIA) {
         if (stat > 0) {
            int len = 3 * stat;
            char *answer = new char[len];
            int nrec = fSocket->Recv(answer, len, kind);  // returns user
            if (nrec < 0) {
               action = 0;
               rc = kFALSE;
               break;
            }
            if (kind != kMESS_STRING)
               Warning("Authenticate",
                       "strings with accepted methods not received (%d:%d)",
                       kind, nrec);
            remMeth =
               sscanf(answer, "%d %d %d %d %d %d", &rMth[0], &rMth[1],
                      &rMth[2], &rMth[3], &rMth[4], &rMth[5]);
            if (gDebug > 0 && remloc > 0)
               Info("Authenticate",
                    "remotely allowed methods not yet tried: %s",
                    answer);
            delete[] answer;
         } else if (stat == 0) {
            Info("Authenticate",
                 "no more methods accepted remotely to be tried");
            action = 3;
            rc = kFALSE;
            break;
         }
         // If no more local methods, return
         if (remloc < 1) {
            action = 2;
            rc = kFALSE;
            break;
         }
         // Look if a non-tried method matches
         int i, j;
         char locav[40] = { 0 };
         Bool_t methfound = kFALSE;
         for (i = 0; i < remMeth; i++) {
            for (j = 0; j < nmet; j++) {
               if (fHostAuth->GetMethod(j) == rMth[i] && tMth[j] == 0) {
                  meth = j;
                  action = 1;
                  methfound = kTRUE;
                  break;
               }
               if (i == 0)
                  snprintf(locav, 40, "%s %d", locav, fHostAuth->GetMethod(j));
            }
            if (methfound) break;
         }
         if (methfound) break;
         //
         // No method left to be tried: notify and exit
         if (gDebug > 0)
            Warning("Authenticate",
                    "no match with those locally available: %s", locav);
         action = 2;
         rc = kFALSE;
         break;
      } else {        // unknown message code at this stage
         action = 3;
         rc = kFALSE;
         break;
      }
      break;

   case -1:
      //
      // Method not supported
      fHostAuth->CountFailure((Int_t)fSecurity);
      if (gDebug > 2)
         Info("Authenticate",
              "method not even started: insufficient or wrong info: %s",
              "try with next method, if any");
      fHostAuth->RemoveMethod(fSecurity);
      nmet--;
      if (nmet > 0) {
         action = 1;
      } else
         action = 2;

      break;

   case -2:
      //
      // Remote host does not accepts connections from local host
      fHostAuth->CountFailure((Int_t)fSecurity);
      if (fVersion <= 2)
         if (gDebug > 2)
            Warning("Authenticate",
                    "status code -2 not expected from old daemons");
      rc = kFALSE;
      break;

   case -3:
      //
      // Timeout: we set the method as last one, should the caller
      // decide to retry, if it will attempt first something else.
      // (We can not retry directly, because the server will not be
      //  synchronized ...)
      fHostAuth->CountFailure((Int_t)fSecurity);
      if (gDebug > 2)
         Info("Authenticate", "got a timeout");
      fHostAuth->SetLast(fSecurity);
      if (meth < nmet - 1) {
         fTimeOut = 2;
      } else
         fTimeOut = 1;
      rc = kFALSE;
      break;

   default:
      fHostAuth->CountFailure((Int_t)fSecurity);
      if (gDebug > 2)
         Info("Authenticate", "unknown status code: %d - assume failure",st);
      rc = kFALSE;
      action = 0;
      break;
   }

   switch (action) {
   case 1:
      goto negotia;
      // No break but we go away anyhow
   case 2:
      fSocket->Send("0", kROOTD_BYE);
      // fallthrough
   case 3:
      if (strlen(noSupport) > 0)
         Info("Authenticate", "attempted methods %s are not supported"
              " by remote server version", noSupport);
      Info("Authenticate",
           "failure: list of attempted methods: %s", triedMeth);
      AuthError("Authenticate",-1);
      rc = kFALSE;
      break;
   default:
      break;
   }

   // Cleanup timer
   if (alarm)
      SafeDelete(alarm);

   return rc;

}

//______________________________________________________________________________
void TAuthenticate::SetEnvironment()
{
   // Set default authentication environment. The values are inferred
   // from fSecurity and fDetails.

   R__LOCKGUARD2(gAuthenticateMutex);

   if (gDebug > 2)
      Info("SetEnvironment",
           "setting environment: fSecurity:%d, fDetails:%s", fSecurity,
           fDetails.Data());

   // Defaults
   fgDefaultUser = fgUser;
   if (fSecurity == kKrb5 ||
       (fSecurity == kGlobus && gROOT->IsProofServ()))
      fgAuthReUse = kFALSE;
   else
      fgAuthReUse = kTRUE;
   fgPromptUser = kFALSE;

   // Decode fDetails, is non empty ...
   if (fDetails != "") {
      char usdef[kMAXPATHLEN] = { 0 };
      char pt[5] = { 0 }, ru[5] = { 0 };
      Int_t hh = 0, mm = 0;
      char us[kMAXPATHLEN] = {0}, cp[kMAXPATHLEN] = {0}, pp[kMAXPATHLEN] = {0};
      char cd[kMAXPATHLEN] = {0}, cf[kMAXPATHLEN] = {0}, kf[kMAXPATHLEN] = {0}, ad[kMAXPATHLEN] = {0};
      const char *ptr;

      TString usrPromptDef = TString(GetAuthMethod(fSecurity)) + ".LoginPrompt";
      if ((ptr = strstr(fDetails, "pt:")) != 0) {
         sscanf(ptr + 3, "%4s %8191s", pt, usdef);
      } else {
         if (!strncasecmp(gEnv->GetValue(usrPromptDef,""),"no",2) ||
             !strncmp(gEnv->GetValue(usrPromptDef,""),"0",1))
            strncpy(pt,"0",1);
         else
            strncpy(pt,"1",1);
      }
      TString usrReUseDef = TString(GetAuthMethod(fSecurity)) + ".ReUse";
      if ((ptr = strstr(fDetails, "ru:")) != 0) {
         sscanf(ptr + 3, "%4s %8191s", ru, usdef);
      } else {
         if (!strncasecmp(gEnv->GetValue(usrReUseDef,""),"no",2) ||
             !strncmp(gEnv->GetValue(usrReUseDef,""),"0",1))
            strncpy(ru,"0",1);
         else
            strncpy(ru,"1",1);
      }
      TString usrValidDef = TString(GetAuthMethod(fSecurity)) + ".Valid";
      TString hours(gEnv->GetValue(usrValidDef,"24:00"));
      Int_t pd = 0;
      if ((pd = hours.Index(":")) > -1) {
         TString minutes = hours;
         hours.Resize(pd);
         minutes.Replace(0,pd+1,"");
         hh = atoi(hours.Data());
         mm = atoi(minutes.Data());
      } else {
         hh = atoi(hours.Data());
         mm = 0;
      }

      // Now action depends on method ...
      if (fSecurity == kGlobus) {
         if ((ptr = strstr(fDetails, "cd:")) != 0)
            sscanf(ptr, "%8191s %8191s", cd, usdef);
         if ((ptr = strstr(fDetails, "cf:")) != 0)
            sscanf(ptr, "%8191s %8191s", cf, usdef);
         if ((ptr = strstr(fDetails, "kf:")) != 0)
            sscanf(ptr, "%8191s %8191s", kf, usdef);
         if ((ptr = strstr(fDetails, "ad:")) != 0)
            sscanf(ptr, "%8191s %8191s", ad, usdef);
         if (gDebug > 2) {
            Info("SetEnvironment",
                 "details:%s, pt:%s, ru:%s, cd:%s, cf:%s, kf:%s, ad:%s",
                 fDetails.Data(), pt, ru, cd, cf, kf, ad);
         }
      } else if (fSecurity == kClear) {
         if ((ptr = strstr(fDetails, "us:")) != 0)
            sscanf(ptr + 3, "%8191s %8191s", us, usdef);
         if ((ptr = strstr(fDetails, "cp:")) != 0)
            sscanf(ptr + 3, "%8191s %8191s", cp, usdef);
         if (gDebug > 2)
            Info("SetEnvironment", "details:%s, pt:%s, ru:%s, us:%s cp:%s",
                 fDetails.Data(), pt, ru, us, cp);
      } else if (fSecurity == kKrb5) {
         if ((ptr = strstr(fDetails, "us:")) != 0)
            sscanf(ptr + 3, "%8191s %8191s", us, usdef);
         if ((ptr = strstr(fDetails, "pp:")) != 0)
            sscanf(ptr + 3, "%8191s %8191s", pp, usdef);
         if (gDebug > 2)
            Info("SetEnvironment", "details:%s, pt:%s, ru:%s, us:%s pp:%s",
                 fDetails.Data(), pt, ru, us, pp);
      } else {
         if ((ptr = strstr(fDetails, "us:")) != 0)
            sscanf(ptr + 3, "%8191s %8191s", us, usdef);
         if (gDebug > 2)
            Info("SetEnvironment", "details:%s, pt:%s, ru:%s, us:%s",
                 fDetails.Data(), pt, ru, us);
      }

      // Set Prompt flag
      if (!strncasecmp(pt, "yes",3) || !strncmp(pt, "1", 1))
         fgPromptUser = kTRUE;

      // Set ReUse flag
      if (fSecurity == kKrb5) {
         fgAuthReUse = kFALSE;
         if (!strncasecmp(ru, "yes",3) || !strncmp(ru, "1",1))
            fgAuthReUse = kTRUE;
      } else {
         if (fSecurity != kGlobus || !(gROOT->IsProofServ())) {
            fgAuthReUse = kTRUE;
            if (!strncasecmp(ru, "no",2) || !strncmp(ru, "0",1))
               fgAuthReUse = kFALSE;
         }
      }

      // Set Expiring date
      fgExpDate = TDatime();
      fgExpDate.Set(fgExpDate.Convert() + hh*3600 + mm*60);

      // UnSet Crypt flag for UsrPwd, if requested
      if (fSecurity == kClear) {
         fgUsrPwdCrypt = kTRUE;
         if (!strncmp(cp, "no", 2) || !strncmp(cp, "0", 1))
            fgUsrPwdCrypt = kFALSE;
      }
      // Build UserDefaults
      usdef[0] = '\0';
      if (fSecurity == kGlobus) {
         if (strlen(cd) > 0) { snprintf(usdef,8192," %s",cd); }
         if (strlen(cf) > 0) { snprintf(usdef,8192,"%s %s",usdef, cf); }
         if (strlen(kf) > 0) { snprintf(usdef,8192,"%s %s",usdef, kf); }
         if (strlen(ad) > 0) { snprintf(usdef,8192,"%s %s",usdef, ad); }
      } else {
         if (fSecurity == kKrb5) {
            // Collect info about principal, if any
            if (strlen(pp) > 0) {
               fgKrb5Principal = TString(pp);
            } else {
               // Allow specification via 'us:' key
               if (strlen(us) > 0 && strstr(us,"@"))
                  fgKrb5Principal = TString(us);
            }
            // command line user specification (fUser) gets highest priority
            if (fUser.Length()) {
               snprintf(usdef, kMAXPATHLEN, "%s", fUser.Data());
            } else {
               if (strlen(us) > 0 && !strstr(us,"@"))
                  snprintf(usdef, kMAXPATHLEN, "%s", us);
            }
         } else {
            // give highest priority to command-line specification
            if (fUser == "") {
               if (strlen(us) > 0) snprintf(usdef, kMAXPATHLEN, "%s", us);
            } else
               snprintf(usdef, kMAXPATHLEN, "%s", fUser.Data());
         }
      }
      if (strlen(usdef) > 0) {
         fgDefaultUser = usdef;
      } else {
         if (fgUser != "") {
            fgDefaultUser = fgUser;
         } else {
            UserGroup_t *u = gSystem->GetUserInfo();
            if (u)
               fgDefaultUser = u->fUser;
            delete u;
         }
      }
      if (fgDefaultUser == "anonymous" || fgDefaultUser == "rootd" ||
          fgUser != "" || fUser != "") {
         // when set by user don't prompt for it anymore
         fgPromptUser = kFALSE;
      }

      if (gDebug > 2)
         Info("SetEnvironment", "usdef:%s", fgDefaultUser.Data());
   }
}

//______________________________________________________________________________
Bool_t TAuthenticate::GetUserPasswd(TString &user, TString &passwd,
                                    Bool_t &pwhash, Bool_t srppwd)
{
   // Try to get user name and passwd from several sources.

   if (gDebug > 3)
      Info("GetUserPasswd", "Enter: User: '%s' Hash:%d SRP:%d",
           user.Data(),(Int_t)pwhash,(Int_t)srppwd);

   // Get user and passwd set via static functions SetUser and SetPasswd.
   if (user == "") {
      if (fgUser != "")
         user = fgUser;
      if (passwd == "" && fgPasswd != "" && srppwd == fgSRPPwd) {
         passwd = fgPasswd;
         pwhash = fgPwHash;
      }
   } else {
      if (fgUser != "" && user == fgUser) {
         if (passwd == "" && fgPasswd != "" && srppwd == fgSRPPwd) {
            passwd = fgPasswd;
            pwhash = fgPwHash;
         }
      }
   }
   if (gDebug > 3)
      Info("GetUserPasswd", "In memory: User: '%s' Hash:%d",
           user.Data(),(Int_t)pwhash);

   // Check system info for user if still not defined
   if (user == "") {
      UserGroup_t *u = gSystem->GetUserInfo();
      if (u)
         user = u->fUser;
      delete u;
      if (gDebug > 3)
         Info("GetUserPasswd", "In memory: User: '%s' Hash:%d",
              user.Data(),(Int_t)pwhash);
   }

   // Check ~/.rootnetrc and ~/.netrc files if user was not set via
   // the static SetUser() method.
   if (user == "" || passwd == "") {
      if (gDebug > 3)
         Info("GetUserPasswd", "Checking .netrc family ...");
      CheckNetrc(user, passwd, pwhash, srppwd);
   }
   if (gDebug > 3)
      Info("GetUserPasswd", "From .netrc family: User: '%s' Hash:%d",
           user.Data(),(Int_t)pwhash);

   // If user also not set via  ~/.rootnetrc or ~/.netrc ask user.
   if (user == "") {
      char *p = PromptUser(fRemote);
      user = p;
      delete [] p;
      if (user == "") {
         Error("GetUserPasswd", "user name not set");
         return 1;
      }
   }

   return 0;
}

//______________________________________________________________________________
Bool_t TAuthenticate::CheckNetrc(TString &user, TString &passwd)
{
   // Try to get user name and passwd from the ~/.rootnetrc or
   // ~/.netrc files. For more info see the version with 4 arguments.
   // This version is maintained for backward compatability reasons.

   Bool_t hash, srppwd;

   // Set srppwd flag
   srppwd = (fSecurity == kSRP) ? kTRUE : kFALSE;

   return CheckNetrc(user, passwd, hash, srppwd);
}

//______________________________________________________________________________
Bool_t TAuthenticate::CheckNetrc(TString &user, TString &passwd,
                                 Bool_t &pwhash, Bool_t srppwd)
{
   // Try to get user name and passwd from the ~/.rootnetrc or
   // ~/.netrc files. First ~/.rootnetrc is tried, after that ~/.netrc.
   // These files will only be used when their access masks are 0600.
   // Returns kTRUE if user and passwd were found for the machine
   // specified in the URL. If kFALSE, user and passwd are "".
   // If srppwd == kTRUE then a SRP ('secure') pwd is searched for in
   // the files.
   // The boolean pwhash is set to kTRUE if the returned passwd is to
   // be understood as password hash, i.e. if the 'password-hash' keyword
   // is found in the 'machine' lines; not implemented for 'secure'
   // and the .netrc file.
   // The format of these files are:
   //
   // # this is a comment line
   // machine <machine fqdn> login <user> password <passwd>
   // machine <machine fqdn> login <user> password-hash <passwd>
   //
   // and in addition ~/.rootnetrc also supports:
   //
   // secure <machine fqdn> login <user> password <passwd>
   //
   // <machine fqdn> may be a domain name or contain the wild card '*'.
   //
   // for the secure protocols. All lines must start in the first column.

   Bool_t result = kFALSE;
   Bool_t first = kTRUE;
   TString remote = fRemote;

   passwd = "";
   pwhash = kFALSE;

   char *net =
      gSystem->ConcatFileName(gSystem->HomeDirectory(), ".rootnetrc");

   // Determine FQDN of the host ...
   TInetAddress addr = gSystem->GetHostByName(fRemote);
   if (addr.IsValid())
      remote = addr.GetHostName();

again:
   // Only use file when its access rights are 0600
   FileStat_t buf;
   if (gSystem->GetPathInfo(net, buf) == 0) {
#ifdef WIN32
      // Since Win32 does not have proper protections use file always
      if (R_ISREG(buf.fMode) && !R_ISDIR(buf.fMode)) {
#else
         if (R_ISREG(buf.fMode) && !R_ISDIR(buf.fMode) &&
             (buf.fMode & 0777) == (kS_IRUSR | kS_IWUSR)) {
#endif
            FILE *fd = fopen(net, "r");
            char line[256];
            while (fgets(line, sizeof(line), fd) != 0) {
               if (line[0] == '#')
                  continue;
               char word[6][64];
               int nword = sscanf(line, "%63s %63s %63s %63s %63s %63s",
                                        word[0], word[1], word[2], word[3], word[4], word[5]);
               if (nword != 6)
                  continue;
               if (srppwd && strcmp(word[0], "secure"))
                  continue;
               if (!srppwd && strcmp(word[0], "machine"))
                  continue;
               if (strcmp(word[2], "login"))
                  continue;
               if (srppwd && strcmp(word[4], "password"))
                  continue;
               if (!srppwd &&
                   strcmp(word[4], "password") && strcmp(word[4], "password-hash"))
                  continue;

               // Treat the host name found in file as a regular expression
               // with '*' as a wild card
               TString href(word[1]);
               href.ReplaceAll("*",".*");
               TRegexp rg(href);
               if (remote.Index(rg) != kNPOS) {
                  if (user == "") {
                     user = word[3];
                     passwd = word[5];
                     if (!strcmp(word[4], "password-hash"))
                        pwhash = kTRUE;
                     result = kTRUE;
                     break;
                  } else {
                     if (!strcmp(word[3], user.Data())) {
                        passwd = word[5];
                        if (!strcmp(word[4], "password-hash"))
                           pwhash = kTRUE;
                        result = kTRUE;
                        break;
                     }
                  }
               }
            }
            fclose(fd);
         } else
            Warning("CheckNetrc",
                    "file %s exists but has not 0600 permission", net);
      }
      delete [] net;

      if (first && !srppwd && !result) {
         net = gSystem->ConcatFileName(gSystem->HomeDirectory(), ".netrc");
         first = kFALSE;
         goto again;
      }

      return result;
   }

//______________________________________________________________________________
const char *TAuthenticate::GetGlobalUser()
{
   // Static method returning the global user.

   return fgUser;
}

//______________________________________________________________________________
Bool_t TAuthenticate::GetGlobalPwHash()
{
   // Static method returning the global password hash flag.

   return fgPwHash;
}

//______________________________________________________________________________
Bool_t TAuthenticate::GetGlobalSRPPwd()
{
   // Static method returning the global SRP password flag.

   return fgSRPPwd;
}

//______________________________________________________________________________
TDatime TAuthenticate::GetGlobalExpDate()
{
   // Static method returning default expiring date for new validity contexts

   return fgExpDate;
}

//______________________________________________________________________________
const char *TAuthenticate::GetDefaultUser()
{
   // Static method returning the default user information.

   return fgDefaultUser;
}

//______________________________________________________________________________
const char *TAuthenticate::GetKrb5Principal()
{
    // Static method returning the principal to be used to init Krb5 tickets.

   return fgKrb5Principal;
}

//______________________________________________________________________________
Bool_t TAuthenticate::GetAuthReUse()
{
   // Static method returning the authentication reuse settings.

   return fgAuthReUse;
}

//______________________________________________________________________________
Bool_t TAuthenticate::GetPromptUser()
{
   // Static method returning the prompt user settings.

   return fgPromptUser;
}

//______________________________________________________________________________
const char *TAuthenticate::GetAuthMethod(Int_t idx)
{
   // Static method returning the method corresponding to idx.

   R__LOCKGUARD2(gAuthenticateMutex);

   if (idx < 0 || idx > kMAXSEC-1) {
      ::Error("Authenticate::GetAuthMethod", "idx out of bounds (%d)", idx);
      idx = 0;
   }
   return fgAuthMeth[idx];
}

//______________________________________________________________________________
Int_t TAuthenticate::GetAuthMethodIdx(const char *meth)
{
   // Static method returning the method index (which can be used to find
   // the method in GetAuthMethod()). Returns -1 in case meth is not found.

   R__LOCKGUARD2(gAuthenticateMutex);

   if (meth && meth[0]) {
      for (Int_t i = 0; i < kMAXSEC; i++) {
         if (!fgAuthMeth[i].CompareTo(meth, TString::kIgnoreCase))
            return i;
      }
   }

   return -1;
}

//______________________________________________________________________________
char *TAuthenticate::PromptUser(const char *remote)
{
   // Static method to prompt for the user name to be used for authentication
   // to rootd or proofd. User is asked to type user name.
   // Returns user name (which must be deleted by caller) or 0.
   // If non-interactive run (eg ProofServ) returns default user.

   R__LOCKGUARD2(gAuthenticateMutex);

   const char *user;
   if (fgDefaultUser != "")
      user = fgDefaultUser;
   else
      user = gSystem->Getenv("USER");
#ifdef R__WIN32
   if (!user)
      user = gSystem->Getenv("USERNAME");
#endif
   if (isatty(0) == 0 || isatty(1) == 0) {
      ::Warning("TAuthenticate::PromptUser",
                "not tty: cannot prompt for user, returning default");
      if (strlen(user))
         return StrDup(user);
      else
         return StrDup("None");
   }

   const char *usrIn = Getline(Form("Name (%s:%s): ", remote, user));
   if (usrIn[0]) {
      TString usr(usrIn);
      usr.Remove(usr.Length() - 1); // get rid of \n
      if (!usr.IsNull())
         return StrDup(usr);
      else
         return StrDup(user);
   }
   return 0;
}

//______________________________________________________________________________
char *TAuthenticate::PromptPasswd(const char *prompt)
{
   // Static method to prompt for the user's passwd to be used for
   // authentication to rootd or proofd. Uses non-echoing command line
   // to get passwd. Returns passwd (which must de deleted by caller) or 0.
   // If non-interactive run (eg ProofServ) returns -1

   if (isatty(0) == 0 || isatty(1) == 0) {
      ::Warning("TAuthenticate::PromptPasswd",
                "not tty: cannot prompt for passwd, returning -1");
      static char noint[4] = {"-1"};
      return StrDup(noint);
   }

   char buf[128];
   const char *pw = buf;
   // Get the plugin for the passwd dialog box, if needed
   if (!gROOT->IsBatch() && (fgPasswdDialog == (TPluginHandler *)(-1)) &&
       gEnv->GetValue("Auth.UsePasswdDialogBox", 1) == 1) {
      if ((fgPasswdDialog =
           gROOT->GetPluginManager()->FindHandler("TGPasswdDialog"))) {
         if (fgPasswdDialog->LoadPlugin() == -1) {
            fgPasswdDialog = 0;
            ::Warning("TAuthenticate",
                      "could not load plugin for the password dialog box");
         }
      }
   }
   if (fgPasswdDialog && (fgPasswdDialog != (TPluginHandler *)(-1))) {

      // Use graphic dialog
      fgPasswdDialog->ExecPlugin(3, prompt, buf, 128);

      // Wait until the user is done
      while (gROOT->IsInterrupted())
         gSystem->DispatchOneEvent(kFALSE);

   } else {
      Gl_config("noecho", 1);
      pw = Getline(prompt);
      Gl_config("noecho", 0);
   }

   // Final checks
   if (pw[0]) {
      TString spw(pw);
      if (spw.EndsWith("\n"))
         spw.Remove(spw.Length() - 1);   // get rid of \n
      char *rpw = StrDup(spw);
      return rpw;
   }
   return 0;
}

//______________________________________________________________________________
GlobusAuth_t TAuthenticate::GetGlobusAuthHook()
{
   // Static method returning the globus authorization hook.

   return fgGlobusAuthHook;
}

//______________________________________________________________________________
const char *TAuthenticate::GetRSAPubExport(Int_t key)
{
   // Static method returning the RSA public keys.

   key = (key >= 0 && key <= 1) ? key : 0;
   return fgRSAPubExport[key].keys;
}

//______________________________________________________________________________
Int_t TAuthenticate::GetRSAInit()
{
   // Static method returning the RSA initialization flag.

   return fgRSAInit;
}

//______________________________________________________________________________
void TAuthenticate::SetDefaultRSAKeyType(Int_t key)
{
   // Static method setting the default type of RSA key.

   if (key >= 0 && key <= 1)
      fgRSAKey = key;
}

//______________________________________________________________________________
void TAuthenticate::SetRSAInit(Int_t init)
{
   // Static method setting RSA initialization flag.

   fgRSAInit = init;
}

//______________________________________________________________________________
TList *TAuthenticate::GetAuthInfo()
{
   // Static method returning the list with authentication details.

   R__LOCKGUARD2(gAuthenticateMutex);

   if (!fgAuthInfo)
      fgAuthInfo = new TList;
   return fgAuthInfo;
}

//______________________________________________________________________________
TList *TAuthenticate::GetProofAuthInfo()
{
   // Static method returning the list with authentication directives
   // to be sent to proof.

   R__LOCKGUARD2(gAuthenticateMutex);

   if (!fgProofAuthInfo)
      fgProofAuthInfo = new TList;
   return fgProofAuthInfo;
}

//______________________________________________________________________________
void TAuthenticate::AuthError(const char *where, Int_t err)
{
   // Print error string depending on error code.

   R__LOCKGUARD2(gAuthenticateMutex);

   // Make sure it is in range
   err = (err < kErrError) ? ((err > -1) ? err : -1) : kErrError;

   Int_t erc = err;
   Bool_t forceprint = kFALSE;
   TString lasterr = "";
   if (err == -1) {
      forceprint = kTRUE;
      erc = fgLastError;
      lasterr = "(last error only; re-run with gDebug > 0 for more details)";
   }

   if (erc > -1)
      if (gDebug > 0 || forceprint) {
         if (gRootdErrStr[erc])
            ::Error(Form("TAuthenticate::%s", where), "%s %s",
                    gRootdErrStr[erc], lasterr.Data());
         else
            ::Error(Form("TAuthenticate::%s", where),
                    "unknown error code: server must be running a newer ROOT version %s",
                    lasterr.Data());
      }

   // Update last error code
   fgLastError = err;
}

//______________________________________________________________________________
void TAuthenticate::SetGlobalUser(const char *user)
{
   // Set global user name to be used for authentication to rootd or proofd.

   R__LOCKGUARD2(gAuthenticateMutex);

   if (fgUser != "")
      fgUser = "";

   if (user && user[0])
      fgUser = user;
}

//______________________________________________________________________________
void TAuthenticate::SetGlobalPasswd(const char *passwd)
{
   // Set global passwd to be used for authentication to rootd or proofd.

   R__LOCKGUARD2(gAuthenticateMutex);

   if (fgPasswd != "")
      fgPasswd = "";

   if (passwd && passwd[0])
      fgPasswd = passwd;
}

//______________________________________________________________________________
void TAuthenticate::SetGlobalPwHash(Bool_t pwhash)
{
   // Set global passwd hash flag to be used for authentication to rootd or proofd.

   fgPwHash = pwhash;
}

//______________________________________________________________________________
void TAuthenticate::SetGlobalSRPPwd(Bool_t srppwd)
{
   // Set global SRP passwd flag to be used for authentication to rootd or proofd.

   fgSRPPwd = srppwd;
}

//______________________________________________________________________________
void TAuthenticate::SetReadHomeAuthrc(Bool_t readhomeauthrc)
{
   // Set flag controlling the reading of $HOME/.rootauthrc.
   // In PROOF the administrator may want to switch off private settings.
   // Always true, may only be set false via option to proofd.

   fgReadHomeAuthrc = readhomeauthrc;
}

//______________________________________________________________________________
void TAuthenticate::SetGlobalExpDate(TDatime expdate)
{
   // Set default expiring date for new validity contexts

   fgExpDate = expdate;
}

//______________________________________________________________________________
void TAuthenticate::SetDefaultUser(const char *defaultuser)
{
   // Set default user name.

   if (fgDefaultUser != "")
      fgDefaultUser = "";

   if (defaultuser && defaultuser[0])
      fgDefaultUser = defaultuser;
}

//______________________________________________________________________________
void TAuthenticate::SetTimeOut(Int_t to)
{
   // Set timeout (active if > 0)

   fgAuthTO = (to <= 0) ? -1 : to;
}

//______________________________________________________________________________
void TAuthenticate::SetAuthReUse(Bool_t authreuse)
{
   // Set global AuthReUse flag

   fgAuthReUse = authreuse;
}

//______________________________________________________________________________
void TAuthenticate::SetPromptUser(Bool_t promptuser)
{
   // Set global PromptUser flag

   fgPromptUser = promptuser;
}

//______________________________________________________________________________
void TAuthenticate::SetSecureAuthHook(SecureAuth_t func)
{
   // Set secure authorization function. Automatically called when libSRPAuth
   // is loaded.

   fgSecAuthHook = func;
}

//______________________________________________________________________________
void TAuthenticate::SetKrb5AuthHook(Krb5Auth_t func)
{
   // Set kerberos5 authorization function. Automatically called when
   // libKrb5Auth is loaded.

   fgKrb5AuthHook = func;
}

//______________________________________________________________________________
void TAuthenticate::SetGlobusAuthHook(GlobusAuth_t func)
{
   // Set Globus authorization function. Automatically called when
   // libGlobusAuth is loaded.

   fgGlobusAuthHook = func;
}

//______________________________________________________________________________
Int_t TAuthenticate::SshError(const char *errorfile)
{
   // SSH error parsing: returns
   //     0  :  no error or fatal
   //     1  :  should retry (eg 'connection closed by remote host')

   Int_t error = 0;

   if (!gSystem->AccessPathName(errorfile, kReadPermission)) {
      FILE *ferr = fopen(errorfile,"r");
      if (ferr) {
         // Get list of errors for which one should retry
         char *serr = StrDup(gEnv->GetValue("SSH.ErrorRetry", ""));
         // Prepare for parsing getting rid of '"'s
         Int_t lerr = strlen(serr);
         char *pc = (char *)memchr(serr,'"',lerr);
         while (pc) {
            *pc = '\0';
            pc = (char *)memchr(pc+1,'"',strlen(pc+1));
         }
         // Now read the file
         char line[kMAXPATHLEN];
         while (fgets(line,sizeof(line),ferr)) {
            // Get rid of trailing '\n'
            if (line[strlen(line)-1] == '\n')
               line[strlen(line)-1] = '\0';
            if (gDebug > 2)
               Info("SshError","read line: %s",line);
            pc = serr;
            while (pc < serr + lerr) {
               if (pc[0] == '\0' || pc[0] == ' ')
                  pc++;
               else {
                  if (gDebug > 2)
                     Info("SshError","checking error: '%s'",pc);
                  if (strstr(line,pc))
                     error = 1;
                  pc += strlen(pc);
               }
            }
         }
         // Close file
         fclose(ferr);
         // Free allocated memory
         if (serr) delete [] serr;
      }
   }
   return error;
}

//______________________________________________________________________________
Int_t TAuthenticate::SshAuth(TString &user)
{
   // SSH client authentication code.

   // No control on credential forwarding in case of SSH authentication;
   // switched it off on PROOF servers, unless the user knows what they
   // are doing

   if (gROOT->IsProofServ()) {
      if (!(gEnv->GetValue("ProofServ.UseSSH",0))) {
         if (gDebug > 0)
            Info("SshAuth", "SSH protocol is switched OFF by default"
                 " for PROOF servers: use 'ProofServ.UseSSH 1'"
                 " to enable it (see system.rootrc)");
         return -1;
      }
   }

   Int_t sshproto = 1;
   if (fVersion < 4)
      sshproto = 0;

   // Find out which command we should be using
   char cmdref[2][5] = {"ssh", "scp"};
   char scmd[5] = "";
   TString sshExe;
   Bool_t notfound = kTRUE;

   while (notfound && sshproto > -1) {

      strlcpy(scmd,cmdref[sshproto],5);

      // Check First if a 'scmd' executable exists ...
      char *sSshExe = gSystem->Which(gSystem->Getenv("PATH"),
                               scmd, kExecutePermission);
      sshExe = sSshExe;
      delete [] sSshExe;
      if (!sshExe) {
         if (gDebug > 2)
            Info("SshAuth", "%s not found in $PATH", scmd);

         // Still allow for client definition of the ssh location ...
         if (strcmp(gEnv->GetValue("SSH.ExecDir", "-1"), "-1")) {
            if (gDebug > 2)
               Info("SshAuth", "searching user defined path ...");
            sshExe.Form("%s/%s", (char *)gEnv->GetValue("SSH.ExecDir", ""), scmd);
            if (gSystem->AccessPathName(sshExe, kExecutePermission)) {
               if (gDebug > 2)
                  Info("SshAuth", "%s not executable", sshExe.Data());
            } else
               notfound = kFALSE;
         }
      } else
         notfound = kFALSE;
      if (notfound) sshproto--;
   }

   // Check if the command was found
   if (notfound)
      return -1;

   if (gDebug > 2)
      Info("SshAuth", "%s is %s (sshproto: %d)", scmd, sshExe.Data(), sshproto);

   // SSH-like authentication code.
   // Returns 0 in case authentication failed
   //         1 in case of success
   //        -1 in case of the remote node does not seem to support
   //           SSH-like Authentication
   //        -2 in case of the remote node does not seem to allow
   //           connections from this node

   char secName[kMAXPATHLEN] = { 0 };

   // Determine user name ...
   user = GetSshUser(user);

   // Check ReUse
   Int_t reuse = (int)fgAuthReUse;
   fDetails = TString::Format("pt:%d ru:%d us:",(int)fgPromptUser,(int)fgAuthReUse)
      + user;

   // Create options string
   int opt = reuse * kAUTH_REUSE_MSK + fRSAKey * kAUTH_RSATY_MSK;
   TString options;
   options.Form("%d none %ld %s %d", opt,
                (Long_t)user.Length(),user.Data(),sshproto);

   // Check established authentications
   Int_t kind = kROOTD_SSH;
   Int_t retval = reuse;
   Int_t rc = 0;
   if ((rc = AuthExists(user, (Int_t) TAuthenticate::kSSH, options,
                        &kind, &retval, &StdCheckSecCtx)) == 1) {
      // A valid authentication exists: we are done ...
      return 1;
   }
   if (rc == -2) {
      return rc;
   }
   if (retval == kErrNotAllowed && kind == kROOTD_ERR) {
      return 0;
   }
   // Check return flags
   if (kind != kROOTD_SSH) {
      return 0;                 // something went wrong
   }
   if (retval == 0) {
      return 0;                 // no remote support for SSH
   }
   if (retval == -2) {
      return 0;                 // user unkmown to remote host
   }

   // Wait for the server to communicate remote pid and location
   // of command to execute
   char cmdinfo[kMAXPATHLEN] = { 0 };
   Int_t reclen = (retval+1 > kMAXPATHLEN) ? kMAXPATHLEN : retval+1 ;
   if (fSocket->Recv(cmdinfo, reclen, kind) < 0) {
      return 0;
   }
   if (kind != kROOTD_SSH) {
      return 0;                 // something went wrong
   }
   if (gDebug > 3) {
      Info("SshAuth", "received from server command info: %s", cmdinfo);
   }

   int rport = -1;
   TString ci(cmdinfo), tkn;
   Ssiz_t from = 0;
   while (ci.Tokenize(tkn, from, " ")) {
      if (from > 0) cmdinfo[from-1] = '\0';
      if (tkn.BeginsWith("p:")) {
         tkn.ReplaceAll("p:", "");
         if (tkn.IsDigit()) rport = tkn.Atoi();
#ifdef R__SSL
      } else if (tkn.BeginsWith("k:")) {
         tkn.ReplaceAll("k:", "");
         if (tkn.IsDigit() && tkn.Atoi() == 1) fRSAKey = 1;
#endif
      }
   }

   // If we are a non-interactive session we cannot reply
   TString noPrompt = "";
   if (isatty(0) == 0 || isatty(1) == 0) {
      noPrompt  = TString("-o 'PasswordAuthentication no' ");
      noPrompt += TString("-o 'StrictHostKeyChecking no' ");
      if (gDebug > 3)
         Info("SshAuth", "using noprompt options: %s", noPrompt.Data());
   }

   // Remote settings
   Int_t srvtyp = fSocket->GetServType();
   Int_t rproto = fSocket->GetRemoteProtocol();

   // Send authentication request to remote sshd
   // Create command
   int ssh_rc = 1;
   Int_t ntry = gEnv->GetValue("SSH.MaxRetry",100);
   TString fileErr = "";
   if (sshproto == 0) {
      // Prepare local file first in the home directory
      fileErr = "rootsshtmp_";
      FILE *floc = gSystem->TempFileName(fileErr,gSystem->HomeDirectory());
      if (floc == 0) {
         // Try the temp directory
         fileErr = "rootsshtmp_";
         if ((floc = gSystem->TempFileName(fileErr)))
            fclose(floc);
      }
      fileErr.Append(".error");
      TString sshcmd;
      sshcmd.Form("%s -x -l %s %s", sshExe.Data(), user.Data(), noPrompt.Data());
      if (rport != -1)
         sshcmd += TString::Format(" -p %d",rport);
      sshcmd += TString::Format(" %s %s",fRemote.Data(), cmdinfo);
      sshcmd += TString::Format(" 1> /dev/null 2> %s",fileErr.Data());

      // Execute command
      Int_t again = 1;
      while (ssh_rc && again && ntry--) {
         ssh_rc = gSystem->Exec(sshcmd);
         if (ssh_rc) {
            again = SshError(fileErr);
            if (gDebug > 3)
               Info("SshAuth", "%d: sleeping: rc: %d, again:%d, ntry: %d",
                    fgProcessID, ssh_rc, again, ntry);
            if (again)
               gSystem->Sleep(1);
         }
      }
   } else {
      // Whether we need to add info about user@host in the command
      // Recent rootd/proofd set this correctly so that it works also
      // via SSH tunnel
      Bool_t addhost = ((srvtyp == TSocket::kROOTD && rproto < 15) ||
                        (srvtyp == TSocket::kPROOFD && rproto < 13)||
                        (srvtyp == TSocket::kSOCKD && rproto < 1)) ? 1 : 0;

      // Prepare local file first in the home directory
      TString fileLoc = "rootsshtmp_";
      FILE *floc = gSystem->TempFileName(fileLoc,gSystem->HomeDirectory());
      if (floc == 0) {
         // Try the temp directory
         fileLoc = "rootsshtmp_";
         floc = gSystem->TempFileName(fileLoc);
      }

      if (floc != 0) {
         // Close file and change permissions before filling it
         fclose(floc);
         if (chmod(fileLoc, 0600) == -1) {
            Info("SshAuth", "fchmod error: %d", errno);
            ssh_rc = 2;
         } else {
            floc = fopen(fileLoc, "w");
            if (reuse == 1) {
               // Send our public key
               if (fVersion > 4) {
                  fprintf(floc,"k: %d\n",fRSAKey+1);
                  fwrite(fgRSAPubExport[fRSAKey].keys,1,
                         fgRSAPubExport[fRSAKey].len,floc);
               } else {
                  fprintf(floc,"k: %s\n",fgRSAPubExport[0].keys);
               }
            } else
               // Just a notification
               fprintf(floc,"k: -1\n");
            fclose(floc);
            ssh_rc = 0;
         }
         if (!ssh_rc) {
            fileErr = TString(fileLoc).Append(".error");
            TString sshcmd;
            sshcmd.Form("%s -p %s", sshExe.Data(), noPrompt.Data());
            if (rport != -1)
               sshcmd += TString::Format(" -P %d",rport);
            sshcmd += TString::Format(" %s",fileLoc.Data());
            if (addhost) {
               sshcmd += TString::Format(" %s@%s:%s 1> /dev/null",
                                         user.Data(),fRemote.Data(),cmdinfo);
            } else {
               sshcmd += TString::Format("%s 1> /dev/null", cmdinfo);
            }
            sshcmd += TString::Format(" 2> %s",fileErr.Data());
            // Execute command
            ssh_rc = 1;
            Int_t again = 1;
            while (ssh_rc && again && ntry--) {
               ssh_rc = gSystem->Exec(sshcmd);
               if (ssh_rc) {
                  again = SshError(fileErr);
                  if (gDebug > 3)
                     Info("SshAuth", "%d: sleeping: rc: %d, again:%d, ntry: %d",
                          fgProcessID, ssh_rc, again, ntry);
                  if (again)
                     // Wait 1 sec before retry
                     gSystem->Sleep(1000);
               }
            }
         }
      } else {
         // Problems creating temporary file: return ...
         ssh_rc = 1;
      }
      // Remove the file after use ...
      if (!gSystem->AccessPathName(fileLoc,kFileExists)) {
         gSystem->Unlink(fileLoc);
      }
   }
   // Remove the file after use ...
   if (!gSystem->AccessPathName(fileErr,kFileExists)) {
      gSystem->Unlink(fileErr);
   }
   if (gDebug > 3)
      Info("SshAuth", "%d: system return code: %d (%d)",
           fgProcessID, ssh_rc, ntry+1);

   if (ssh_rc && sshproto == 0) {

      srvtyp = fSocket->GetServType();
      rproto = fSocket->GetRemoteProtocol();
      Int_t level = 2;
      if ((srvtyp == TSocket::kROOTD && rproto < 10) ||
          (srvtyp == TSocket::kPROOFD && rproto < 9))
         level = 1;
      if ((srvtyp == TSocket::kROOTD && rproto < 8) ||
          (srvtyp == TSocket::kPROOFD && rproto < 7))
         level = 0;
      if (level) {
         Int_t port = fSocket->GetPort();
         TSocket *newsock = 0;
         TString url;
         url.Form("sockd://%s",fRemote.Data());
         if (srvtyp == TSocket::kROOTD) {
            // Parallel socket requested by 'rootd'
            url.ReplaceAll("sockd",5,"rootd",5);
            newsock = new TPSocket(url.Data(),port,1,-1);
         } else {
            if (srvtyp == TSocket::kPROOFD)
               url.ReplaceAll("sockd",5,"proofd",6);
            newsock = new TSocket(fRemote.Data(),port,-1);
            if (srvtyp == TSocket::kPROOFD)
               newsock->Send("failure notification");
         }
         // prepare info to send
         char cd1[1024], pipe[1024], dum[1024];
         Int_t id3;
         sscanf(cmdinfo, "%1023s %d %1023s %1023s", cd1, &id3, pipe, dum);
         snprintf(secName, kMAXPATHLEN, "%d -1 0 %s %d %s %d",
                  -fgProcessID, pipe,
                  (int)strlen(user), user.Data(), TSocket::GetClientProtocol());
         newsock->Send(secName, kROOTD_SSH);
         if (level > 1) {
            // Improved diagnostics
            // Receive diagnostics message
            if (newsock->Recv(retval, kind) >= 0) {
               char *buf = new char[retval+1];
               if (newsock->Recv(buf, retval+1, kind) >= 0) {
                  if (strncmp(buf,"OK",2)) {
                     Info("SshAuth", "from remote host %s:", fRemote.Data());
                     Info("SshAuth", ">> nothing listening on port %s %s",buf,
                          "(supposed to be associated to sshd)");
                     Info("SshAuth", ">> contact the daemon administrator at %s",
                          fRemote.Data());
                  } else {
                     if (gDebug > 0) {
                        Info("SshAuth", "from remote host %s:", fRemote.Data());
                        Info("SshAuth", ">> something listening on the port"
                             " supposed to be associated to sshd.");
                        Info("SshAuth", ">> You have probably mistyped your"
                             " password. Or you tried to hack the"
                             " system.");
                        Info("SshAuth", ">> If the problem persists you may"
                             " consider contacting the daemon");
                        Info("SshAuth", ">> administrator at %s.",fRemote.Data());
                     }
                  }
               }
               delete [] buf;
            }
         }
         SafeDelete(newsock);
         // Receive error message
         if (fSocket->Recv(retval, kind) >= 0) {  // for consistency
            if (kind == kROOTD_ERR)
               AuthError("SshAuth", retval);
         }
      }
      return 0;
   } else if (ssh_rc && sshproto > 0) {
      // Communicate failure
      if (fSocket->Send("0", kROOTD_SSH) < 0)
         Info("SshAuth", "error communicating failure");
      return 0;
   }

   // Communicate success
   if (sshproto > 0) {
      if (fSocket->Send("1", kROOTD_SSH) < 0)
         Info("SshAuth", "error communicating success");
   }

   Int_t nrec = 0;
   // Receive key request info and type of key (if ok, error otherwise)
   if ((nrec = fSocket->Recv(retval, kind)) < 0)  // returns user
      return 0;
   if (gDebug > 3)
      Info("SshAuth", "got message %d, flag: %d", kind, retval);

   // Check if an error occured
   if (kind == kROOTD_ERR) {
      AuthError("SshAuth", retval);
      return 0;
   }

   if (reuse == 1 && sshproto == 0) {

      // Save type of key
      if (kind != kROOTD_RSAKEY  || retval < 1 || retval > 2) {
         Error("SshAuth",
               "problems recvn RSA key flag: got message %d, flag: %d",
               kind, retval);
         return 0;
      }

      fRSAKey = retval - 1;

      // Send the key securely
      if (SendRSAPublicKey(fSocket,fRSAKey) < 0)
         return 0;

      // Receive username used for login
      if ((nrec = fSocket->Recv(retval, kind)) < 0)  // returns user
         return 0;
      if (gDebug > 3)
         Info("SshAuth", "got message %d, flag: %d", kind, retval);
   }

   if (kind != kROOTD_SSH || retval < 1) {
      Warning("SshAuth",
              "problems recvn (user,offset) length (%d:%d bytes:%d)", kind,
              retval, nrec);
      return 0;
   }

   char answer[256];
   reclen = (retval+1 > 256) ? 256 : retval+1;
   if ((nrec = fSocket->Recv(answer, reclen, kind)) < 0)  // returns user
      return 0;
   if (kind != kMESS_STRING)
      Warning("SshAuth", "username and offset not received (%d:%d)", kind,
              nrec);

   // Parse answer
   char lUser[128];
   int offset = -1;
   sscanf(answer, "%127s %d", lUser, &offset);
   if (gDebug > 3)
      Info("SshAuth", "received from server: user: %s, offset: %d", lUser,
           offset);

   // Receive token
   char *token = 0;
   if (reuse == 1 && offset > -1) {
      if (SecureRecv(fSocket, 1, fRSAKey, &token) == -1) {
         Warning("SshAuth", "problems secure-receiving token -"
                 " may result in corrupted token");
         delete [] token;
         return 0;
      }
      if (gDebug > 3)
         Info("SshAuth", "received from server: token: '%s' ", token);
   } else {
      token = StrDup("");
   }

   // Create SecContext object
   fSecContext = fHostAuth->CreateSecContext((const char *)lUser, fRemote,
                                             (Int_t)kSSH, offset, fDetails,
                                             (const char *)token, fgExpDate, 0, fRSAKey);

   // Release allocated memory ...
   if (token) delete [] token;

   // Get and Analyse the reply
   if (fSocket->Recv(retval, kind) < 0)
      return 0;
   if (gDebug > 3)
      Info("SshAuth", "received from server: kind: %d, retval: %d", kind,
           retval);

   if (kind != kROOTD_AUTH) {
      return 0;
   } else {
      return retval;
   }
}

//______________________________________________________________________________
const char *TAuthenticate::GetSshUser(TString user) const
{
   // Method returning the user to be used for the ssh login.
   // Looks first at SSH.Login and finally at env USER.
   // If SSH.LoginPrompt is set to 'yes' it prompts for the 'login name'

   R__LOCKGUARD2(gAuthenticateMutex);

   static TString usr = "";

   if (user == "") {
      if (fgPromptUser) {
         char *p = PromptUser(fRemote);
         usr = p;
         delete [] p;
      } else {
         usr = fgDefaultUser;
         if (usr == "") {
            char *p = PromptUser(fRemote);
            usr = p;
            delete [] p;
         }
      }
   } else {
      usr = user;
   }

   return usr;
}

//______________________________________________________________________________
Bool_t TAuthenticate::CheckHost(const char *host, const char *href)
{
   // Check if 'host' matches 'href':
   // this means either equal or "containing" it, even with wild cards *
   // in the first field (in the case 'href' is a name, ie not IP address)
   // Returns kTRUE if the two matches.

   R__LOCKGUARD2(gAuthenticateMutex);

   Bool_t retval = kTRUE;

   // Both strings should have been defined
   if (!host || !href)
      return kFALSE;

   // 'href' == '*' indicates any 'host' ...
   if (!strcmp(href,"*"))
      return kTRUE;

   // If 'href' contains at a letter or an hyphen it is assumed to be
   // a host name. Otherwise a name.
   // Check also for wild cards
   Bool_t name = kFALSE;
   TRegexp rename("[+a-zA-Z]");
   Int_t len;
   if (rename.Index(href,&len) != -1 || strstr(href,"-"))
      name = kTRUE;

   // Check also for wild cards
   Bool_t wild = kFALSE;
   if (strstr(href,"*"))
      wild = kTRUE;

   // Now build the regular expression for final checking
   TRegexp rehost(href,wild);

   // host to check
   TString theHost(host);
   if (!name) {
      TInetAddress addr = gSystem->GetHostByName(host);
      theHost = addr.GetHostAddress();
      if (gDebug > 2)
         ::Info("TAuthenticate::CheckHost", "checking host IP: %s", theHost.Data());
   }

   // Check 'host' against 'rehost'
   Ssiz_t pos = rehost.Index(theHost,&len);
   if (pos == -1)
      retval = kFALSE;

   // If IP and no wilds, it should match either
   // the beginning or the end of the string
   if (!wild) {
      if (pos > 0 && pos != (Ssiz_t)(theHost.Length()-strlen(href)))
         retval = kFALSE;
   }

   return retval;
}

//______________________________________________________________________________
Int_t TAuthenticate::RfioAuth(TString &username)
{
   // UidGid client authentication code.
   // Returns 0 in case authentication failed
   //         1 in case of success
   //        <0 in case of system error

   if (gDebug > 2)
      Info("RfioAuth", "enter ... username %s", username.Data());

   // Get user info ... ...
   UserGroup_t *pw = gSystem->GetUserInfo(gSystem->GetEffectiveUid());
   if (pw) {

      // These are the details to be saved in case of success ...
      username = pw->fUser;
      fDetails = TString("pt:0 ru:0 us:") + username;

      // Check that we are not root and that the requested user is ourselves
      if (pw->fUid != 0) {

         UserGroup_t *grp = gSystem->GetGroupInfo(gSystem->GetEffectiveGid());

         // Get effective user & group ID associated with the current process...
         Int_t uid = pw->fUid;
         Int_t gid = grp ? grp->fGid : pw->fGid;

         delete grp;

         // Send request ....
         TString sstr = TString::Format("%d %d", uid, gid);
         if (gDebug > 3)
            Info("RfioAuth", "sending ... %s", sstr.Data());
         Int_t ns = 0;
         if ((ns = fSocket->Send(sstr.Data(), kROOTD_RFIO)) < 0)
            return 0;
         if (gDebug > 3)
            Info("RfioAuth", "sent ... %d bytes (expected > %d)", ns,
                 sstr.Length());

         // Get answer
         Int_t stat, kind;
         if (fSocket->Recv(stat, kind) < 0)
            return 0;
         if (gDebug > 3)
            Info("RfioAuth", "after kROOTD_RFIO: kind= %d, stat= %d", kind,
                 stat);

         // Query result ...
         if (kind == kROOTD_AUTH && stat >= 1) {
            // Create inactive SecContext object for use in TSocket
            fSecContext =
               fHostAuth->CreateSecContext((const char *)pw->fUser,
                                           fRemote, kRfio, -stat, fDetails, 0);
            delete pw;
            return 1;
         } else {
            TString server = "sockd";
            if (fProtocol.Contains("root"))
               server = "rootd";
            if (fProtocol.Contains("proof"))
               server = "proofd";

            // Authentication failed
            if (stat == kErrConnectionRefused) {
               if (gDebug > 0)
                  Error("RfioAuth",
                        "%s@%s does not accept connections from %s%s",
                        server.Data(),fRemote.Data(),
                        fUser.Data(),gSystem->HostName());
               delete pw;
               return -2;
            } else if (stat == kErrNotAllowed) {
               if (gDebug > 0)
                  Error("RfioAuth",
                        "%s@%s does not accept %s authentication from %s@%s",
                        server.Data(),fRemote.Data(),
                        TAuthenticate::fgAuthMeth[5].Data(),
                        fUser.Data(),gSystem->HostName());
            } else {
               AuthError("RfioAuth", stat);
            }
            delete pw;
            return 0;
         }
      } else {
         Warning("RfioAuth", "UidGid login as \"root\" not allowed");
         return -1;
      }
   }
   return -1;
}

//______________________________________________________________________________
Int_t TAuthenticate::ClearAuth(TString &user, TString &passwd, Bool_t &pwdhash)
{
   // UsrPwd client authentication code.
   // Returns 0 in case authentication failed
   //         1 in case of success

   R__LOCKGUARD2(gAuthenticateMutex);

   if (gDebug > 2)
      Info("ClearAuth", "enter: user: %s (passwd hashed?: %d)",
           user.Data(),(Int_t)pwdhash);

   Int_t reuse    = fgAuthReUse;
   Int_t prompt   = fgPromptUser;
   Int_t cryptopt = fgUsrPwdCrypt;
   Int_t needsalt = 1;
   if (pwdhash)
      needsalt = 0;
   fDetails = TString::Format("pt:%d ru:%d cp:%d us:",
                              fgPromptUser, fgAuthReUse, fgUsrPwdCrypt) + user;
   if (gDebug > 2)
      Info("ClearAuth", "ru:%d pt:%d cp:%d ns:%d rk:%d",
           fgAuthReUse,fgPromptUser,fgUsrPwdCrypt,needsalt,fgRSAKey);
#ifdef R__WIN32
   needsalt = 0;
#endif
   Int_t stat, kind;

   if (fVersion > 1) {

      //
      // New protocol
      //
      Int_t anon = 0;
      TString salt = "";
      TString pashash = "";

      // Get effective user (fro remote checks in $HOME/.rhosts)
      UserGroup_t *pw = gSystem->GetUserInfo(gSystem->GetEffectiveUid());
      TString effUser;
      if (pw) {
         effUser = TString(pw->fUser);
         delete pw;
      } else
         effUser = user;

      // Create options string
      int opt = (reuse * kAUTH_REUSE_MSK) + (cryptopt * kAUTH_CRYPT_MSK) +
         (needsalt * kAUTH_SSALT_MSK) + (fRSAKey * kAUTH_RSATY_MSK);
      TString options;
      options.Form("%d %ld %s %ld %s", opt,
                   (Long_t)user.Length(), user.Data(),
                   (Long_t)effUser.Length(), effUser.Data());

      // Check established authentications
      kind = kROOTD_USER;
      stat = reuse;
      Int_t rc = 0;
      if ((rc = AuthExists(user, (Int_t) TAuthenticate::kClear, options,
                           &kind, &stat, &StdCheckSecCtx)) == 1) {
         // A valid authentication exists: we are done ...
         return 1;
      }
      if (rc == -2) {
         return rc;
      }
      if (stat == kErrNotAllowed && kind == kROOTD_ERR) {
         return 0;
      }

      if (kind == kROOTD_AUTH && stat == -1) {
         if (gDebug > 3)
            Info("ClearAuth", "anonymous user");
         anon  = 1;
         cryptopt = 0;
         reuse = 0;
         needsalt = 0;
      }

      // The random tag in hex representation
      // Protection against reply attacks
      char ctag[11] = {0};
      if (anon == 0 && cryptopt == 1) {

         // Check that we got the right thing ..
         if (kind != kROOTD_RSAKEY || stat < 1 || stat > 2 ) {
            // Check for errors
            if (kind != kROOTD_ERR) {
               Warning("ClearAuth",
                       "problems recvn RSA key flag: got message %d, flag: %d",
                       kind, stat);
            }
            return 0;
         }
         if (gDebug > 3)
            Info("ClearAuth", "get key request ...");

         // Save type of key
         fRSAKey = stat - 1;

         // Send the key securely
         if (SendRSAPublicKey(fSocket,fRSAKey) < 0)
            return 0;

         int slen = 0;
         if (needsalt) {
            // Receive password salt
            char *tmpsalt = 0;
            if ((slen = SecureRecv(fSocket, 1, fRSAKey, &tmpsalt)) == -1) {
               Warning("ClearAuth", "problems secure-receiving salt -"
                       " may result in corrupted salt");
               Warning("ClearAuth", "switch off reuse for this session");
               needsalt = 0;
               return 0;
            }
            if (slen) {
               // Extract random tag, if there
               if (slen > 9) {
                  int ltmp = slen;
                  while (ltmp && tmpsalt[ltmp-1] != '#') ltmp--;
                  if (ltmp) {
                     if (tmpsalt[ltmp-1] == '#' &&
                         tmpsalt[ltmp-10] == '#') {
                        strlcpy(ctag,&tmpsalt[ltmp-10],11);
                        // We drop the random tag
                        ltmp -= 10;
                        tmpsalt[ltmp] = 0;
                        // Update salt length
                        slen -= 10;
                     }
                  }
                  if (!tmpsalt[0]) {
                     // No salt left
                     needsalt = 0;
                     slen = 0;
                  }
               }
               if (slen)
                  salt = TString(tmpsalt);
               delete [] tmpsalt;
            }
            if (gDebug > 2)
               Info("ClearAuth", "got salt: '%s' (len: %d)", salt.Data(), slen);
         } else {
            if (gDebug > 2)
               Info("ClearAuth", "Salt not required");
            char *tmptag = 0;
            if (SecureRecv(fSocket, 1, fRSAKey, &tmptag) == -1) {
               Warning("ClearAuth", "problems secure-receiving rndmtag -"
                       " may result in corrupted rndmtag");
            }
            if (tmptag) {
               strlcpy(ctag, tmptag, 11);
               delete [] tmptag;
            }
         }
         // We may not have got a salt (if the server may not access it
         // or if it needs the full password, like for AFS ...)
         if (!slen)
            needsalt = 0;
      }
      // Now get the password either from prompt or from memory, if saved already
      if (anon == 1) {

         if (fgPasswd.Contains("@")) {
            // Anonymous like login with user chosen passwd ...
            passwd = fgPasswd;
         } else {
            // Anonymous like login with automatic passwd generation ...
            TString localuser;
            pw = gSystem->GetUserInfo();
            if (pw)
               localuser = StrDup(pw->fUser);
            delete pw;
            static TString localFQDN;
            if (localFQDN == "") {
               TInetAddress addr = gSystem->GetHostByName(gSystem->HostName());
               if (addr.IsValid())
                  localFQDN = addr.GetHostName();
            }
            passwd.Form("%s@%s", localuser.Data(), localFQDN.Data());
            if (gDebug > 2)
               Info("ClearAuth",
                    "automatically generated anonymous passwd: %s",
                    passwd.Data());
         }

      } else {

         if (prompt == 1 || pashash.Length() == 0) {

            if (passwd == "") {
               TString xp;
               xp.Form("%s@%s password: ", user.Data(),fRemote.Data());
               char *pwd = PromptPasswd(xp);
               passwd = TString(pwd);
               delete [] pwd;
               if (passwd == "") {
                  Error("ClearAuth", "password not set");
                  fSocket->Send("-1", kROOTD_PASS);  // Needs this for consistency
                  return 0;
               }
            }
            if (needsalt && !pwdhash) {
#ifndef R__WIN32
               pashash = TString(crypt(passwd, salt));
               if (!pashash.BeginsWith(salt)) {
                  // not the right version of the crypt function:
                  // do not send hash
                  pashash = passwd;
               }
#else
               pashash = passwd;
#endif
            } else {
               pashash = passwd;
            }
         }

      }

      // Store password for later use
      fgUser = fUser;
      fgPwHash = kFALSE;
      fPwHash = kFALSE;
      fgPasswd = passwd;
      fPasswd = passwd;
      fSRPPwd = kFALSE;
      fgSRPPwd = kFALSE;

      // Send it to server
      if (anon == 0 && cryptopt == 1) {

         // Needs to send this for consistency
         if (fSocket->Send("\0", kROOTD_PASS) < 0)
            return 0;

         // Add the random tag received from the server
         // (if any); makes packets non re-usable
         if (strlen(ctag))
            pashash += ctag;

         if (SecureSend(fSocket, 1, fRSAKey, pashash.Data()) == -1) {
            Warning("ClearAuth", "problems secure-sending pass hash"
                    " - may result in authentication failure");
            return 0;
         }
      } else {

         // Standard technique: invert passwd
         if (passwd != "") {
            for (int i = 0; i < passwd.Length(); i++) {
               char inv = ~passwd(i);
               passwd.Replace(i, 1, inv);
            }
         }
         if (fSocket->Send(passwd.Data(), kROOTD_PASS) < 0)
            return 0;
      }

      Int_t nrec = 0;
      // Receive username used for login
      if ((nrec = fSocket->Recv(stat, kind)) < 0 )  // returns user
         return 0;
      if (gDebug > 3)
         Info("ClearAuth", "after kROOTD_PASS: kind= %d, stat= %d", kind,
              stat);

      // Check for errors
      if (kind == kROOTD_ERR) {
         AuthError("ClearAuth", stat);
         fgPasswd = "";
         return 0;
      }

      if (kind != kROOTD_PASS || stat < 1)
         Warning("ClearAuth",
                 "problems recvn (user,offset) length (%d:%d bytes:%d)",
                 kind, stat, nrec);

      // Get user and offset
      char answer[256];
      int reclen = (stat+1 > 256) ? 256 : stat+1;
      if ((nrec = fSocket->Recv(answer, reclen, kind)) < 0)
         return 0;
      if (kind != kMESS_STRING)
         Warning("ClearAuth",
                 "username and offset not received (%d:%d)", kind,
                 nrec);

      // Parse answer
      char lUser[128];
      Int_t offset = -1;
      sscanf(answer, "%127s %d", lUser, &offset);
      if (gDebug > 3)
         Info("ClearAuth",
              "received from server: user: %s, offset: %d (%s)", lUser,
              offset, answer);

      // Return username
      user = lUser;

      char *token = 0;
      if (reuse == 1 && offset > -1) {
         // Receive token
         if (cryptopt == 1) {
            if (SecureRecv(fSocket, 1, fRSAKey, &token) == -1) {
               Warning("ClearAuth",
                       "problems secure-receiving token -"
                       " may result in corrupted token");
               return 0;
            }
         } else {
            Int_t tlen = 9;
            token = new char[tlen];
            if (fSocket->Recv(token, tlen, kind) < 0) {
               delete [] token;
               return 0;
            }
            if (kind != kMESS_STRING)
               Warning("ClearAuth", "token not received (%d:%d)", kind,
                       nrec);
            // Invert token
            for (int i = 0; i < (int) strlen(token); i++) {
               token[i] = ~token[i];
            }

         }
         if (gDebug > 3)
            Info("ClearAuth", "received from server: token: '%s' ",
                 token);
      }
      TPwdCtx *pwdctx = new TPwdCtx(fPasswd,fPwHash);
      // Create SecContext object
      fSecContext = fHostAuth->CreateSecContext((const char *)lUser, fRemote,
                                                kClear, offset, fDetails, (const char *)token,
                                                fgExpDate, (void *)pwdctx, fRSAKey);

      // Release allocated memory ...
      if (token)
         delete [] token;

      // This from remote login
      if (fSocket->Recv(stat, kind) < 0)
         return 0;


      if (kind == kROOTD_AUTH && stat >= 1) {
         if (stat == 5 && fSocket->GetServType() == TSocket::kPROOFD)
            // AFS: we cannot reuse the token because remotely the
            // daemon token must be re-initialized; for PROOF, we
            // just flag the entry as AFS; this allows to skip reusing
            // but to keep the session key for password forwarding
            fSecContext->SetID("AFS authentication");
         return 1;
      } else {
         fgPasswd = "";
         if (kind == kROOTD_ERR)
            AuthError("ClearAuth", stat);
         return 0;
      }

   } else {

      // Old Protocol

      // Send username
      if (fSocket->Send(user.Data(), kROOTD_USER) < 0)
         return 0;

      // Get replay from server
      if (fSocket->Recv(stat, kind) < 0)
         return 0;

      // This check should guarantee backward compatibility with a private
      // version of rootd used by CDF
      if (kind == kROOTD_AUTH && stat == 1) {
         fSecContext =
            fHostAuth->CreateSecContext(user,fRemote,kClear,-1,fDetails,0);
         return 1;
      }

      if (kind == kROOTD_ERR) {
         TString server = "sockd";
         if (fProtocol.Contains("root"))
            server = "rootd";
         if (fProtocol.Contains("proof"))
            server = "proofd";
         if (stat == kErrConnectionRefused) {
            if (gDebug > 0)
               Error("ClearAuth",
                     "%s@%s does not accept connections from %s@%s",
                     server.Data(),fRemote.Data(),
                     fUser.Data(),gSystem->HostName());
            return -2;
         } else if (stat == kErrNotAllowed) {
            if (gDebug > 0)
               Error("ClearAuth",
                     "%s@%s does not accept %s authentication from %s@%s",
                     server.Data(),fRemote.Data(),
                     TAuthenticate::fgAuthMeth[0].Data(),
                     fUser.Data(),gSystem->HostName());
         } else
            AuthError("ClearAuth", stat);
         return 0;
      }
      // Prepare passwd to send
   badpass1:
      if (passwd == "") {
         TString xp;
         xp.Form("%s@%s password: ", user.Data(),fRemote.Data());
         char *p = PromptPasswd(xp);
         passwd = p;
         delete [] p;
         if (passwd == "")
            Error("ClearAuth", "password not set");
      }
      if (fUser == "anonymous" || fUser == "rootd") {
         if (!passwd.Contains("@")) {
            Warning("ClearAuth",
                    "please use passwd of form: user@host.do.main");
            passwd = "";
            goto badpass1;
         }
      }

      fgPasswd = passwd;
      fPasswd = passwd;

      // Invert passwd
      if (passwd != "") {
         for (int i = 0; i < passwd.Length(); i++) {
            char inv = ~passwd(i);
            passwd.Replace(i, 1, inv);
         }
      }
      // Send it over the net
      if (fSocket->Send(passwd, kROOTD_PASS) < 0)
         return 0;

      // Get result of attempt
      if (fSocket->Recv(stat, kind) < 0)  // returns user
         return 0;
      if (gDebug > 3)
         Info("ClearAuth", "after kROOTD_PASS: kind= %d, stat= %d", kind,
              stat);

      if (kind == kROOTD_AUTH && stat == 1) {
         fSecContext =
            fHostAuth->CreateSecContext(user,fRemote,kClear,-1,fDetails,0);
         return 1;
      } else {
         if (kind == kROOTD_ERR)
            AuthError("ClearAuth", stat);
         return 0;
      }
   }
   return 0;
}

//______________________________________________________________________________
THostAuth *TAuthenticate::GetHostAuth(const char *host, const char *user,
                                      Option_t *opt, Int_t *exact)
{
   // Sets fUser=user and search fgAuthInfo for the entry pertaining to
   // (host,user), setting fHostAuth accordingly.
   // If opt = "P" use fgProofAuthInfo list instead
   // If no entry is found fHostAuth is not changed

   if (exact)
      *exact = 0;

   if (gDebug > 2)
      ::Info("TAuthenticate::GetHostAuth", "enter ... %s ... %s", host, user);

   // Strip off the servertype, if any
   Int_t srvtyp = -1;
   TString hostname = host;
   if (hostname.Contains(":")) {
      char *ps = (char *)strstr(host,":");
      if (ps)
         srvtyp = atoi(ps+1);
      hostname.Remove(hostname.Index(":"));
   }
   TString hostFQDN = hostname;
   if (strncmp(host,"default",7) && !hostFQDN.Contains("*")) {
      TInetAddress addr = gSystem->GetHostByName(hostFQDN);
      if (addr.IsValid())
         hostFQDN = addr.GetHostName();
   }
   TString usr = user;
   if (!usr.Length())
      usr = "*";
   THostAuth *rHA = 0;

   // Check list of auth info for already loaded info about this host
   TIter *next = new TIter(GetAuthInfo());
   if (!strncasecmp(opt,"P",1)) {
      SafeDelete(next);
      next = new TIter(GetProofAuthInfo());
   }

   THostAuth *ai;
   Bool_t notFound = kTRUE;
   Bool_t serverOK = kTRUE;
   while ((ai = (THostAuth *) (*next)())) {
      if (gDebug > 3)
         ai->Print("Authenticate::GetHostAuth");

      // server
      if (!(serverOK = (ai->GetServer() == -1) ||
            (ai->GetServer() == srvtyp)))
         continue;

      // Use default entry if existing and nothing more specific is found
      if (!strcmp(ai->GetHost(),"default") && serverOK && notFound)
         rHA = ai;

      // Check
      if (CheckHost(hostFQDN,ai->GetHost()) &&
          CheckHost(usr,ai->GetUser())     && serverOK) {
         rHA = ai;
         notFound = kFALSE;
      }

      if (hostFQDN == ai->GetHost() &&
          usr == ai->GetUser()     && srvtyp == ai->GetServer() ) {
         rHA = ai;
         if (exact)
            *exact = 1;
         break;
      }
   }
   SafeDelete(next);
   return rHA;
}

//______________________________________________________________________________
THostAuth *TAuthenticate::HasHostAuth(const char *host, const char *user,
                                      Option_t *opt)
{
   // Checks if a THostAuth with exact match for {host,user} exists
   // in the fgAuthInfo list
   // If opt = "P" use ProofAuthInfo list instead
   // Returns pointer to it or 0

   if (gDebug > 2)
      ::Info("TAuthenticate::HasHostAuth", "enter ... %s ... %s", host, user);

   // Strip off the servertype, if any
   Int_t srvtyp = -1;
   TString hostFQDN = host;
   if (hostFQDN.Contains(":")) {
      char *ps = (char *)strstr(host,":");
      if (ps)
         srvtyp = atoi(ps+1);
      hostFQDN.Remove(hostFQDN.Index(":"));
   }
   if (strncmp(host,"default",7) && !hostFQDN.Contains("*")) {
      TInetAddress addr = gSystem->GetHostByName(hostFQDN);
      if (addr.IsValid())
         hostFQDN = addr.GetHostName();
   }

   TIter *next = new TIter(GetAuthInfo());
   if (!strncasecmp(opt,"P",1)) {
      SafeDelete(next);
      next = new TIter(GetProofAuthInfo());
   }
   THostAuth *ai;
   while ((ai = (THostAuth *) (*next)())) {

      if (hostFQDN == ai->GetHost() &&
          !strcmp(user, ai->GetUser()) && srvtyp == ai->GetServer()) {
         SafeDelete(next);
         return ai;
      }
   }
   SafeDelete(next);
   return 0;
}

//______________________________________________________________________________
void TAuthenticate::FileExpand(const char *fexp, FILE *ftmp)
{
   // Expands include directives found in fexp files
   // The expanded, temporary file, is pointed to by 'ftmp'
   // and should be already open. To be called recursively.

   FILE *fin;
   char line[kMAXPATHLEN];
   char cinc[20], fileinc[kMAXPATHLEN];

   if (gDebug > 2)
      ::Info("TAuthenticate::FileExpand", "enter ... '%s' ... 0x%lx", fexp, (Long_t)ftmp);

   fin = fopen(fexp, "r");
   if (fin == 0)
      return;

   while (fgets(line, sizeof(line), fin) != 0) {
      // Skip comment lines
      if (line[0] == '#')
         continue;
      if (line[strlen(line) - 1] == '\n')
         line[strlen(line) - 1] = '\0';
      if (gDebug > 2)
         ::Info("TAuthenticate::FileExpand", "read line ... '%s'", line);
      int nw = sscanf(line, "%19s %8191s", cinc, fileinc);
      if (nw < 1)
         continue;              // Not enough info in this line
      if (strcmp(cinc, "include") != 0) {
         // copy line in temporary file
         fprintf(ftmp, "%s\n", line);
      } else {

         // Drop quotes or double quotes, if any
         TString ln(line);
         ln.ReplaceAll("\"",1,"",0);
         ln.ReplaceAll("'",1,"",0);
         sscanf(ln.Data(), "%19s %8191s", cinc, fileinc);

         // support environment directories ...
         if (fileinc[0] == '$') {
            TString finc(fileinc);
            TString edir(fileinc);
            if (edir.Contains("/")) {
               edir.Remove(edir.Index("/"));
               edir.Remove(0,1);
               if (gSystem->Getenv(edir.Data())) {
                  finc.Remove(0,1);
                  finc.ReplaceAll(edir.Data(),gSystem->Getenv(edir.Data()));
                  fileinc[0] = '\0';
                  strncpy(fileinc,finc.Data(),kMAXPATHLEN);
                  fileinc[kMAXPATHLEN-1] = '\0';
               }
            }
         }

         // open (expand) file in temporary file ...
         if (fileinc[0] == '~') {
            // needs to expand
            int flen =
               strlen(fileinc) + strlen(gSystem->HomeDirectory()) + 10;
            char *ffull = new char[flen];
            snprintf(ffull, flen, "%s/%s", gSystem->HomeDirectory(), fileinc + 1);
            if (strlen(ffull) < kMAXPATHLEN - 1) strlcpy(fileinc, ffull,kMAXPATHLEN);
            delete [] ffull;
         }
         // Check if file exist and can be read ... ignore if not ...
         if (!gSystem->AccessPathName(fileinc, kReadPermission)) {
            FileExpand(fileinc, ftmp);
         } else {
            ::Warning("TAuthenticate::FileExpand",
                      "file specified by 'include' cannot be open or read (%s)",
                      fileinc);
         }
      }
   }
   fclose(fin);
}

//______________________________________________________________________________
char *TAuthenticate::GetDefaultDetails(int sec, int opt, const char *usr)
{
   // Determine default authentication details for method 'sec' and user 'usr'.
   // Checks .rootrc family files. Returned string must be deleted by the user.

   char temp[kMAXPATHLEN] = { 0 };
   const char copt[2][5] = { "no", "yes" };

   if (gDebug > 2)
      ::Info("TAuthenticate::GetDefaultDetails",
             "enter ... %d ...pt:%d ... '%s'", sec, opt, usr);

   if (opt < 0 || opt > 1)
      opt = 1;

   // UsrPwd
   if (sec == TAuthenticate::kClear) {
      if (!usr[0] || !strncmp(usr,"*",1))
         usr = gEnv->GetValue("UsrPwd.Login", "");
      snprintf(temp, kMAXPATHLEN, "pt:%s ru:%s cp:%s us:%s",
               gEnv->GetValue("UsrPwd.LoginPrompt", copt[opt]),
               gEnv->GetValue("UsrPwd.ReUse", "1"),
               gEnv->GetValue("UsrPwd.Crypt", "1"), usr);

      // SRP
   } else if (sec == TAuthenticate::kSRP) {
      if (!usr[0] || !strncmp(usr,"*",1))
         usr = gEnv->GetValue("SRP.Login", "");
      snprintf(temp, kMAXPATHLEN, "pt:%s ru:%s us:%s",
               gEnv->GetValue("SRP.LoginPrompt", copt[opt]),
               gEnv->GetValue("SRP.ReUse", "0"), usr);

      // Kerberos
   } else if (sec == TAuthenticate::kKrb5) {
      if (!usr[0] || !strncmp(usr,"*",1))
         usr = gEnv->GetValue("Krb5.Login", "");
      snprintf(temp, kMAXPATHLEN, "pt:%s ru:%s us:%s",
               gEnv->GetValue("Krb5.LoginPrompt", copt[opt]),
               gEnv->GetValue("Krb5.ReUse", "0"), usr);

      // Globus
   } else if (sec == TAuthenticate::kGlobus) {
      snprintf(temp, kMAXPATHLEN,"pt:%s ru:%s %s",
               gEnv->GetValue("Globus.LoginPrompt", copt[opt]),
               gEnv->GetValue("Globus.ReUse", "1"),
               gEnv->GetValue("Globus.Login", ""));

      // SSH
   } else if (sec == TAuthenticate::kSSH) {
      if (!usr[0] || !strncmp(usr,"*",1))
         usr = gEnv->GetValue("SSH.Login", "");
      snprintf(temp, kMAXPATHLEN, "pt:%s ru:%s us:%s",
               gEnv->GetValue("SSH.LoginPrompt", copt[opt]),
               gEnv->GetValue("SSH.ReUse", "1"), usr);

      // Uid/Gid
   } else if (sec == TAuthenticate::kRfio) {
      if (!usr[0] || !strncmp(usr,"*",1))
         usr = gEnv->GetValue("UidGid.Login", "");
      snprintf(temp, kMAXPATHLEN, "pt:%s us:%s",
               gEnv->GetValue("UidGid.LoginPrompt", copt[opt]), usr);
   }
   if (gDebug > 2)
      ::Info("TAuthenticate::GetDefaultDetails", "returning ... %s", temp);

   return StrDup(temp);
}

//______________________________________________________________________________
void TAuthenticate::RemoveHostAuth(THostAuth * ha, Option_t *opt)
{
   // Remove THostAuth instance from the list

   if (!strncasecmp(opt,"P",1))
      GetProofAuthInfo()->Remove(ha);
   else
      GetAuthInfo()->Remove(ha);
   // ... destroy it
   delete ha;
}

//______________________________________________________________________________
void TAuthenticate::Show(Option_t *opt)
{
   // Print info about the authentication sector.
   // If 'opt' contains 's' or 'S' prints information about established TSecContext,
   // else prints information about THostAuth (if 'opt' is 'p' or 'P', prints
   // Proof related information)

   TString sopt(opt);

   if (sopt.Contains("s",TString::kIgnoreCase)) {

      // Print established security contexts
      TIter next(gROOT->GetListOfSecContexts());
      TSecContext *sc = 0;
      while ((sc = (TSecContext *)next()))
         sc->Print();

   } else {

      ::Info("::Print",
             " +--------------------------- BEGIN --------------------------------+");
      ::Info("::Print",
             " +                                                                  +");
      if (sopt.Contains("p",TString::kIgnoreCase)) {
         ::Info("::Print",
                " + List fgProofAuthInfo has %4d members                            +",
                GetProofAuthInfo()->GetSize());
         ::Info("::Print",
                " +                                                                  +");
         ::Info("::Print",
                " +------------------------------------------------------------------+");
         TIter next(GetProofAuthInfo());
         THostAuth *ai;
         while ((ai = (THostAuth *) next())) {
            ai->Print();
         }
      } else {
         ::Info("::Print",
                " + List fgAuthInfo has %4d members                                 +",
                GetAuthInfo()->GetSize());
         ::Info("::Print",
                " +                                                                  +");
         ::Info("::Print",
                " +------------------------------------------------------------------+");
         TIter next(GetAuthInfo());
         THostAuth *ai;
         while ((ai = (THostAuth *) next())) {
            ai->Print();
            ai->PrintEstablished();
         }
      }
      ::Info("::Print",
             " +---------------------------- END ---------------------------------+");
   }
}

//______________________________________________________________________________
Int_t TAuthenticate::AuthExists(TString username, Int_t method, const char *options,
                                Int_t *message, Int_t *rflag,
                                CheckSecCtx_t checksecctx)
{
   // Check if we have a valid established sec context in memory
   // Retrieves relevant info and negotiates with server.
   // options = "Opt,strlen(username),username.Data()"
   // message = kROOTD_USER, ...

   // Welcome message, if requested ...
   if (gDebug > 2)
      Info("AuthExists","%d: enter: msg: %d options: '%s'",
           method,*message, options);

   // Look for an existing security context matching this request
   Bool_t notHA = kFALSE;

   // First in the local list
   TIter next(fHostAuth->Established());
   TRootSecContext *secctx;
   while ((secctx = (TRootSecContext *)next())) {
      if (secctx->GetMethod() == method) {
         if (fRemote == secctx->GetHost()) {
            if (checksecctx &&
                (*checksecctx)(username,secctx) == 1)
               break;
         }
      }
   }

   // If nothing found, try the all list
   if (!secctx) {
      next = TIter(gROOT->GetListOfSecContexts());
      while ((secctx = (TRootSecContext *)next())) {
         if (secctx->GetMethod() == method) {
            if (fRemote == secctx->GetHost()) {
               if (checksecctx &&
                   (*checksecctx)(username,secctx) == 1) {
                  notHA = kTRUE;
                  break;
               }
            }
         }
      }
   }

   // If we have been given a valid sec context retrieve some info
   Int_t offset = -1;
   TString token;
   if (secctx) {
      offset = secctx->GetOffSet();
      token = secctx->GetToken();
      if (gDebug > 2)
         Info("AuthExists",
              "found valid TSecContext: offset: %d token: '%s'",
              offset, token.Data());
   }

   // Prepare string to be sent to the server
   TString sstr;
   sstr.Form("%d %d %s", fgProcessID, offset, options);

   // Send message
   if (fSocket->Send(sstr, *message) < 0)
      return -2;

   Int_t reuse = *rflag;
   if (reuse == 1 && offset > -1) {

      // Receive result of checking offset
      // But only for recent servers
      // NB: not backward compatible with dev version 4.00.02: switch
      // off 'reuse' for such servers to avoid hanging at this point.
      Int_t rproto = fSocket->GetRemoteProtocol();
      Bool_t oldsrv = ((fProtocol.BeginsWith("root") && rproto == 9) ||
                       (fProtocol.BeginsWith("proof") && rproto == 8));
      Int_t stat = 1, kind;
      if (!oldsrv) {
         if (fSocket->Recv(stat, kind) < 0)
            return -2;
         if (kind != kROOTD_AUTH)
            Warning("AuthExists","protocol error: expecting %d got %d"
                    " (value: %d)",kROOTD_AUTH,kind,stat);
      }

      if (stat > 0) {
         if (gDebug > 2)
            Info("AuthExists","offset OK");

         Int_t rsaKey = secctx->GetRSAKey();
         if (gDebug > 2)
            Info("AuthExists", "key type: %d", rsaKey);

         if (rsaKey > -1) {

            // Recent servers send a random tag in stat
            // It has to be signed too
            if (stat > 1) {
               // Create hex from tag
               char tag[9] = {0};
               snprintf(tag, 9, "%08x",stat);
               // Add to token
               token += tag;
            }

            // Send token encrypted
            if (SecureSend(fSocket, 1, rsaKey, token) == -1) {
               Warning("AuthExists", "problems secure-sending token %s",
                       "- may trigger problems in proofing Id ");
               return -2;
            }
         } else {
            // Send inverted
            for (int i = 0; i < token.Length(); i++) {
               char inv = ~token(i);
               token.Replace(i, 1, inv);
            }
            if (fSocket->Send(token, kMESS_STRING) < 0)
               return -2;
         }
      } else {
         if (gDebug > 0)
            Info("AuthExists","offset not OK - rerun authentication");
         // If the sec context was not valid, deactivate it ...
         if (secctx)
            secctx->DeActivate("");
      }
   }

   Int_t stat, kind;
   if (fSocket->Recv(stat, kind) < 0)
      return -2;
   if (gDebug > 3)
      Info("AuthExists","%d: after msg %d: kind= %d, stat= %d",
           method,*message, kind, stat);

   // Return flags
   *message = kind;
   *rflag = stat;

   if (kind == kROOTD_ERR) {
      TString server = "sockd";
      if (fSocket->GetServType() == TSocket::kROOTD)
         server = "rootd";
      if (fSocket->GetServType() == TSocket::kPROOFD)
         server = "proofd";
      if (stat == kErrConnectionRefused) {
         Error("AuthExists","%s@%s does not accept connections from %s@%s",
               server.Data(),fRemote.Data(),fUser.Data(),gSystem->HostName());
         return -2;
      } else if (stat == kErrNotAllowed) {
         if (gDebug > 0)
            Info("AuthExists",
                 "%s@%s does not accept %s authentication from %s@%s",
                 server.Data(),fRemote.Data(), fgAuthMeth[method].Data(),
                 fUser.Data(),gSystem->HostName());
      } else
         AuthError("AuthExists", stat);

      // If the sec context was not valid, deactivate it ...
      if (secctx)
         secctx->DeActivate("");
      return 0;
   }

   if (kind == kROOTD_AUTH && stat >= 1) {
      if (!secctx)
         secctx =
            fHostAuth->CreateSecContext(fUser,fRemote,method,-stat,fDetails,0);
      if (gDebug > 3) {
         if (stat == 1)
            Info("AuthExists", "valid authentication exists");
         if (stat == 2)
            Info("AuthExists", "valid authentication exists: offset changed");
         if (stat == 3)
            Info("AuthExists", "remote access authorized by /etc/hosts.equiv");
         if (stat == 4)
            Info("AuthExists", "no authentication required remotely");
      }

      if (stat == 2) {
         int newOffSet;
         // Receive new offset ...
         if (fSocket->Recv(newOffSet, kind) < 0)
            return -2;
         // ... and save it
         secctx->SetOffSet(newOffSet);
      }

      fSecContext = secctx;
      // Add it to local list for later use (if not already there)
      if (notHA)
         fHostAuth->Established()->Add(secctx);
      return 1;
   }
   return 0;
}

//______________________________________________________________________________
void TAuthenticate::InitRandom()
{
   // Initialize random machine using seed from /dev/urandom
   // (or current time if /dev/urandom not available).

   static Bool_t notinit = kTRUE;

   if (notinit) {
      const char *randdev = "/dev/urandom";
      Int_t fd;
      UInt_t seed;
      if ((fd = open(randdev, O_RDONLY)) != -1) {
         if (gDebug > 2)
            ::Info("InitRandom", "taking seed from %s", randdev);
         if (read(fd, &seed, sizeof(seed)) != sizeof(seed))
            ::Warning("InitRandom", "could not read seed from %s", randdev);
         close(fd);
      } else {
         if (gDebug > 2)
            ::Info("InitRandom", "%s not available: using time()", randdev);
         seed = time(0);   //better use times() + win32 equivalent
      }
      srand(seed);
      notinit = kFALSE;
   }
}

//______________________________________________________________________________
Int_t TAuthenticate::GenRSAKeys()
{
   // Generate a valid pair of private/public RSA keys to protect for
   // authentication token exchange

   if (gDebug > 2)
      Info("GenRSAKeys", "enter");

   if (fgRSAInit == 1) {
      if (gDebug > 2)
         Info("GenRSAKeys", "Keys prviously generated - return");
   }

   // This is for dynamic loads ...
   TString lib = "libRsa";

   // This is the local RSA implementation
   if (!TRSA_fun::RSA_genprim()) {
      char *p;
      if ((p = gSystem->DynamicPathName(lib, kTRUE))) {
         delete [] p;
         gSystem->Load(lib);
      }
   }

   // Init random machine
   TAuthenticate::InitRandom();

#ifdef R__SSL
   if (fgRSAKey == 1) {
      // Generate also the SSL key
      if (gDebug > 2)
         Info("GenRSAKeys","SSL: Generate Blowfish key");

      // Init SSL ...
      SSL_library_init();

      //  ... and its error strings
      SSL_load_error_strings();

      // Load Ciphers
      OpenSSL_add_all_ciphers();

      // Number of bits for key
      Int_t nbits = gEnv->GetValue("SSL.BFBits",256);

      // Minimum is 128
      nbits = (nbits >= 128) ? nbits : 128;

      // Max to limit size of buffers to 15912 (internal limitation)
      nbits = (nbits <= 15912) ? nbits : 15912;

      // Closer Number of chars
      Int_t klen = nbits / 8 ;

      // Init random engine
      char *rbuf = GetRandString(0,klen);
      RAND_seed(rbuf,strlen(rbuf));

      // This is what we export
      fgRSAPubExport[1].len = klen;
      fgRSAPubExport[1].keys = rbuf;
      if (gDebug > 2)
         Info("GenRSAKeys","SSL: BF key length: %d", fgRSAPubExport[1].len);

      // Now set the key locally in BF form
      BF_set_key(&fgBFKey, klen, (const unsigned char *)rbuf);
   }
#endif

   // Sometimes some bunch is not decrypted correctly
   // That's why we make retries to make sure that encryption/decryption
   // works as expected
   Bool_t notOk = 1;
   rsa_NUMBER p1, p2, rsa_n, rsa_e, rsa_d;
   Int_t l_n = 0, l_d = 0;
   char buf_n[rsa_STRLEN], buf_e[rsa_STRLEN], buf_d[rsa_STRLEN];
#if R__RSADE
   Int_t l_e;
   char buf[rsa_STRLEN];
#endif

   Int_t nAttempts = 0;
   Int_t thePrimeLen = kPRIMELENGTH;
   Int_t thePrimeExp = kPRIMEEXP;   // Prime probability = 1-0.5^thePrimeExp
   while (notOk && nAttempts < kMAXRSATRIES) {

      nAttempts++;
      if (gDebug > 2 && nAttempts > 1) {
         Info("GenRSAKeys", "retry no. %d",nAttempts);
         srand(auth_rand());
      }

      // Valid pair of primes
      p1 = TRSA_fun::RSA_genprim()(thePrimeLen, thePrimeExp);
      p2 = TRSA_fun::RSA_genprim()(thePrimeLen+1, thePrimeExp);

      // Retry if equal
      Int_t nPrimes = 0;
      while (TRSA_fun::RSA_cmp()(&p1, &p2) == 0 && nPrimes < kMAXRSATRIES) {
         nPrimes++;
         if (gDebug > 2)
            Info("GenRSAKeys", "equal primes: regenerate (%d times)",nPrimes);
         srand(auth_rand());
         p1 = TRSA_fun::RSA_genprim()(thePrimeLen, thePrimeExp);
         p2 = TRSA_fun::RSA_genprim()(thePrimeLen+1, thePrimeExp);
      }
#if R__RSADEB
      if (gDebug > 3) {
         TRSA_fun::RSA_num_sput()(&p1, buf, rsa_STRLEN);
         Info("GenRSAKeys", "local: p1: '%s' ", buf);
         TRSA_fun::RSA_num_sput()(&p2, buf, rsa_STRLEN);
         Info("GenRSAKeys", "local: p2: '%s' ", buf);
      }
#endif
      // Generate keys
      if (TRSA_fun::RSA_genrsa()(p1, p2, &rsa_n, &rsa_e, &rsa_d)) {
         if (gDebug > 2 && nAttempts > 1)
            Info("GenRSAKeys"," genrsa: unable to generate keys (%d)",
                 nAttempts);
         continue;
      }

      // Get equivalent strings and determine their lengths
      TRSA_fun::RSA_num_sput()(&rsa_n, buf_n, rsa_STRLEN);
      l_n = strlen(buf_n);
      TRSA_fun::RSA_num_sput()(&rsa_e, buf_e, rsa_STRLEN);
#if R__RSADEB
      l_e = strlen(buf_e);
#endif
      TRSA_fun::RSA_num_sput()(&rsa_d, buf_d, rsa_STRLEN);
      l_d = strlen(buf_d);

#if R__RSADEB
      if (gDebug > 3) {
         Info("GenRSAKeys", "local: n: '%s' length: %d", buf_n, l_n);
         Info("GenRSAKeys", "local: e: '%s' length: %d", buf_e, l_e);
         Info("GenRSAKeys", "local: d: '%s' length: %d", buf_d, l_d);
      }
#endif
      if (TRSA_fun::RSA_cmp()(&rsa_n, &rsa_e) <= 0)
         continue;
      if (TRSA_fun::RSA_cmp()(&rsa_n, &rsa_d) <= 0)
         continue;

      // Now we try the keys
      char test[2 * rsa_STRLEN] = "ThisIsTheStringTest01203456-+/";
      Int_t lTes = 31;
      char *tdum = GetRandString(0, lTes - 1);
      strlcpy(test, tdum, lTes+1);
      delete [] tdum;
      char buf[2 * rsa_STRLEN];
      if (gDebug > 3)
         Info("GenRSAKeys", "local: test string: '%s' ", test);

      // Private/Public
      strlcpy(buf, test, lTes+1);

      // Try encryption with private key
      int lout = TRSA_fun::RSA_encode()(buf, lTes, rsa_n, rsa_e);
      if (gDebug > 3)
         Info("GenRSAKeys",
              "local: length of crypted string: %d bytes", lout);

      // Try decryption with public key
      TRSA_fun::RSA_decode()(buf, lout, rsa_n, rsa_d);
      buf[lTes] = 0;
      if (gDebug > 3)
         Info("GenRSAKeys", "local: after private/public : '%s' ", buf);

      if (strncmp(test, buf, lTes))
         continue;

      // Public/Private
      strlcpy(buf, test, lTes+1);

      // Try encryption with public key
      lout = TRSA_fun::RSA_encode()(buf, lTes, rsa_n, rsa_d);
      if (gDebug > 3)
         Info("GenRSAKeys", "local: length of crypted string: %d bytes ",
              lout);

      // Try decryption with private key
      TRSA_fun::RSA_decode()(buf, lout, rsa_n, rsa_e);
      buf[lTes] = 0;
      if (gDebug > 3)
         Info("GenRSAKeys", "local: after public/private : '%s' ", buf);

      if (strncmp(test, buf, lTes))
         continue;

      notOk = 0;
   }

   // Save Private key
   TRSA_fun::RSA_assign()(&fgRSAPriKey.n, &rsa_n);
   TRSA_fun::RSA_assign()(&fgRSAPriKey.e, &rsa_e);

   // Save Public key
   TRSA_fun::RSA_assign()(&fgRSAPubKey.n, &rsa_n);
   TRSA_fun::RSA_assign()(&fgRSAPubKey.e, &rsa_d);

#if R__RSADEB
   if (gDebug > 2) {
      // Determine their lengths
      Info("GenRSAKeys", "local: generated keys are:");
      Info("GenRSAKeys", "local: n: '%s' length: %d", buf_n, l_n);
      Info("GenRSAKeys", "local: e: '%s' length: %d", buf_e, l_e);
      Info("GenRSAKeys", "local: d: '%s' length: %d", buf_d, l_d);
   }
#endif
   // Export form
   if (fgRSAPubExport[0].keys) {
      delete [] fgRSAPubExport[0].keys;
      fgRSAPubExport[0].len = 0;
   }
   fgRSAPubExport[0].len = l_n + l_d + 4;
   fgRSAPubExport[0].keys = new char[fgRSAPubExport[0].len];

   fgRSAPubExport[0].keys[0] = '#';
   memcpy(fgRSAPubExport[0].keys + 1, buf_n, l_n);
   fgRSAPubExport[0].keys[l_n + 1] = '#';
   memcpy(fgRSAPubExport[0].keys + l_n + 2, buf_d, l_d);
   fgRSAPubExport[0].keys[l_n + l_d + 2] = '#';
   fgRSAPubExport[0].keys[l_n + l_d + 3] = 0;
#if R__RSADEB
   if (gDebug > 2)
      Info("GenRSAKeys", "local: export pub: '%s'", fgRSAPubExport[0].keys);
#else
   if (gDebug > 2)
      Info("GenRSAKeys", "local: export pub length: %d bytes", fgRSAPubExport[0].len);
#endif

   // Set availability flag
   fgRSAInit = 1;

   return 0;
}

//______________________________________________________________________________
char *TAuthenticate::GetRandString(Int_t opt, Int_t len)
{
   // Allocates and fills a 0 terminated buffer of length len+1 with
   // len random characters.
   // Returns pointer to the buffer (to be deleted by the caller)
   // opt = 0      any non dangerous char
   //       1      letters and numbers  (upper and lower case)
   //       2      hex characters       (upper and lower case)

   unsigned int iimx[4][4] = {
      {0x0, 0xffffff08, 0xafffffff, 0x2ffffffe}, // opt = 0
      {0x0, 0x3ff0000, 0x7fffffe, 0x7fffffe},    // opt = 1
      {0x0, 0x3ff0000, 0x7e, 0x7e},              // opt = 2
      {0x0, 0x3ffc000, 0x7fffffe, 0x7fffffe}     // opt = 3
   };

   const char *cOpt[4] = { "Any", "LetNum", "Hex", "Crypt" };

   //  Default option 0
   if (opt < 0 || opt > 2) {
      opt = 0;
      if (gDebug > 2)
         Info("GetRandString", "unknown option: %d : assume 0", opt);
   }
   if (gDebug > 2)
      Info("GetRandString", "enter ... len: %d %s", len, cOpt[opt]);

   // Allocate buffer
   char *buf = new char[len + 1];

   // Init random machine (if needed)
   TAuthenticate::InitRandom();

   // randomize
   Int_t k = 0;
   Int_t i, j, l, m, frnd;
   while (k < len) {
      frnd = auth_rand();
      for (m = 7; m < 32; m += 7) {
         i = 0x7F & (frnd >> m);
         j = i / 32;
         l = i - j * 32;
         if ((iimx[opt][j] & (1 << l))) {
            buf[k] = i;
            k++;
         }
         if (k == len)
            break;
      }
   }

   // null terminated
   buf[len] = 0;
   if (gDebug > 3)
      Info("GetRandString", "got '%s' ", buf);

   return buf;
}

//______________________________________________________________________________
Int_t TAuthenticate::SecureSend(TSocket *sock, Int_t enc,
                                Int_t key, const char *str)
{
   // Encode null terminated str using the session private key indicated by enc
   // and sends it over the network
   // Returns number of bytes sent, or -1 in case of error.
   // enc = 1 for private encoding, enc = 2 for public encoding

   char buftmp[kMAXSECBUF];
   char buflen[20];

   if (gDebug > 2)
      ::Info("TAuthenticate::SecureSend", "local: enter ... (enc: %d)", enc);

   Int_t slen = strlen(str) + 1;
   Int_t ttmp = 0;
   Int_t nsen = -1;

   if (key == 0) {
      strlcpy(buftmp, str, slen+1);

      if (enc == 1)
         ttmp = TRSA_fun::RSA_encode()(buftmp, slen, fgRSAPriKey.n,
                                       fgRSAPriKey.e);
      else if (enc == 2)
         ttmp = TRSA_fun::RSA_encode()(buftmp, slen, fgRSAPubKey.n,
                                       fgRSAPubKey.e);
      else
         return nsen;
   } else if (key == 1) {

#ifdef R__SSL
      ttmp = strlen(str);
      if ((ttmp % 8) > 0)           // It should be a multiple of 8!
         ttmp = ((ttmp + 8)/8) * 8;
      unsigned char iv[8];
      memset((void *)&iv[0],0,8);
      BF_cbc_encrypt((const unsigned char *)str, (unsigned char *)buftmp,
                     strlen(str), &fgBFKey, iv, BF_ENCRYPT);
#else
      if (gDebug > 0)
         ::Info("TAuthenticate::SecureSend","not compiled with SSL support:"
                " you should not have got here!");
#endif
   } else {
      if (gDebug > 0)
         ::Info("TAuthenticate::SecureSend","unknown key type (%d)",key);
      return nsen;
   }

   snprintf(buflen,20,"%d",ttmp);
   if (sock->Send(buflen, kROOTD_ENCRYPT) < 0)
      return -1;
   nsen = sock->SendRaw(buftmp, ttmp);
   if (gDebug > 3)
      ::Info("TAuthenticate::SecureSend",
             "local: sent %d bytes (expected: %d)", nsen,ttmp);

   return nsen;
}

//______________________________________________________________________________
Int_t TAuthenticate::SecureRecv(TSocket *sock, Int_t dec, Int_t key, char **str)
{
   // Receive str from sock and decode it using key indicated by key type
   // Return number of received bytes or -1 in case of error.
   // dec = 1 for private decoding, dec = 2 for public decoding


   char buftmp[kMAXSECBUF];
   char buflen[20];

   Int_t nrec = -1;
   // We must get a pointer ...
   if (!str)
      return nrec;

   Int_t kind;
   if (sock->Recv(buflen, 20, kind) < 0)
      return -1;
   Int_t len = atoi(buflen);
   if (gDebug > 3)
      ::Info("TAuthenticate::SecureRecv", "got len '%s' %d (msg kind: %d)",
             buflen, len, kind);
   if (len == 0) {
      return len;
   }
   if (!strncmp(buflen, "-1", 2))
      return nrec;

   // Receive buffer
   if ((nrec = sock->RecvRaw(buftmp, len)) < 0)
      return nrec;
   if (key == 0) {
      if (dec == 1)
         TRSA_fun::RSA_decode()(buftmp, len, fgRSAPriKey.n, fgRSAPriKey.e);
      else if (dec == 2)
         TRSA_fun::RSA_decode()(buftmp, len, fgRSAPubKey.n, fgRSAPubKey.e);
      else
         return -1;

      // Prepare output
      const size_t strSize = strlen(buftmp) + 1;
      *str = new char[strSize];
      strlcpy(*str, buftmp, strSize);

   } else if (key == 1) {
#ifdef R__SSL
      unsigned char iv[8];
      memset((void *)&iv[0],0,8);
      *str = new char[nrec + 1];
      BF_cbc_encrypt((const unsigned char *)buftmp, (unsigned char *)(*str),
                     nrec, &fgBFKey, iv, BF_DECRYPT);
      (*str)[nrec] = '\0';
#else
      if (gDebug > 0)
         ::Info("TAuthenticate::SecureRecv","not compiled with SSL support:"
                " you should not have got here!");
#endif
   } else {
      if (gDebug > 0)
         ::Info("TAuthenticate::SecureRecv","unknown key type (%d)",key);
      return -1;
   }

   nrec= strlen(*str);

   return nrec;
}

//______________________________________________________________________________
Int_t TAuthenticate::DecodeRSAPublic(const char *rsaPubExport, rsa_NUMBER &rsa_n,
                                     rsa_NUMBER &rsa_d, char **rsassl)
{
   // Store RSA public keys from export string rsaPubExport.

   if (!rsaPubExport)
      return -1;

   if (gDebug > 2)
      ::Info("TAuthenticate::DecodeRSAPublic",
             "enter: string length: %ld bytes", (Long_t)strlen(rsaPubExport));

   char str[kMAXPATHLEN] = { 0 };
   Int_t klen = strlen(rsaPubExport);
   if (klen > kMAXPATHLEN - 1) {
      ::Info("TAuthenticate::DecodeRSAPublic",
             "key too long (%d): truncate to %d",klen,kMAXPATHLEN);
      klen = kMAXPATHLEN - 1;
   }
   memcpy(str, rsaPubExport, klen);
   str[klen] ='\0';

   Int_t keytype = -1;

   if (klen > 0) {

      // Skip spaces at beginning, if any
      int k = 0;
      while (str[k] == 32) k++;

      if (str[k] == '#') {

         keytype = 0;

         // The format is #<hex_n>#<hex_d>#
         char *pd1 = strstr(str, "#");
         char *pd2 = pd1 ? strstr(pd1 + 1, "#") : (char *)0;
         char *pd3 = pd2 ? strstr(pd2 + 1, "#") : (char *)0;
         if (pd1 && pd2 && pd3) {
            // Get <hex_n> ...
            int l1 = (int) (pd2 - pd1 - 1);
            char *rsa_n_exp = new char[l1 + 1];
            strlcpy(rsa_n_exp, pd1 + 1, l1+1);
            if (gDebug > 2)
               ::Info("TAuthenticate::DecodeRSAPublic",
                      "got %ld bytes for rsa_n_exp", (Long_t)strlen(rsa_n_exp));
            // Now <hex_d>
            int l2 = (int) (pd3 - pd2 - 1);
            char *rsa_d_exp = new char[l2 + 1];
            strlcpy(rsa_d_exp, pd2 + 1, 13);
            if (gDebug > 2)
               ::Info("TAuthenticate::DecodeRSAPublic",
                      "got %ld bytes for rsa_d_exp", (Long_t)strlen(rsa_d_exp));

            TRSA_fun::RSA_num_sget()(&rsa_n, rsa_n_exp);
            TRSA_fun::RSA_num_sget()(&rsa_d, rsa_d_exp);

            if (rsa_n_exp)
               if (rsa_n_exp) delete[] rsa_n_exp;
            if (rsa_d_exp)
               if (rsa_d_exp) delete[] rsa_d_exp;

         } else
            ::Info("TAuthenticate::DecodeRSAPublic","bad format for input string");
#ifdef R__SSL
      } else {
         // try SSL
         keytype = 1;

         RSA *rsatmp;

         // Bio for exporting the pub key
         BIO *bpub = BIO_new(BIO_s_mem());

         // Write key from kbuf to BIO
         BIO_write(bpub,(void *)str,strlen(str));

         // Read pub key from BIO
         if (!(rsatmp = PEM_read_bio_RSAPublicKey(bpub, 0, 0, 0))) {
            if (gDebug > 0)
               ::Info("TAuthenticate::DecodeRSAPublic",
                        "unable to read pub key from bio");
         } else
            if (rsassl)
               *rsassl = (char *)rsatmp;
            else
               ::Info("TAuthenticate::DecodeRSAPublic",
                        "no space allocated for output variable");
         BIO_free(bpub);
      }
#else
      } else {
         if (rsassl) { }   // To avoid compiler complains
         if (gDebug > 0)
            ::Info("TAuthenticate::DecodeRSAPublic","not compiled with SSL support:"
                   " you should not have got here!");
      }
#endif
   }

   return keytype;
}

//______________________________________________________________________________
Int_t TAuthenticate::SetRSAPublic(const char *rsaPubExport, Int_t klen)
{
   // Store RSA public keys from export string rsaPubExport.
   // Returns type of stored key, or -1 is not recognized

   if (gDebug > 2)
      ::Info("TAuthenticate::SetRSAPublic",
             "enter: string length %ld bytes", (Long_t)strlen(rsaPubExport));

   Int_t rsakey = -1;
   if (!rsaPubExport)
      return rsakey;

   if (klen > 0) {

      // Skip spaces at beginning, if any
      int k0 = 0;
      while (rsaPubExport[k0] == 32) k0++;
      int k2 = klen - 1;

      // Parse rsaPubExport
      // Type 0 is in the form
      //
      //   #< gt 10 exa chars >#< gt 10 exa chars >#
      //
      rsakey = 1;
      if (rsaPubExport[k0] == '#' && rsaPubExport[k2] == '#') {
         char *p0 = (char *)&rsaPubExport[k0];
         char *p2 = (char *)&rsaPubExport[k2];
         char *p1 = strchr(p0+1,'#');
         if (p1 > p0 && p1 < p2) {
            Int_t l01 = (Int_t)(p1-p0)-1;
            Int_t l12 = (Int_t)(p2-p1)-1;
            if (l01 >= kPRIMELENGTH*2 && l12 >= kPRIMELENGTH*2) {
               // Require exadecimal chars in between
               char *c = p0+1;
               while (c < p1 && ((*c < 58 && *c > 47) || (*c < 91 && *c > 64)))
                  c++;
               if (c == p1) {
                  c++;
                  while (c < p2 && ((*c < 58 && *c > 47) || (*c < 91 && *c > 64)))
                     c++;
                  if (c == p2)
                     rsakey = 0;
               }
            }
         }
      }
      if (gDebug > 3)
         ::Info("TAuthenticate::SetRSAPublic"," Key type: %d",rsakey);
      if (rsakey == 0) {

         // Decode input string
         rsa_NUMBER rsa_n, rsa_d;
         rsakey = TAuthenticate::DecodeRSAPublic(rsaPubExport,rsa_n,rsa_d);

         // Save Public key
         TRSA_fun::RSA_assign()(&fgRSAPubKey.n, &rsa_n);
         TRSA_fun::RSA_assign()(&fgRSAPubKey.e, &rsa_d);

      } else {
         rsakey = 1;
#ifdef R__SSL
         // Now set the key locally in BF form
         BF_set_key(&fgBFKey, klen, (const unsigned char *)rsaPubExport);
#else
         if (gDebug > 0)
            ::Info("TAuthenticate::SetRSAPublic",
                   "not compiled with SSL support:"
                   " you should not have got here!");
#endif
      }
   }

   return rsakey;
}

//______________________________________________________________________________
Int_t TAuthenticate::SendRSAPublicKey(TSocket *socket, Int_t key)
{
   // Receives server RSA Public key
   // Sends local RSA public key encoded

   // Receive server public key
   char serverPubKey[kMAXSECBUF];
   int kind, nr = 0;
   if ((nr = socket->Recv(serverPubKey, kMAXSECBUF, kind)) < 0)
      return nr;
   if (gDebug > 3)
      ::Info("TAuthenticate::SendRSAPublicKey",
             "received key from server %ld bytes", (Long_t)strlen(serverPubKey));

   // Decode it
   rsa_NUMBER rsa_n, rsa_d;
#ifdef R__SSL
   char *tmprsa = 0;
   if (TAuthenticate::DecodeRSAPublic(serverPubKey,rsa_n,rsa_d,
                                      &tmprsa) != key) {
      if (tmprsa)
         RSA_free((RSA *)tmprsa);
      return -1;
   }
   RSA *RSASSLServer = (RSA *)tmprsa;
#else
   if (TAuthenticate::DecodeRSAPublic(serverPubKey,rsa_n,rsa_d) != key)
      return -1;
#endif

   // Send local public key, encodes
   char buftmp[kMAXSECBUF] = {0};
   char buflen[20] = {0};
   Int_t slen = fgRSAPubExport[key].len;
   Int_t ttmp = 0;
   if (key == 0) {
      strlcpy(buftmp,fgRSAPubExport[key].keys,slen+1);
      ttmp = TRSA_fun::RSA_encode()(buftmp, slen, rsa_n, rsa_d);
      snprintf(buflen, 20, "%d", ttmp);
   } else if (key == 1) {
#ifdef R__SSL
      Int_t lcmax = RSA_size(RSASSLServer) - 11;
      Int_t kk = 0;
      Int_t ke = 0;
      Int_t ns = slen;
      while (ns > 0) {
         Int_t lc = (ns > lcmax) ? lcmax : ns ;
         if ((ttmp = RSA_public_encrypt(lc,
                                        (unsigned char *)&fgRSAPubExport[key].keys[kk],
                                        (unsigned char *)&buftmp[ke],
                                        RSASSLServer,RSA_PKCS1_PADDING)) < 0) {
            char errstr[120];
            ERR_error_string(ERR_get_error(), errstr);
            ::Info("TAuthenticate::SendRSAPublicKey","SSL: error: '%s' ",errstr);
         }
         kk += lc;
         ke += ttmp;
         ns -= lc;
      }
      ttmp = ke;
      snprintf(buflen, 20, "%d", ttmp);
#else
      if (gDebug > 0)
         ::Info("TAuthenticate::SendRSAPublicKey","not compiled with SSL support:"
                " you should not have got here!");
      return -1;
#endif
   } else {
      if (gDebug > 0)
         ::Info("TAuthenticate::SendRSAPublicKey","unknown key type (%d)",key);
#ifdef R__SSL
      if (RSASSLServer)
         RSA_free(RSASSLServer);
#endif
      return -1;
   }

   // Send length first
   if ((nr = socket->Send(buflen, kROOTD_ENCRYPT)) < 0)
      return nr;
   // Send Key. second ...
   Int_t nsen = socket->SendRaw(buftmp, ttmp);
   if (gDebug > 3)
      ::Info("TAuthenticate::SendRSAPublicKey",
             "local: sent %d bytes (expected: %d)", nsen,ttmp);
#ifdef R__SSL
   if (RSASSLServer)
      RSA_free(RSASSLServer);
#endif
   return nsen;
}

//______________________________________________________________________________
Int_t TAuthenticate::ReadRootAuthrc()
{
   // Read authentication directives from $ROOTAUTHRC, $HOME/.rootauthrc or
   // <Root_etc_dir>/system.rootauthrc and create related THostAuth objects.
   // Files are read only if they changed since last reading
   // If 'proofconf' is defined, check also file proofconf for directives

   // rootauthrc family
   char *authrc = 0;
   if (gSystem->Getenv("ROOTAUTHRC") != 0) {
      authrc = StrDup(gSystem->Getenv("ROOTAUTHRC"));
   } else {
      if (fgReadHomeAuthrc)
         authrc = gSystem->ConcatFileName(gSystem->HomeDirectory(), ".rootauthrc");
   }
   if (authrc && gDebug > 2)
      ::Info("TAuthenticate::ReadRootAuthrc", "Checking file: %s", authrc);
   if (!authrc || gSystem->AccessPathName(authrc, kReadPermission)) {
      if (authrc && gDebug > 1)
         ::Info("TAuthenticate::ReadRootAuthrc",
                "file %s cannot be read (errno: %d)", authrc, errno);
      delete [] authrc;
#ifdef ROOTETCDIR
      authrc = gSystem->ConcatFileName(ROOTETCDIR,"system.rootauthrc");
#else
      char etc[1024];
#ifdef WIN32
      snprintf(etc, 1024, "%s\\etc", gRootDir);
#else
      snprintf(etc, 1024, "%s/etc", gRootDir);
#endif
      authrc = gSystem->ConcatFileName(etc,"system.rootauthrc");
#endif
      if (gDebug > 2)
         ::Info("TAuthenticate::ReadRootAuthrc", "Checking system file:%s",authrc);
      if (gSystem->AccessPathName(authrc, kReadPermission)) {
         if (gDebug > 1)
            ::Info("TAuthenticate::ReadRootAuthrc",
                   "file %s cannot be read (errno: %d)", authrc, errno);
         delete [] authrc;
         return 0;
      }
   }

   // Check if file has changed since last read
   TString tRootAuthrc = authrc;
   if (tRootAuthrc == fgRootAuthrc) {
      struct stat si;
      stat(tRootAuthrc, &si);
      if ((UInt_t)si.st_mtime < fgLastAuthrc.Convert()) {
         if (gDebug > 1)
            ::Info("TAuthenticate::ReadRootAuthrc",
                   "file %s already read", authrc);
         delete [] authrc;
         return 0;
      }
   }

   // Save filename in static variable
   fgRootAuthrc = tRootAuthrc;
   fgLastAuthrc = TDatime();

   // THostAuth lists
   TList *authinfo = TAuthenticate::GetAuthInfo();
   TList *proofauthinfo = TAuthenticate::GetProofAuthInfo();

   // Expand File into temporary file name and open it
   int expand = 1;
   TString filetmp = "rootauthrc";
   FILE *ftmp = gSystem->TempFileName(filetmp);
   if (gDebug > 2)
      ::Info("TAuthenticate::ReadRootAuthrc", "got tmp file: %s open at 0x%lx",
             filetmp.Data(), (Long_t)ftmp);
   if (ftmp == 0)
      expand = 0;  // Problems opening temporary file: ignore 'include's ...

   FILE *fd = 0;
   // If the temporary file is open, copy everything to the new file ...
   if (expand == 1) {
      TAuthenticate::FileExpand(authrc, ftmp);
      fd = ftmp;
      rewind(fd);
   } else {
      // Open file
      fd = fopen(authrc, "r");
      if (fd == 0) {
         if (gDebug > 2)
            ::Info("TAuthenticate::ReadRootAuthrc",
                   "file %s cannot be open (errno: %d)", authrc, errno);
         delete [] authrc;
         return 0;
      }
   }

   // Now scan file for meaningful directives
   TList tmpAuthInfo;
   char line[kMAXPATHLEN];
   Bool_t cont = kFALSE;
   TString proofserv;
   while (fgets(line, sizeof(line), fd) != 0) {

      // Skip comment lines
      if (line[0] == '#')
         continue;

      // Get rid of end of line '\n', if there ...
      if (line[strlen(line) - 1] == '\n')
         line[strlen(line) - 1] = '\0';

      // Skip empty lines
      if (!line[0])
         continue;

      // Now scan
      const size_t tmpSize = strlen(line) + 1;
      char *tmp = new char[tmpSize];
      if (!tmp) {
         ::Error("TAuthenticate::ReadRootAuthrc",
                 "could not allocate temporary buffer");
         return 0;
      }
      strlcpy(tmp, line, tmpSize);
      char *nxt = strtok(tmp," ");

      if (!strcmp(nxt, "proofserv") || cont) {

         // Building the list of data servers for proof (analyzed at the end)
         char *ph = 0;
         if (cont)
            ph = nxt;
         else
            ph = strtok(0," ");
         while (ph) {
            if (*ph != 92) {
               proofserv += TString((const char *)ph);
               proofserv += TString(" ");
               cont = kFALSE;
            } else {
               cont = kTRUE;
            }
            ph = strtok(0," ");
         }

      } else {

         TString hostsrv = nxt;
         TString host   = hostsrv;
         TString server = "";
         if (hostsrv.Contains(":")) {
            server = hostsrv;
            host.Remove(host.Index(":"));
            server.Remove(0,server.Index(":")+1);
         }
         Int_t srvtyp = -1;
         if (server.Length()) {
            if (server == "0" || server.BeginsWith("sock"))
               srvtyp = TSocket::kSOCKD;
            else if (server == "1" || server.BeginsWith("root"))
               srvtyp = TSocket::kROOTD;
            else if (server == "2" || server.BeginsWith("proof"))
               srvtyp = TSocket::kPROOFD;
         }

         // Line with host info directives
         TString user = "*";

         nxt = strtok(0," ");
         if (!strncmp(nxt,"user",4)) {
            nxt = strtok(0," ");
            if (strncmp(nxt,"list",4) && strncmp(nxt,"method",6)) {
               user = TString(nxt);
               nxt = strtok(0," ");
            }
         }

         // Get related THostAuth, if exists in the tmp list,
         TIter next(&tmpAuthInfo);
         THostAuth *ha;
         while ((ha = (THostAuth *)next())) {
            if (host == ha->GetHost() && user == ha->GetUser() &&
                srvtyp == ha->GetServer())
               break;
         }
         if (!ha) {
            // Create a new one
            ha = new THostAuth(host,srvtyp,user);
            tmpAuthInfo.Add(ha);
         }

         if (!strncmp(nxt,"list",4)) {
            // list of methods for {host,usr}
            Int_t nm = 0, me[kMAXSEC] = {0};
            char *mth = strtok(0," ");
            while (mth) {
               Int_t met = -1;
               if (strlen(mth) > 1) {
                  // Method passed as string: translate it to number
                  met = GetAuthMethodIdx(mth);
                  if (met == -1 && gDebug > 2)
                     ::Info("TAuthenticate::ReadRootAuthrc",
                            "unrecognized method (%s): ", mth);
               } else {
                  met = atoi(mth);
               }
               if (met > -1 && met < kMAXSEC)
                  me[nm++] = met;
               mth = strtok(0," ");
            }
            if (nm)
               ha->ReOrder(nm,me);

         } else if (!strncmp(nxt,"method",6)) {

            // details for {host,usr,method}
            char *mth = strtok(0," ");
            Int_t met = -1;
            if (strlen(mth) > 1) {
               // Method passed as string: translate it to number
               met = GetAuthMethodIdx(mth);
               if (met == -1 && gDebug > 2)
                  ::Info("TAuthenticate::ReadRootAuthrc",
                         "unrecognized method (%s): ", mth);
            } else {
               met = atoi(mth);
            }
            if (met > -1 && met < kMAXSEC) {
               const char *det = 0;
               nxt = strtok(0," ");
               if (nxt) {
                  det = (const char *)strstr(line,nxt);
               }
               if (ha->HasMethod(met))
                  ha->SetDetails(met,det);
               else
                  ha->AddMethod(met,det);
            }
         }
      }
      if (tmp) delete [] tmp;
   }
   // Close file and remove it if temporary
   fclose(fd);
   if (expand == 1)
      gSystem->Unlink(filetmp);
   // Cleanup allocated memory
   delete [] authrc;

   // Update authinfo with new info found
   TAuthenticate::MergeHostAuthList(authinfo,&tmpAuthInfo);

   // Print those left, if requested ...
   if (gDebug > 2)
      TAuthenticate::Show();

   // Now create the list of THostAuth to be sent over to
   // the Master/Slaves, if requested ...
   TList tmpproofauthinfo;
   if (proofserv.Length() > 0) {
      char *tmps = new char[proofserv.Length()+1];
      strlcpy(tmps,proofserv.Data(),proofserv.Length()+1);
      char *nxt = strtok(tmps," ");
      while (nxt) {
         TString tmp((const char *)nxt);
         Int_t pdd = -1;
         // host
         TString host;
         if ((pdd = tmp.Index(":")) == -1) {
            host = tmp;
         } else {
            host = tmp;
            host.Resize(pdd);
            if (!host.Length())
               host = "*";
            tmp.Remove(0,pdd+1);
         }
         // user
         TString user;
         if ((pdd = tmp.Index(":")) == -1) {
            user = tmp;
         } else {
            user = tmp;
            user.Resize(pdd);
            if (!user.Length())
               user = "*";
            tmp.Remove(0,pdd+1);
         }
         // method(s)
         TString meth;
         Int_t nm = 0, me[kMAXSEC] = {0}, met = -1;
         while (tmp.Length() > 0) {
            meth = tmp;
            if ((pdd = tmp.Index(":")) > -1)
               meth.Resize(pdd);
            if (meth.Length() > 1) {
               // Method passed as string: translate it to number
               met = GetAuthMethodIdx(meth.Data());
               if (met == -1 && gDebug > 2)
                  ::Info("TAuthenticate::ReadRootAuthrc",
                         "unrecognized method (%s): ",meth.Data());
            } else if (meth.Length() == 1) {
               met = atoi(meth.Data());
               if (met > -1 && met < kMAXSEC)
                  me[nm++] = met;
            }
            if (pdd > -1)
               tmp.Remove(0,pdd+1);
            else
               tmp.Resize(0);
         }

         // Get related THostAuth, if exists, or create a new one
         THostAuth *ha = 0;
         THostAuth *hatmp = TAuthenticate::GetHostAuth(host,user);
         if (!hatmp) {
            ha = new THostAuth(host,user,nm,me,0);
         } else {
            // Create an empty THostAuth
            ha = new THostAuth(host,user);
            // Update with hatmp info
            ha->Update(hatmp);
            // ReOrder following new directives
            ha->ReOrder(nm,me);
         }
         // Add to the tmp list
         tmpproofauthinfo.Add(ha);
         // Go to next
         nxt = strtok(0," ");
      }
      delete [] tmps;
   }

   // Update proofauthinfo with new info found
   TAuthenticate::MergeHostAuthList(proofauthinfo,&tmpproofauthinfo,"P");
   // Print those, if requested ...
   if (gDebug > 2)
      TAuthenticate::Show("P");

   return authinfo->GetSize();
}

//______________________________________________________________________________
Bool_t TAuthenticate::CheckProofAuth(Int_t cSec, TString &out)
{
   // Check if the authentication method can be attempted for the client.

   Bool_t rc = kFALSE;
   const char sshid[3][20] = { "/.ssh/identity", "/.ssh/id_dsa", "/.ssh/id_rsa" };
   const char netrc[2][20] = { "/.netrc", "/.rootnetrc" };
   TString user;

   // Get user logon name
   UserGroup_t *pw = gSystem->GetUserInfo();
   if (pw) {
      user = TString(pw->fUser);
      delete pw;
   } else {
      ::Info("CheckProofAuth",
             "not properly logged on (getpwuid unable to find relevant info)!");
      out = "";
      return rc;
   }

   // UsrPwd
   if (cSec == (Int_t) TAuthenticate::kClear) {
      Int_t i = 0;
      for (; i < 2; i++) {
         TString infofile = TString(gSystem->HomeDirectory())+TString(netrc[i]);
         if (!gSystem->AccessPathName(infofile, kReadPermission))
            rc = kTRUE;
      }
      if (rc)
         out.Form("pt:0 ru:1 us:%s",user.Data());
   }

   // SRP
   if (cSec == (Int_t) TAuthenticate::kSRP) {
#ifdef R__SRP
      out.Form("pt:0 ru:1 us:%s",user.Data());
      rc = kTRUE;
#endif
   }

   // Kerberos
   if (cSec == (Int_t) TAuthenticate::kKrb5) {
#ifdef R__KRB5
      out.Form("pt:0 ru:0 us:%s",user.Data());
      rc = kTRUE;
#endif
   }

   // Globus
   if (cSec == (Int_t) TAuthenticate::kGlobus) {
#ifdef R__GLBS
      TApplication *lApp = gROOT->GetApplication();
      if (lApp != 0 && lApp->Argc() > 9) {
         if (gROOT->IsProofServ()) {
            // Delegated Credentials
            Int_t ShmId = -1;
            if (gSystem->Getenv("ROOTSHMIDCRED"))
               ShmId = strtol(gSystem->Getenv("ROOTSHMIDCRED"),
                              (char **)0, 10);
            if (ShmId != -1) {
               struct shmid_ds shm_ds;
               if (shmctl(ShmId, IPC_STAT, &shm_ds) == 0)
                  rc = kTRUE;
            }
            if (rc) {
               // Build details .. CA dir
               TString Adir(gSystem->Getenv("X509_CERT_DIR"));
               // Usr Cert
               TString Ucer(gSystem->Getenv("X509_USER_CERT"));
               // Usr Key
               TString Ukey(gSystem->Getenv("X509_USER_KEY"));
               // Usr Dir
               TString Cdir = Ucer;
               Cdir.Resize(Cdir.Last('/')+1);
               // Create output
               out.Form("pt=0 ru:0 cd:%s cf:%s kf:%s ad:%s",
                        Cdir.Data(),Ucer.Data(),Ukey.Data(),Adir.Data());
            }
         }
      }
#endif
   }

   // SSH
   if (cSec == (Int_t) TAuthenticate::kSSH) {
      Int_t i = 0;
      for (; i < 3; i++) {
         TString infofile = TString(gSystem->HomeDirectory())+TString(sshid[i]);
         if (!gSystem->AccessPathName(infofile,kReadPermission))
            rc = kTRUE;
      }
      if (rc)
         out.Form("pt:0 ru:1 us:%s",user.Data());
   }

   // Rfio
   if (cSec == (Int_t) TAuthenticate::kRfio) {
      out.Form("pt:0 ru:0 us:%s",user.Data());
      rc = kTRUE;
   }

   if (gDebug > 3) {
      if (strlen(out) > 0)
         ::Info("CheckProofAuth",
                "meth: %d ... is available: details: %s", cSec, out.Data());
      else
         ::Info("CheckProofAuth",
                "meth: %d ... is NOT available", cSec);
   }

   // return
   return rc;
}

//______________________________________________________________________________
Int_t StdCheckSecCtx(const char *user, TRootSecContext *ctx)
{
   // Standard version of CheckSecCtx to be passed to TAuthenticate::AuthExists
   // Check if User is matches the one in Ctx
   // Returns: 1 if ok, 0 if not
   // Deactivates Ctx is not valid

   Int_t rc = 0;

   if (ctx->IsActive()) {
      if (!strcmp(user,ctx->GetUser()) &&
          strncmp("AFS", ctx->GetID(), 3))
         rc = 1;
   }
   return rc;
}

//______________________________________________________________________________
void TAuthenticate::MergeHostAuthList(TList *std, TList *nin, Option_t *opt)
{
   // Tool for updating fgAuthInfo or fgProofAuthInfo
   // 'nin' contains list of last input information through (re)reading
   // of a rootauthrc-alike file. 'nin' info has priority.
   // 'std' is cleaned from inactive members.
   // 'nin' members used to update existing members in 'std' are
   // removed from 'nin', do that they do not leak
   // opt = "P" for proofauthinfo.

   // Remove inactive from the 'std'
   TIter nxstd(std);
   THostAuth *ha;
   while ((ha = (THostAuth *) nxstd())) {
      if (!ha->IsActive()) {
         std->Remove(ha);
         SafeDelete(ha);
      }
   }

   // Merge 'nin' info in 'std'
   TIter nxnew(nin);
   THostAuth *hanew;
   while ((hanew = (THostAuth *)nxnew())) {
      if (hanew->NumMethods()) {
         TString hostsrv;
         hostsrv.Form("%s:%d",hanew->GetHost(),hanew->GetServer());
         THostAuth *hastd =
            TAuthenticate::HasHostAuth(hostsrv,hanew->GetUser(),opt);
         if (hastd) {
            // Update with new info
            hastd->Update(hanew);
            // Flag for removal
            hanew->DeActivate();
         } else {
            // Add new ThostAuth to std
            std->Add(hanew);
         }
      } else
         // Flag for removal empty objects
         hanew->DeActivate();
   }

   // Cleanup memory before quitting
   nxnew.Reset();
   while ((hanew = (THostAuth *)nxnew())) {
      if (!hanew->IsActive()) {
         nin->Remove(hanew);
         SafeDelete(hanew);
      }
   }

}

//______________________________________________________________________________
void TAuthenticate::RemoveSecContext(TRootSecContext *ctx)
{
   // Tool for removing SecContext ctx from THostAuth listed in
   // fgAuthInfo or fgProofAuthInfo

   THostAuth *ha = 0;

   // authinfo first
   TIter nxai(GetAuthInfo());
   while ((ha = (THostAuth *)nxai())) {
      TIter next(ha->Established());
      TRootSecContext *lctx = 0;
      while ((lctx = (TRootSecContext *) next())) {
         if (lctx == ctx) {
            ha->Established()->Remove(ctx);
            break;
         }
      }
   }

   // proofauthinfo second
   TIter nxpa(GetProofAuthInfo());
   while ((ha = (THostAuth *)nxpa())) {
      TIter next(ha->Established());
      TRootSecContext *lctx = 0;
      while ((lctx = (TRootSecContext *) next())) {
         if (lctx == ctx) {
            ha->Established()->Remove(ctx);
            break;
         }
      }
   }

}

//______________________________________________________________________________
Int_t TAuthenticate::ProofAuthSetup()
{
   // Authentication related stuff setup in TProofServ.
   // This is the place where the buffer send by the client / master is
   // decoded. It contains also password information, if the case requires.
   // Return 0 on success, -1 on failure.

   static Bool_t done = kFALSE;

   // Only once
   if (done)
      return 0;
   done = kTRUE;

   // Localise the buffer and decode it
   const char *p = gSystem->Getenv("ROOTPROOFAUTHSETUP");
   if (!p) {
      if (gDebug > 2)
         Info("ProofAuthSetup","Buffer not found: nothing to do");
      return 0;
   }
   TString mbuf = TBase64::Decode(p);

   // Create the message
   TMessage *mess = new TMessage((void*)mbuf.Data(), mbuf.Length()+sizeof(UInt_t));

   // Extract the information
   TString user = "";
   TString passwd = "";
   Bool_t  pwhash = kFALSE;
   Bool_t  srppwd = kFALSE;
   Int_t  rsakey = -1;
   *mess >> user >> passwd >> pwhash >> srppwd >> rsakey;

   // Set Globals for later use
   TAuthenticate::SetGlobalUser(user);
   TAuthenticate::SetGlobalPasswd(passwd);
   TAuthenticate::SetGlobalPwHash(pwhash);
   TAuthenticate::SetGlobalSRPPwd(srppwd);
   TAuthenticate::SetDefaultRSAKeyType(rsakey);
   const char *h = gSystem->Getenv("ROOTHOMEAUTHRC");
   if (h) {
      Bool_t rha = (Bool_t)(strtol(h, (char **)0, 10));
      TAuthenticate::SetReadHomeAuthrc(rha);
   }

   // Extract the list of THostAuth
   TList *pha = (TList *)mess->ReadObject(TList::Class());
   if (!pha) {
      if (gDebug > 0)
         Info("ProofAuthSetup","List of THostAuth not found");
      return 0;
   }

   Bool_t master = gROOT->IsProofServ();
   TIter next(pha);
   THostAuth *ha = 0;
   while ((ha = (THostAuth *)next())) {

      // Check if there is already one compatible
      Int_t kExact = 0;
      THostAuth *haex = 0;
      Bool_t fromProofAI = kFALSE;
      if (master) {
         // Look first in the proof list
         haex = TAuthenticate::GetHostAuth(ha->GetHost(),ha->GetUser(),"P",&kExact);
         // If nothing found, look also in the standard list
         if (!haex) {
            haex =
               TAuthenticate::GetHostAuth(ha->GetHost(),ha->GetUser(),"R",&kExact);
         } else
            fromProofAI = kTRUE;
      } else {
         // For slaves look first in the standard list only
         haex = TAuthenticate::GetHostAuth(ha->GetHost(),ha->GetUser(),"R",&kExact);
      }

      if (haex) {
         // If yes, action depends on whether it matches exactly or not
         if (kExact == 1) {
            // Update info in authinfo if Slave or in proofauthinfo
            // if Master and the entry was already in proofauthinfo
            if (!master || fromProofAI) {
               // update this existing one with the information found in
               // in the new one, if needed
               haex->Update(ha);
               // Delete temporary THostAuth
               SafeDelete(ha);
            } else
               // Master, entry not already in proofauthinfo,
               // Add it to the list
               TAuthenticate::GetProofAuthInfo()->Add(ha);
         } else {
            // update this new one with the information found in
            // in the existing one (if needed) and ...
            Int_t i = 0;
            for (; i < haex->NumMethods(); i++) {
               Int_t met = haex->GetMethod(i);
               if (!ha->HasMethod(met))
                  ha->AddMethod(met,haex->GetDetails(met));
            }
            if (master)
               // ... add the new one to the list
               TAuthenticate::GetProofAuthInfo()->Add(ha);
            else
               // We add this one to the standard list
               TAuthenticate::GetAuthInfo()->Add(ha);
         }
      } else {
         if (master)
            // We add this one to the list for forwarding
            TAuthenticate::GetProofAuthInfo()->Add(ha);
         else
            // We add this one to the standard list
            TAuthenticate::GetAuthInfo()->Add(ha);
      }
   }

   // We are done
   return 0;
}

//______________________________________________________________________________
Int_t TAuthenticate::ProofAuthSetup(TSocket *sock, Bool_t client)
{
   // Setup of authetication related stuff in PROOF run after a
   // successful authentication.
   // Return 0 on success, -1 on failure.

   // Fill some useful info
   TSecContext *sc    = sock->GetSecContext();
   TString user       = sc->GetUser();
   Int_t remoteOffSet = sc->GetOffSet();

   // send user name to remote host
   // for UsrPwd and SRP methods send also passwd, rsa encoded
   TMessage pubkey;
   TString passwd = "";
   Bool_t  pwhash = kFALSE;
   Bool_t  srppwd = kFALSE;
   Bool_t  sndsrp = kFALSE;

   Bool_t upwd = sc->IsA("UsrPwd");
   Bool_t srp = sc->IsA("SRP");

   TPwdCtx *pwdctx = 0;
   if (remoteOffSet > -1 && (upwd || srp))
      pwdctx = (TPwdCtx *)(sc->GetContext());

   if (client) {
      if ((gEnv->GetValue("Proofd.SendSRPPwd",0)) && (remoteOffSet > -1))
         sndsrp = kTRUE;
   } else {
      if (srp && pwdctx) {
         if (strcmp(pwdctx->GetPasswd(), "") && remoteOffSet > -1)
            sndsrp = kTRUE;
      }
   }

   if ((upwd && pwdctx) || (srp  && sndsrp)) {
      if (pwdctx) {
         passwd = pwdctx->GetPasswd();
         pwhash = pwdctx->IsPwHash();
      }
   }

   Int_t keytyp = ((TRootSecContext *)sc)->GetRSAKey();

   // Prepare buffer
   TMessage mess;
   mess << user << passwd << pwhash << srppwd << keytyp;

   // Add THostAuth info
   mess.WriteObject(TAuthenticate::GetProofAuthInfo());

   // Get buffer as a base 64 string
   char *mbuf = mess.Buffer();
   Int_t mlen = mess.Length();
   TString messb64 = TBase64::Encode(mbuf, mlen);

   if (gDebug > 2)
      ::Info("ProofAuthSetup","sending %d bytes", messb64.Length());

   // Send it over
   if (remoteOffSet > -1) {
      if (TAuthenticate::SecureSend(sock, 1, keytyp, messb64.Data()) == -1) {
         ::Error("ProofAuthSetup","problems secure-sending message buffer");
         return -1;
      }
   } else {
      // There is no encryption key: send it plain
      char buflen[20];
      snprintf(buflen,20, "%d", messb64.Length());
      if (sock->Send(buflen, kMESS_ANY) < 0) {
         ::Error("ProofAuthSetup","plain: problems sending message length");
         return -1;
      }
      if (sock->SendRaw(messb64.Data(), messb64.Length()) < 0) {
         ::Error("ProofAuthSetup","problems sending message buffer");
         return -1;
      }
   }

   // We are done
   return 0;
}

//______________________________________________________________________________
Int_t TAuthenticate::GetClientProtocol()
{
   // Static method returning supported client protocol.

   return TSocket::GetClientProtocol();
}

//
// The code below is needed by TSlave and TProofServ for backward
// compatibility.
//

//______________________________________________________________________________
static Int_t SendHostAuth(TSocket *s)
{
   // Sends the list of the relevant THostAuth objects to the master or
   // to the active slaves, typically data servers external to the proof
   // cluster. The list is of THostAuth to be sent is specified by
   // TAuthenticate::fgProofAuthInfo after directives found in the
   // .rootauthrc family files ('proofserv' key)
   // Returns -1 if a problem sending THostAuth has occured, -2 in case
   // of problems closing the transmission.

   Int_t retval = 0, ns = 0;

   if (!s) {
      Error("SendHostAuth","invalid input: socket undefined");
      return -1;
   }


   TIter next(TAuthenticate::GetProofAuthInfo());
   THostAuth *ha;
   while ((ha = (THostAuth *)next())) {
      TString buf;
      ha->AsString(buf);
      if((ns = s->Send(buf, kPROOF_HOSTAUTH)) < 1) {
         retval = -1;
         break;
      }
      if (gDebug > 2)
         Info("SendHostAuth","sent %d bytes (%s)",ns,buf.Data());
   }

   // End of transmission ...
   if ((ns = s->Send("END", kPROOF_HOSTAUTH)) < 1)
      retval = -2;
   if (gDebug > 2)
      Info("SendHostAuth","sent %d bytes for closing",ns);

   return retval;
}

//______________________________________________________________________________
static Int_t RecvHostAuth(TSocket *s, Option_t *opt)
{
   // Receive from client/master directives for authentications, create
   // related THostAuth and add them to the TAuthenticate::ProofAuthInfo
   // list. Opt = "M" or "m" if Master, "S" or "s" if Proof slave.
   // The 'proofconf' file is read only if Master

   if (!s) {
      Error("RecvHostAuth","invalid input: socket undefined");
      return -1;
   }

   // Check if Master
   Bool_t master = !strncasecmp(opt,"M",1) ? kTRUE : kFALSE;

   // First read directives from <rootauthrc>, <proofconf> and alike files
   TAuthenticate::ReadRootAuthrc();

   // Receive buffer
   Int_t kind;
   char buf[kMAXSECBUF];
   Int_t nr = s->Recv(buf, kMAXSECBUF, kind);
   if (nr < 0 || kind != kPROOF_HOSTAUTH) {
      Error("RecvHostAuth", "received: kind: %d (%d bytes)", kind, nr);
      return -1;
   }
   if (gDebug > 2)
      Info("RecvHostAuth","received %d bytes (%s)",nr,buf);

   while (strcmp(buf, "END")) {
      // Clean buffer
      Int_t nc = (nr >= kMAXSECBUF) ? kMAXSECBUF - 1 : nr ;
      buf[nc] = '\0';

      // Create THostAuth
      THostAuth *ha = new THostAuth((const char *)&buf);

      // Check if there is already one compatible
      Int_t kExact = 0;
      THostAuth *haex = 0;
      Bool_t fromProofAI = kFALSE;
      if (master) {
         // Look first in the proof list
         haex = TAuthenticate::GetHostAuth(ha->GetHost(),ha->GetUser(),"P",&kExact);
         // If nothing found, look also in the standard list
         if (!haex) {
            haex =
               TAuthenticate::GetHostAuth(ha->GetHost(),ha->GetUser(),"R",&kExact);
         } else
            fromProofAI = kTRUE;
      } else {
         // For slaves look first in the standard list only
         haex = TAuthenticate::GetHostAuth(ha->GetHost(),ha->GetUser(),"R",&kExact);
      }

      if (haex) {
         // If yes, action depends on whether it matches exactly or not
         if (kExact == 1) {
            // Update info in authinfo if Slave or in proofauthinfo
            // if master and the entry was already in proofauthinfo
            if (!master || fromProofAI) {
               // update this existing one with the information found in
               // in the new one, if needed
               haex->Update(ha);
               // Delete temporary THostAuth
               SafeDelete(ha);
            } else
               // master, entry not already in proofauthinfo,
               // Add it to the list
               TAuthenticate::GetProofAuthInfo()->Add(ha);
         } else {
            // update this new one with the information found in
            // in the existing one (if needed) and ...
            Int_t i = 0;
            for (; i < haex->NumMethods(); i++) {
               Int_t met = haex->GetMethod(i);
               if (!ha->HasMethod(met))
                  ha->AddMethod(met,haex->GetDetails(met));
            }
            if (master)
               // ... add the new one to the list
               TAuthenticate::GetProofAuthInfo()->Add(ha);
            else
               // We add this one to the standard list
               TAuthenticate::GetAuthInfo()->Add(ha);
         }
      } else {
         if (master)
            // We add this one to the list for forwarding
            TAuthenticate::GetProofAuthInfo()->Add(ha);
         else
            // We add this one to the standard list
            TAuthenticate::GetAuthInfo()->Add(ha);
      }


      // Get the next one
      nr = s->Recv(buf, kMAXSECBUF, kind);
      if (nr < 0 || kind != kPROOF_HOSTAUTH) {
         Info("RecvHostAuth","Error: received: kind: %d (%d bytes)", kind, nr);
         return -1;
      }
      if (gDebug > 2)
         Info("RecvHostAuth","received %d bytes (%s)",nr,buf);
   }

   return 0;
}

extern "C" {

//______________________________________________________________________________
Int_t OldSlaveAuthSetup(TSocket *sock,
                        Bool_t master, TString ord, TString conf)
{
   // Setup of authetication in PROOF run after successful opening
   // of the socket. Provided for backward compatibility.
   // Return 0 on success, -1 on failure.


   // Fill some useful info
   TSecContext *sc    = sock->GetSecContext();
   TString user       = sc->GetUser();
   Int_t proofdProto  = sock->GetRemoteProtocol();
   Int_t remoteOffSet = sc->GetOffSet();

   // send user name to remote host
   // for UsrPwd and SRP methods send also passwd, rsa encoded
   TMessage pubkey;
   TString passwd = "";
   Bool_t  pwhash = kFALSE;
   Bool_t  srppwd = kFALSE;
   Bool_t  sndsrp = kFALSE;

   Bool_t upwd = sc->IsA("UsrPwd");
   Bool_t srp = sc->IsA("SRP");

   TPwdCtx *pwdctx = 0;
   if (remoteOffSet > -1 && (upwd || srp))
      pwdctx = (TPwdCtx *)(sc->GetContext());

   if (!master) {
      if ((gEnv->GetValue("Proofd.SendSRPPwd",0)) && (remoteOffSet > -1))
         sndsrp = kTRUE;
   } else {
      if (srp && pwdctx) {
         if (strcmp(pwdctx->GetPasswd(), "") && remoteOffSet > -1)
            sndsrp = kTRUE;
      }
   }

   if ((upwd && pwdctx) || (srp  && sndsrp)) {

      // Send offset to identify remotely the public part of RSA key
      if (sock->Send(remoteOffSet, kROOTD_RSAKEY) != 2*sizeof(Int_t)) {
         Error("OldAuthSetup", "failed to send offset in RSA key");
         return -1;
      }

      if (pwdctx) {
         passwd = pwdctx->GetPasswd();
         pwhash = pwdctx->IsPwHash();
      }

      Int_t keytyp = ((TRootSecContext *)sc)->GetRSAKey();
      if (TAuthenticate::SecureSend(sock, 1, keytyp, passwd.Data()) == -1) {
         if (remoteOffSet > -1)
            Warning("OldAuthSetup","problems secure-sending pass hash %s",
                    "- may result in failures");
         // If non RSA encoding available try passwd inversion
         if (upwd) {
            for (int i = 0; i < passwd.Length(); i++) {
               char inv = ~passwd(i);
               passwd.Replace(i, 1, inv);
            }
            TMessage mess;
            mess << passwd;
            if (sock->Send(mess) < 0) {
               Error("OldAuthSetup", "failed to send inverted password");
               return -1;
            }
         }
      }

   } else {

      // Send notification of no offset to be sent ...
      if (sock->Send(-2, kROOTD_RSAKEY) != 2*sizeof(Int_t)) {
         Error("OldAuthSetup", "failed to send no offset notification in RSA key");
         return -1;
      }
   }

   // Send ordinal (and config) info to slave (or master)
   TMessage mess;
   mess << user << pwhash << srppwd << ord << conf;

   if (sock->Send(mess) < 0) {
      Error("OldAuthSetup", "failed to send ordinal and config info");
      return -1;
   }

   if (proofdProto > 6) {
      // Now we send authentication details to access, e.g., data servers
      // not in the proof cluster and to be propagated to slaves.
      // This is triggered by the 'proofserv <dserv1> <dserv2> ...'
      // line in .rootauthrc
      if (SendHostAuth(sock) < 0) {
         Error("OldAuthSetup", "failed to send HostAuth info");
         return -1;
      }
   }

   // We are done
   return 0;
}

//______________________________________________________________________________
Int_t OldProofServAuthSetup(TSocket *sock, Bool_t master, Int_t protocol,
                            TString &user, TString &ord, TString &conf)
{
   // Authentication related setup in TProofServ run after successful
   // startup. Provided for backward compatibility.
   // Return 0 on success, -1 on failure.

   // First receive, decode and store the public part of RSA key
   Int_t retval, kind;
   if (sock->Recv(retval, kind) != 2*sizeof(Int_t)) {
      //other side has closed connection
      Info("OldProofServAuthSetup",
           "socket has been closed due to protocol mismatch - Exiting");
      return -1;
   }

   Int_t rsakey = 0;
   TString passwd;
   if (kind == kROOTD_RSAKEY) {

      if (retval > -1) {
         if (gSystem->Getenv("ROOTKEYFILE")) {

            TString keyfile = gSystem->Getenv("ROOTKEYFILE");
            keyfile += retval;

            FILE *fKey = 0;
            char pubkey[kMAXPATHLEN] = { 0 };
            if (!gSystem->AccessPathName(keyfile.Data(), kReadPermission)) {
               if ((fKey = fopen(keyfile.Data(), "r"))) {
                  Int_t klen = fread((void *)pubkey,1,sizeof(pubkey),fKey);
                  if (klen <= 0) {
                     Error("OldProofServAuthSetup",
                           "failed to read public key from '%s'", keyfile.Data());
                     fclose(fKey);
                     return -1;
                  }
                  pubkey[klen] = 0;
                  // Set RSA key
                  rsakey = TAuthenticate::SetRSAPublic(pubkey,klen);
                  fclose(fKey);
               } else {
                  Error("OldProofServAuthSetup", "failed to open '%s'", keyfile.Data());
                  return -1;
               }
            }
         }

         // Receive passwd
         char *pwd = 0;
         if (TAuthenticate::SecureRecv(sock, 2, rsakey, &pwd) < 0) {
            Error("OldProofServAuthSetup", "failed to receive password");
            return -1;
         }
         passwd = pwd;
         delete[] pwd;

      } else if (retval == -1) {

         // Receive inverted passwd
         TMessage *mess;
         if ((sock->Recv(mess) <= 0) || !mess) {
            Error("OldProofServAuthSetup", "failed to receive inverted password");
            return -1;
         }
         (*mess) >> passwd;
         delete mess;

         for (Int_t i = 0; i < passwd.Length(); i++) {
            char inv = ~passwd(i);
            passwd.Replace(i, 1, inv);
         }

      }
   }

   // Receive final information
   TMessage *mess;
   if ((sock->Recv(mess) <= 0) || !mess) {
      Error("OldProofServAuthSetup", "failed to receive ordinal and config info");
      return -1;
   }

   // Decode it
   Bool_t pwhash, srppwd;
   if (master) {
      if (protocol < 4) {
         (*mess) >> user >> pwhash >> srppwd >> conf;
         ord = "0";
      } else {
         (*mess) >> user >> pwhash >> srppwd >> ord >> conf;
      }
   } else {
      if (protocol < 4) {
         Int_t iord;
         (*mess) >> user >> pwhash >> srppwd >> iord;
         ord = "0.";
         ord += iord;
      } else {
         (*mess) >> user >> pwhash >> srppwd >> ord >> conf;
      }
   }
   delete mess;

   // Set Globals for later use
   TAuthenticate::SetGlobalUser(user);
   TAuthenticate::SetGlobalPasswd(passwd);
   TAuthenticate::SetGlobalPwHash(pwhash);
   TAuthenticate::SetGlobalSRPPwd(srppwd);
   TAuthenticate::SetDefaultRSAKeyType(rsakey);
   const char *h = gSystem->Getenv("ROOTHOMEAUTHRC");
   if (h) {
      Bool_t rha = (Bool_t)(strtol(h, (char **)0, 10));
      TAuthenticate::SetReadHomeAuthrc(rha);
   }

   // Read user or system authentication directives and
   // receive auth info transmitted from the client
   Int_t harc = master ? RecvHostAuth(sock, "M") : RecvHostAuth(sock, "S");

   if (harc < 0) {
      Error("OldProofServAuthSetup", "failed to receive HostAuth info");
      return -1;
   }

   // We are done
   return 0;
}

}  // extern "C"
 TAuthenticate.cxx:1
 TAuthenticate.cxx:2
 TAuthenticate.cxx:3
 TAuthenticate.cxx:4
 TAuthenticate.cxx:5
 TAuthenticate.cxx:6
 TAuthenticate.cxx:7
 TAuthenticate.cxx:8
 TAuthenticate.cxx:9
 TAuthenticate.cxx:10
 TAuthenticate.cxx:11
 TAuthenticate.cxx:12
 TAuthenticate.cxx:13
 TAuthenticate.cxx:14
 TAuthenticate.cxx:15
 TAuthenticate.cxx:16
 TAuthenticate.cxx:17
 TAuthenticate.cxx:18
 TAuthenticate.cxx:19
 TAuthenticate.cxx:20
 TAuthenticate.cxx:21
 TAuthenticate.cxx:22
 TAuthenticate.cxx:23
 TAuthenticate.cxx:24
 TAuthenticate.cxx:25
 TAuthenticate.cxx:26
 TAuthenticate.cxx:27
 TAuthenticate.cxx:28
 TAuthenticate.cxx:29
 TAuthenticate.cxx:30
 TAuthenticate.cxx:31
 TAuthenticate.cxx:32
 TAuthenticate.cxx:33
 TAuthenticate.cxx:34
 TAuthenticate.cxx:35
 TAuthenticate.cxx:36
 TAuthenticate.cxx:37
 TAuthenticate.cxx:38
 TAuthenticate.cxx:39
 TAuthenticate.cxx:40
 TAuthenticate.cxx:41
 TAuthenticate.cxx:42
 TAuthenticate.cxx:43
 TAuthenticate.cxx:44
 TAuthenticate.cxx:45
 TAuthenticate.cxx:46
 TAuthenticate.cxx:47
 TAuthenticate.cxx:48
 TAuthenticate.cxx:49
 TAuthenticate.cxx:50
 TAuthenticate.cxx:51
 TAuthenticate.cxx:52
 TAuthenticate.cxx:53
 TAuthenticate.cxx:54
 TAuthenticate.cxx:55
 TAuthenticate.cxx:56
 TAuthenticate.cxx:57
 TAuthenticate.cxx:58
 TAuthenticate.cxx:59
 TAuthenticate.cxx:60
 TAuthenticate.cxx:61
 TAuthenticate.cxx:62
 TAuthenticate.cxx:63
 TAuthenticate.cxx:64
 TAuthenticate.cxx:65
 TAuthenticate.cxx:66
 TAuthenticate.cxx:67
 TAuthenticate.cxx:68
 TAuthenticate.cxx:69
 TAuthenticate.cxx:70
 TAuthenticate.cxx:71
 TAuthenticate.cxx:72
 TAuthenticate.cxx:73
 TAuthenticate.cxx:74
 TAuthenticate.cxx:75
 TAuthenticate.cxx:76
 TAuthenticate.cxx:77
 TAuthenticate.cxx:78
 TAuthenticate.cxx:79
 TAuthenticate.cxx:80
 TAuthenticate.cxx:81
 TAuthenticate.cxx:82
 TAuthenticate.cxx:83
 TAuthenticate.cxx:84
 TAuthenticate.cxx:85
 TAuthenticate.cxx:86
 TAuthenticate.cxx:87
 TAuthenticate.cxx:88
 TAuthenticate.cxx:89
 TAuthenticate.cxx:90
 TAuthenticate.cxx:91
 TAuthenticate.cxx:92
 TAuthenticate.cxx:93
 TAuthenticate.cxx:94
 TAuthenticate.cxx:95
 TAuthenticate.cxx:96
 TAuthenticate.cxx:97
 TAuthenticate.cxx:98
 TAuthenticate.cxx:99
 TAuthenticate.cxx:100
 TAuthenticate.cxx:101
 TAuthenticate.cxx:102
 TAuthenticate.cxx:103
 TAuthenticate.cxx:104
 TAuthenticate.cxx:105
 TAuthenticate.cxx:106
 TAuthenticate.cxx:107
 TAuthenticate.cxx:108
 TAuthenticate.cxx:109
 TAuthenticate.cxx:110
 TAuthenticate.cxx:111
 TAuthenticate.cxx:112
 TAuthenticate.cxx:113
 TAuthenticate.cxx:114
 TAuthenticate.cxx:115
 TAuthenticate.cxx:116
 TAuthenticate.cxx:117
 TAuthenticate.cxx:118
 TAuthenticate.cxx:119
 TAuthenticate.cxx:120
 TAuthenticate.cxx:121
 TAuthenticate.cxx:122
 TAuthenticate.cxx:123
 TAuthenticate.cxx:124
 TAuthenticate.cxx:125
 TAuthenticate.cxx:126
 TAuthenticate.cxx:127
 TAuthenticate.cxx:128
 TAuthenticate.cxx:129
 TAuthenticate.cxx:130
 TAuthenticate.cxx:131
 TAuthenticate.cxx:132
 TAuthenticate.cxx:133
 TAuthenticate.cxx:134
 TAuthenticate.cxx:135
 TAuthenticate.cxx:136
 TAuthenticate.cxx:137
 TAuthenticate.cxx:138
 TAuthenticate.cxx:139
 TAuthenticate.cxx:140
 TAuthenticate.cxx:141
 TAuthenticate.cxx:142
 TAuthenticate.cxx:143
 TAuthenticate.cxx:144
 TAuthenticate.cxx:145
 TAuthenticate.cxx:146
 TAuthenticate.cxx:147
 TAuthenticate.cxx:148
 TAuthenticate.cxx:149
 TAuthenticate.cxx:150
 TAuthenticate.cxx:151
 TAuthenticate.cxx:152
 TAuthenticate.cxx:153
 TAuthenticate.cxx:154
 TAuthenticate.cxx:155
 TAuthenticate.cxx:156
 TAuthenticate.cxx:157
 TAuthenticate.cxx:158
 TAuthenticate.cxx:159
 TAuthenticate.cxx:160
 TAuthenticate.cxx:161
 TAuthenticate.cxx:162
 TAuthenticate.cxx:163
 TAuthenticate.cxx:164
 TAuthenticate.cxx:165
 TAuthenticate.cxx:166
 TAuthenticate.cxx:167
 TAuthenticate.cxx:168
 TAuthenticate.cxx:169
 TAuthenticate.cxx:170
 TAuthenticate.cxx:171
 TAuthenticate.cxx:172
 TAuthenticate.cxx:173
 TAuthenticate.cxx:174
 TAuthenticate.cxx:175
 TAuthenticate.cxx:176
 TAuthenticate.cxx:177
 TAuthenticate.cxx:178
 TAuthenticate.cxx:179
 TAuthenticate.cxx:180
 TAuthenticate.cxx:181
 TAuthenticate.cxx:182
 TAuthenticate.cxx:183
 TAuthenticate.cxx:184
 TAuthenticate.cxx:185
 TAuthenticate.cxx:186
 TAuthenticate.cxx:187
 TAuthenticate.cxx:188
 TAuthenticate.cxx:189
 TAuthenticate.cxx:190
 TAuthenticate.cxx:191
 TAuthenticate.cxx:192
 TAuthenticate.cxx:193
 TAuthenticate.cxx:194
 TAuthenticate.cxx:195
 TAuthenticate.cxx:196
 TAuthenticate.cxx:197
 TAuthenticate.cxx:198
 TAuthenticate.cxx:199
 TAuthenticate.cxx:200
 TAuthenticate.cxx:201
 TAuthenticate.cxx:202
 TAuthenticate.cxx:203
 TAuthenticate.cxx:204
 TAuthenticate.cxx:205
 TAuthenticate.cxx:206
 TAuthenticate.cxx:207
 TAuthenticate.cxx:208
 TAuthenticate.cxx:209
 TAuthenticate.cxx:210
 TAuthenticate.cxx:211
 TAuthenticate.cxx:212
 TAuthenticate.cxx:213
 TAuthenticate.cxx:214
 TAuthenticate.cxx:215
 TAuthenticate.cxx:216
 TAuthenticate.cxx:217
 TAuthenticate.cxx:218
 TAuthenticate.cxx:219
 TAuthenticate.cxx:220
 TAuthenticate.cxx:221
 TAuthenticate.cxx:222
 TAuthenticate.cxx:223
 TAuthenticate.cxx:224
 TAuthenticate.cxx:225
 TAuthenticate.cxx:226
 TAuthenticate.cxx:227
 TAuthenticate.cxx:228
 TAuthenticate.cxx:229
 TAuthenticate.cxx:230
 TAuthenticate.cxx:231
 TAuthenticate.cxx:232
 TAuthenticate.cxx:233
 TAuthenticate.cxx:234
 TAuthenticate.cxx:235
 TAuthenticate.cxx:236
 TAuthenticate.cxx:237
 TAuthenticate.cxx:238
 TAuthenticate.cxx:239
 TAuthenticate.cxx:240
 TAuthenticate.cxx:241
 TAuthenticate.cxx:242
 TAuthenticate.cxx:243
 TAuthenticate.cxx:244
 TAuthenticate.cxx:245
 TAuthenticate.cxx:246
 TAuthenticate.cxx:247
 TAuthenticate.cxx:248
 TAuthenticate.cxx:249
 TAuthenticate.cxx:250
 TAuthenticate.cxx:251
 TAuthenticate.cxx:252
 TAuthenticate.cxx:253
 TAuthenticate.cxx:254
 TAuthenticate.cxx:255
 TAuthenticate.cxx:256
 TAuthenticate.cxx:257
 TAuthenticate.cxx:258
 TAuthenticate.cxx:259
 TAuthenticate.cxx:260
 TAuthenticate.cxx:261
 TAuthenticate.cxx:262
 TAuthenticate.cxx:263
 TAuthenticate.cxx:264
 TAuthenticate.cxx:265
 TAuthenticate.cxx:266
 TAuthenticate.cxx:267
 TAuthenticate.cxx:268
 TAuthenticate.cxx:269
 TAuthenticate.cxx:270
 TAuthenticate.cxx:271
 TAuthenticate.cxx:272
 TAuthenticate.cxx:273
 TAuthenticate.cxx:274
 TAuthenticate.cxx:275
 TAuthenticate.cxx:276
 TAuthenticate.cxx:277
 TAuthenticate.cxx:278
 TAuthenticate.cxx:279
 TAuthenticate.cxx:280
 TAuthenticate.cxx:281
 TAuthenticate.cxx:282
 TAuthenticate.cxx:283
 TAuthenticate.cxx:284
 TAuthenticate.cxx:285
 TAuthenticate.cxx:286
 TAuthenticate.cxx:287
 TAuthenticate.cxx:288
 TAuthenticate.cxx:289
 TAuthenticate.cxx:290
 TAuthenticate.cxx:291
 TAuthenticate.cxx:292
 TAuthenticate.cxx:293
 TAuthenticate.cxx:294
 TAuthenticate.cxx:295
 TAuthenticate.cxx:296
 TAuthenticate.cxx:297
 TAuthenticate.cxx:298
 TAuthenticate.cxx:299
 TAuthenticate.cxx:300
 TAuthenticate.cxx:301
 TAuthenticate.cxx:302
 TAuthenticate.cxx:303
 TAuthenticate.cxx:304
 TAuthenticate.cxx:305
 TAuthenticate.cxx:306
 TAuthenticate.cxx:307
 TAuthenticate.cxx:308
 TAuthenticate.cxx:309
 TAuthenticate.cxx:310
 TAuthenticate.cxx:311
 TAuthenticate.cxx:312
 TAuthenticate.cxx:313
 TAuthenticate.cxx:314
 TAuthenticate.cxx:315
 TAuthenticate.cxx:316
 TAuthenticate.cxx:317
 TAuthenticate.cxx:318
 TAuthenticate.cxx:319
 TAuthenticate.cxx:320
 TAuthenticate.cxx:321
 TAuthenticate.cxx:322
 TAuthenticate.cxx:323
 TAuthenticate.cxx:324
 TAuthenticate.cxx:325
 TAuthenticate.cxx:326
 TAuthenticate.cxx:327
 TAuthenticate.cxx:328
 TAuthenticate.cxx:329
 TAuthenticate.cxx:330
 TAuthenticate.cxx:331
 TAuthenticate.cxx:332
 TAuthenticate.cxx:333
 TAuthenticate.cxx:334
 TAuthenticate.cxx:335
 TAuthenticate.cxx:336
 TAuthenticate.cxx:337
 TAuthenticate.cxx:338
 TAuthenticate.cxx:339
 TAuthenticate.cxx:340
 TAuthenticate.cxx:341
 TAuthenticate.cxx:342
 TAuthenticate.cxx:343
 TAuthenticate.cxx:344
 TAuthenticate.cxx:345
 TAuthenticate.cxx:346
 TAuthenticate.cxx:347
 TAuthenticate.cxx:348
 TAuthenticate.cxx:349
 TAuthenticate.cxx:350
 TAuthenticate.cxx:351
 TAuthenticate.cxx:352
 TAuthenticate.cxx:353
 TAuthenticate.cxx:354
 TAuthenticate.cxx:355
 TAuthenticate.cxx:356
 TAuthenticate.cxx:357
 TAuthenticate.cxx:358
 TAuthenticate.cxx:359
 TAuthenticate.cxx:360
 TAuthenticate.cxx:361
 TAuthenticate.cxx:362
 TAuthenticate.cxx:363
 TAuthenticate.cxx:364
 TAuthenticate.cxx:365
 TAuthenticate.cxx:366
 TAuthenticate.cxx:367
 TAuthenticate.cxx:368
 TAuthenticate.cxx:369
 TAuthenticate.cxx:370
 TAuthenticate.cxx:371
 TAuthenticate.cxx:372
 TAuthenticate.cxx:373
 TAuthenticate.cxx:374
 TAuthenticate.cxx:375
 TAuthenticate.cxx:376
 TAuthenticate.cxx:377
 TAuthenticate.cxx:378
 TAuthenticate.cxx:379
 TAuthenticate.cxx:380
 TAuthenticate.cxx:381
 TAuthenticate.cxx:382
 TAuthenticate.cxx:383
 TAuthenticate.cxx:384
 TAuthenticate.cxx:385
 TAuthenticate.cxx:386
 TAuthenticate.cxx:387
 TAuthenticate.cxx:388
 TAuthenticate.cxx:389
 TAuthenticate.cxx:390
 TAuthenticate.cxx:391
 TAuthenticate.cxx:392
 TAuthenticate.cxx:393
 TAuthenticate.cxx:394
 TAuthenticate.cxx:395
 TAuthenticate.cxx:396
 TAuthenticate.cxx:397
 TAuthenticate.cxx:398
 TAuthenticate.cxx:399
 TAuthenticate.cxx:400
 TAuthenticate.cxx:401
 TAuthenticate.cxx:402
 TAuthenticate.cxx:403
 TAuthenticate.cxx:404
 TAuthenticate.cxx:405
 TAuthenticate.cxx:406
 TAuthenticate.cxx:407
 TAuthenticate.cxx:408
 TAuthenticate.cxx:409
 TAuthenticate.cxx:410
 TAuthenticate.cxx:411
 TAuthenticate.cxx:412
 TAuthenticate.cxx:413
 TAuthenticate.cxx:414
 TAuthenticate.cxx:415
 TAuthenticate.cxx:416
 TAuthenticate.cxx:417
 TAuthenticate.cxx:418
 TAuthenticate.cxx:419
 TAuthenticate.cxx:420
 TAuthenticate.cxx:421
 TAuthenticate.cxx:422
 TAuthenticate.cxx:423
 TAuthenticate.cxx:424
 TAuthenticate.cxx:425
 TAuthenticate.cxx:426
 TAuthenticate.cxx:427
 TAuthenticate.cxx:428
 TAuthenticate.cxx:429
 TAuthenticate.cxx:430
 TAuthenticate.cxx:431
 TAuthenticate.cxx:432
 TAuthenticate.cxx:433
 TAuthenticate.cxx:434
 TAuthenticate.cxx:435
 TAuthenticate.cxx:436
 TAuthenticate.cxx:437
 TAuthenticate.cxx:438
 TAuthenticate.cxx:439
 TAuthenticate.cxx:440
 TAuthenticate.cxx:441
 TAuthenticate.cxx:442
 TAuthenticate.cxx:443
 TAuthenticate.cxx:444
 TAuthenticate.cxx:445
 TAuthenticate.cxx:446
 TAuthenticate.cxx:447
 TAuthenticate.cxx:448
 TAuthenticate.cxx:449
 TAuthenticate.cxx:450
 TAuthenticate.cxx:451
 TAuthenticate.cxx:452
 TAuthenticate.cxx:453
 TAuthenticate.cxx:454
 TAuthenticate.cxx:455
 TAuthenticate.cxx:456
 TAuthenticate.cxx:457
 TAuthenticate.cxx:458
 TAuthenticate.cxx:459
 TAuthenticate.cxx:460
 TAuthenticate.cxx:461
 TAuthenticate.cxx:462
 TAuthenticate.cxx:463
 TAuthenticate.cxx:464
 TAuthenticate.cxx:465
 TAuthenticate.cxx:466
 TAuthenticate.cxx:467
 TAuthenticate.cxx:468
 TAuthenticate.cxx:469
 TAuthenticate.cxx:470
 TAuthenticate.cxx:471
 TAuthenticate.cxx:472
 TAuthenticate.cxx:473
 TAuthenticate.cxx:474
 TAuthenticate.cxx:475
 TAuthenticate.cxx:476
 TAuthenticate.cxx:477
 TAuthenticate.cxx:478
 TAuthenticate.cxx:479
 TAuthenticate.cxx:480
 TAuthenticate.cxx:481
 TAuthenticate.cxx:482
 TAuthenticate.cxx:483
 TAuthenticate.cxx:484
 TAuthenticate.cxx:485
 TAuthenticate.cxx:486
 TAuthenticate.cxx:487
 TAuthenticate.cxx:488
 TAuthenticate.cxx:489
 TAuthenticate.cxx:490
 TAuthenticate.cxx:491
 TAuthenticate.cxx:492
 TAuthenticate.cxx:493
 TAuthenticate.cxx:494
 TAuthenticate.cxx:495
 TAuthenticate.cxx:496
 TAuthenticate.cxx:497
 TAuthenticate.cxx:498
 TAuthenticate.cxx:499
 TAuthenticate.cxx:500
 TAuthenticate.cxx:501
 TAuthenticate.cxx:502
 TAuthenticate.cxx:503
 TAuthenticate.cxx:504
 TAuthenticate.cxx:505
 TAuthenticate.cxx:506
 TAuthenticate.cxx:507
 TAuthenticate.cxx:508
 TAuthenticate.cxx:509
 TAuthenticate.cxx:510
 TAuthenticate.cxx:511
 TAuthenticate.cxx:512
 TAuthenticate.cxx:513
 TAuthenticate.cxx:514
 TAuthenticate.cxx:515
 TAuthenticate.cxx:516
 TAuthenticate.cxx:517
 TAuthenticate.cxx:518
 TAuthenticate.cxx:519
 TAuthenticate.cxx:520
 TAuthenticate.cxx:521
 TAuthenticate.cxx:522
 TAuthenticate.cxx:523
 TAuthenticate.cxx:524
 TAuthenticate.cxx:525
 TAuthenticate.cxx:526
 TAuthenticate.cxx:527
 TAuthenticate.cxx:528
 TAuthenticate.cxx:529
 TAuthenticate.cxx:530
 TAuthenticate.cxx:531
 TAuthenticate.cxx:532
 TAuthenticate.cxx:533
 TAuthenticate.cxx:534
 TAuthenticate.cxx:535
 TAuthenticate.cxx:536
 TAuthenticate.cxx:537
 TAuthenticate.cxx:538
 TAuthenticate.cxx:539
 TAuthenticate.cxx:540
 TAuthenticate.cxx:541
 TAuthenticate.cxx:542
 TAuthenticate.cxx:543
 TAuthenticate.cxx:544
 TAuthenticate.cxx:545
 TAuthenticate.cxx:546
 TAuthenticate.cxx:547
 TAuthenticate.cxx:548
 TAuthenticate.cxx:549
 TAuthenticate.cxx:550
 TAuthenticate.cxx:551
 TAuthenticate.cxx:552
 TAuthenticate.cxx:553
 TAuthenticate.cxx:554
 TAuthenticate.cxx:555
 TAuthenticate.cxx:556
 TAuthenticate.cxx:557
 TAuthenticate.cxx:558
 TAuthenticate.cxx:559
 TAuthenticate.cxx:560
 TAuthenticate.cxx:561
 TAuthenticate.cxx:562
 TAuthenticate.cxx:563
 TAuthenticate.cxx:564
 TAuthenticate.cxx:565
 TAuthenticate.cxx:566
 TAuthenticate.cxx:567
 TAuthenticate.cxx:568
 TAuthenticate.cxx:569
 TAuthenticate.cxx:570
 TAuthenticate.cxx:571
 TAuthenticate.cxx:572
 TAuthenticate.cxx:573
 TAuthenticate.cxx:574
 TAuthenticate.cxx:575
 TAuthenticate.cxx:576
 TAuthenticate.cxx:577
 TAuthenticate.cxx:578
 TAuthenticate.cxx:579
 TAuthenticate.cxx:580
 TAuthenticate.cxx:581
 TAuthenticate.cxx:582
 TAuthenticate.cxx:583
 TAuthenticate.cxx:584
 TAuthenticate.cxx:585
 TAuthenticate.cxx:586
 TAuthenticate.cxx:587
 TAuthenticate.cxx:588
 TAuthenticate.cxx:589
 TAuthenticate.cxx:590
 TAuthenticate.cxx:591
 TAuthenticate.cxx:592
 TAuthenticate.cxx:593
 TAuthenticate.cxx:594
 TAuthenticate.cxx:595
 TAuthenticate.cxx:596
 TAuthenticate.cxx:597
 TAuthenticate.cxx:598
 TAuthenticate.cxx:599
 TAuthenticate.cxx:600
 TAuthenticate.cxx:601
 TAuthenticate.cxx:602
 TAuthenticate.cxx:603
 TAuthenticate.cxx:604
 TAuthenticate.cxx:605
 TAuthenticate.cxx:606
 TAuthenticate.cxx:607
 TAuthenticate.cxx:608
 TAuthenticate.cxx:609
 TAuthenticate.cxx:610
 TAuthenticate.cxx:611
 TAuthenticate.cxx:612
 TAuthenticate.cxx:613
 TAuthenticate.cxx:614
 TAuthenticate.cxx:615
 TAuthenticate.cxx:616
 TAuthenticate.cxx:617
 TAuthenticate.cxx:618
 TAuthenticate.cxx:619
 TAuthenticate.cxx:620
 TAuthenticate.cxx:621
 TAuthenticate.cxx:622
 TAuthenticate.cxx:623
 TAuthenticate.cxx:624
 TAuthenticate.cxx:625
 TAuthenticate.cxx:626
 TAuthenticate.cxx:627
 TAuthenticate.cxx:628
 TAuthenticate.cxx:629
 TAuthenticate.cxx:630
 TAuthenticate.cxx:631
 TAuthenticate.cxx:632
 TAuthenticate.cxx:633
 TAuthenticate.cxx:634
 TAuthenticate.cxx:635
 TAuthenticate.cxx:636
 TAuthenticate.cxx:637
 TAuthenticate.cxx:638
 TAuthenticate.cxx:639
 TAuthenticate.cxx:640
 TAuthenticate.cxx:641
 TAuthenticate.cxx:642
 TAuthenticate.cxx:643
 TAuthenticate.cxx:644
 TAuthenticate.cxx:645
 TAuthenticate.cxx:646
 TAuthenticate.cxx:647
 TAuthenticate.cxx:648
 TAuthenticate.cxx:649
 TAuthenticate.cxx:650
 TAuthenticate.cxx:651
 TAuthenticate.cxx:652
 TAuthenticate.cxx:653
 TAuthenticate.cxx:654
 TAuthenticate.cxx:655
 TAuthenticate.cxx:656
 TAuthenticate.cxx:657
 TAuthenticate.cxx:658
 TAuthenticate.cxx:659
 TAuthenticate.cxx:660
 TAuthenticate.cxx:661
 TAuthenticate.cxx:662
 TAuthenticate.cxx:663
 TAuthenticate.cxx:664
 TAuthenticate.cxx:665
 TAuthenticate.cxx:666
 TAuthenticate.cxx:667
 TAuthenticate.cxx:668
 TAuthenticate.cxx:669
 TAuthenticate.cxx:670
 TAuthenticate.cxx:671
 TAuthenticate.cxx:672
 TAuthenticate.cxx:673
 TAuthenticate.cxx:674
 TAuthenticate.cxx:675
 TAuthenticate.cxx:676
 TAuthenticate.cxx:677
 TAuthenticate.cxx:678
 TAuthenticate.cxx:679
 TAuthenticate.cxx:680
 TAuthenticate.cxx:681
 TAuthenticate.cxx:682
 TAuthenticate.cxx:683
 TAuthenticate.cxx:684
 TAuthenticate.cxx:685
 TAuthenticate.cxx:686
 TAuthenticate.cxx:687
 TAuthenticate.cxx:688
 TAuthenticate.cxx:689
 TAuthenticate.cxx:690
 TAuthenticate.cxx:691
 TAuthenticate.cxx:692
 TAuthenticate.cxx:693
 TAuthenticate.cxx:694
 TAuthenticate.cxx:695
 TAuthenticate.cxx:696
 TAuthenticate.cxx:697
 TAuthenticate.cxx:698
 TAuthenticate.cxx:699
 TAuthenticate.cxx:700
 TAuthenticate.cxx:701
 TAuthenticate.cxx:702
 TAuthenticate.cxx:703
 TAuthenticate.cxx:704
 TAuthenticate.cxx:705
 TAuthenticate.cxx:706
 TAuthenticate.cxx:707
 TAuthenticate.cxx:708
 TAuthenticate.cxx:709
 TAuthenticate.cxx:710
 TAuthenticate.cxx:711
 TAuthenticate.cxx:712
 TAuthenticate.cxx:713
 TAuthenticate.cxx:714
 TAuthenticate.cxx:715
 TAuthenticate.cxx:716
 TAuthenticate.cxx:717
 TAuthenticate.cxx:718
 TAuthenticate.cxx:719
 TAuthenticate.cxx:720
 TAuthenticate.cxx:721
 TAuthenticate.cxx:722
 TAuthenticate.cxx:723
 TAuthenticate.cxx:724
 TAuthenticate.cxx:725
 TAuthenticate.cxx:726
 TAuthenticate.cxx:727
 TAuthenticate.cxx:728
 TAuthenticate.cxx:729
 TAuthenticate.cxx:730
 TAuthenticate.cxx:731
 TAuthenticate.cxx:732
 TAuthenticate.cxx:733
 TAuthenticate.cxx:734
 TAuthenticate.cxx:735
 TAuthenticate.cxx:736
 TAuthenticate.cxx:737
 TAuthenticate.cxx:738
 TAuthenticate.cxx:739
 TAuthenticate.cxx:740
 TAuthenticate.cxx:741
 TAuthenticate.cxx:742
 TAuthenticate.cxx:743
 TAuthenticate.cxx:744
 TAuthenticate.cxx:745
 TAuthenticate.cxx:746
 TAuthenticate.cxx:747
 TAuthenticate.cxx:748
 TAuthenticate.cxx:749
 TAuthenticate.cxx:750
 TAuthenticate.cxx:751
 TAuthenticate.cxx:752
 TAuthenticate.cxx:753
 TAuthenticate.cxx:754
 TAuthenticate.cxx:755
 TAuthenticate.cxx:756
 TAuthenticate.cxx:757
 TAuthenticate.cxx:758
 TAuthenticate.cxx:759
 TAuthenticate.cxx:760
 TAuthenticate.cxx:761
 TAuthenticate.cxx:762
 TAuthenticate.cxx:763
 TAuthenticate.cxx:764
 TAuthenticate.cxx:765
 TAuthenticate.cxx:766
 TAuthenticate.cxx:767
 TAuthenticate.cxx:768
 TAuthenticate.cxx:769
 TAuthenticate.cxx:770
 TAuthenticate.cxx:771
 TAuthenticate.cxx:772
 TAuthenticate.cxx:773
 TAuthenticate.cxx:774
 TAuthenticate.cxx:775
 TAuthenticate.cxx:776
 TAuthenticate.cxx:777
 TAuthenticate.cxx:778
 TAuthenticate.cxx:779
 TAuthenticate.cxx:780
 TAuthenticate.cxx:781
 TAuthenticate.cxx:782
 TAuthenticate.cxx:783
 TAuthenticate.cxx:784
 TAuthenticate.cxx:785
 TAuthenticate.cxx:786
 TAuthenticate.cxx:787
 TAuthenticate.cxx:788
 TAuthenticate.cxx:789
 TAuthenticate.cxx:790
 TAuthenticate.cxx:791
 TAuthenticate.cxx:792
 TAuthenticate.cxx:793
 TAuthenticate.cxx:794
 TAuthenticate.cxx:795
 TAuthenticate.cxx:796
 TAuthenticate.cxx:797
 TAuthenticate.cxx:798
 TAuthenticate.cxx:799
 TAuthenticate.cxx:800
 TAuthenticate.cxx:801
 TAuthenticate.cxx:802
 TAuthenticate.cxx:803
 TAuthenticate.cxx:804
 TAuthenticate.cxx:805
 TAuthenticate.cxx:806
 TAuthenticate.cxx:807
 TAuthenticate.cxx:808
 TAuthenticate.cxx:809
 TAuthenticate.cxx:810
 TAuthenticate.cxx:811
 TAuthenticate.cxx:812
 TAuthenticate.cxx:813
 TAuthenticate.cxx:814
 TAuthenticate.cxx:815
 TAuthenticate.cxx:816
 TAuthenticate.cxx:817
 TAuthenticate.cxx:818
 TAuthenticate.cxx:819
 TAuthenticate.cxx:820
 TAuthenticate.cxx:821
 TAuthenticate.cxx:822
 TAuthenticate.cxx:823
 TAuthenticate.cxx:824
 TAuthenticate.cxx:825
 TAuthenticate.cxx:826
 TAuthenticate.cxx:827
 TAuthenticate.cxx:828
 TAuthenticate.cxx:829
 TAuthenticate.cxx:830
 TAuthenticate.cxx:831
 TAuthenticate.cxx:832
 TAuthenticate.cxx:833
 TAuthenticate.cxx:834
 TAuthenticate.cxx:835
 TAuthenticate.cxx:836
 TAuthenticate.cxx:837
 TAuthenticate.cxx:838
 TAuthenticate.cxx:839
 TAuthenticate.cxx:840
 TAuthenticate.cxx:841
 TAuthenticate.cxx:842
 TAuthenticate.cxx:843
 TAuthenticate.cxx:844
 TAuthenticate.cxx:845
 TAuthenticate.cxx:846
 TAuthenticate.cxx:847
 TAuthenticate.cxx:848
 TAuthenticate.cxx:849
 TAuthenticate.cxx:850
 TAuthenticate.cxx:851
 TAuthenticate.cxx:852
 TAuthenticate.cxx:853
 TAuthenticate.cxx:854
 TAuthenticate.cxx:855
 TAuthenticate.cxx:856
 TAuthenticate.cxx:857
 TAuthenticate.cxx:858
 TAuthenticate.cxx:859
 TAuthenticate.cxx:860
 TAuthenticate.cxx:861
 TAuthenticate.cxx:862
 TAuthenticate.cxx:863
 TAuthenticate.cxx:864
 TAuthenticate.cxx:865
 TAuthenticate.cxx:866
 TAuthenticate.cxx:867
 TAuthenticate.cxx:868
 TAuthenticate.cxx:869
 TAuthenticate.cxx:870
 TAuthenticate.cxx:871
 TAuthenticate.cxx:872
 TAuthenticate.cxx:873
 TAuthenticate.cxx:874
 TAuthenticate.cxx:875
 TAuthenticate.cxx:876
 TAuthenticate.cxx:877
 TAuthenticate.cxx:878
 TAuthenticate.cxx:879
 TAuthenticate.cxx:880
 TAuthenticate.cxx:881
 TAuthenticate.cxx:882
 TAuthenticate.cxx:883
 TAuthenticate.cxx:884
 TAuthenticate.cxx:885
 TAuthenticate.cxx:886
 TAuthenticate.cxx:887
 TAuthenticate.cxx:888
 TAuthenticate.cxx:889
 TAuthenticate.cxx:890
 TAuthenticate.cxx:891
 TAuthenticate.cxx:892
 TAuthenticate.cxx:893
 TAuthenticate.cxx:894
 TAuthenticate.cxx:895
 TAuthenticate.cxx:896
 TAuthenticate.cxx:897
 TAuthenticate.cxx:898
 TAuthenticate.cxx:899
 TAuthenticate.cxx:900
 TAuthenticate.cxx:901
 TAuthenticate.cxx:902
 TAuthenticate.cxx:903
 TAuthenticate.cxx:904
 TAuthenticate.cxx:905
 TAuthenticate.cxx:906
 TAuthenticate.cxx:907
 TAuthenticate.cxx:908
 TAuthenticate.cxx:909
 TAuthenticate.cxx:910
 TAuthenticate.cxx:911
 TAuthenticate.cxx:912
 TAuthenticate.cxx:913
 TAuthenticate.cxx:914
 TAuthenticate.cxx:915
 TAuthenticate.cxx:916
 TAuthenticate.cxx:917
 TAuthenticate.cxx:918
 TAuthenticate.cxx:919
 TAuthenticate.cxx:920
 TAuthenticate.cxx:921
 TAuthenticate.cxx:922
 TAuthenticate.cxx:923
 TAuthenticate.cxx:924
 TAuthenticate.cxx:925
 TAuthenticate.cxx:926
 TAuthenticate.cxx:927
 TAuthenticate.cxx:928
 TAuthenticate.cxx:929
 TAuthenticate.cxx:930
 TAuthenticate.cxx:931
 TAuthenticate.cxx:932
 TAuthenticate.cxx:933
 TAuthenticate.cxx:934
 TAuthenticate.cxx:935
 TAuthenticate.cxx:936
 TAuthenticate.cxx:937
 TAuthenticate.cxx:938
 TAuthenticate.cxx:939
 TAuthenticate.cxx:940
 TAuthenticate.cxx:941
 TAuthenticate.cxx:942
 TAuthenticate.cxx:943
 TAuthenticate.cxx:944
 TAuthenticate.cxx:945
 TAuthenticate.cxx:946
 TAuthenticate.cxx:947
 TAuthenticate.cxx:948
 TAuthenticate.cxx:949
 TAuthenticate.cxx:950
 TAuthenticate.cxx:951
 TAuthenticate.cxx:952
 TAuthenticate.cxx:953
 TAuthenticate.cxx:954
 TAuthenticate.cxx:955
 TAuthenticate.cxx:956
 TAuthenticate.cxx:957
 TAuthenticate.cxx:958
 TAuthenticate.cxx:959
 TAuthenticate.cxx:960
 TAuthenticate.cxx:961
 TAuthenticate.cxx:962
 TAuthenticate.cxx:963
 TAuthenticate.cxx:964
 TAuthenticate.cxx:965
 TAuthenticate.cxx:966
 TAuthenticate.cxx:967
 TAuthenticate.cxx:968
 TAuthenticate.cxx:969
 TAuthenticate.cxx:970
 TAuthenticate.cxx:971
 TAuthenticate.cxx:972
 TAuthenticate.cxx:973
 TAuthenticate.cxx:974
 TAuthenticate.cxx:975
 TAuthenticate.cxx:976
 TAuthenticate.cxx:977
 TAuthenticate.cxx:978
 TAuthenticate.cxx:979
 TAuthenticate.cxx:980
 TAuthenticate.cxx:981
 TAuthenticate.cxx:982
 TAuthenticate.cxx:983
 TAuthenticate.cxx:984
 TAuthenticate.cxx:985
 TAuthenticate.cxx:986
 TAuthenticate.cxx:987
 TAuthenticate.cxx:988
 TAuthenticate.cxx:989
 TAuthenticate.cxx:990
 TAuthenticate.cxx:991
 TAuthenticate.cxx:992
 TAuthenticate.cxx:993
 TAuthenticate.cxx:994
 TAuthenticate.cxx:995
 TAuthenticate.cxx:996
 TAuthenticate.cxx:997
 TAuthenticate.cxx:998
 TAuthenticate.cxx:999
 TAuthenticate.cxx:1000
 TAuthenticate.cxx:1001
 TAuthenticate.cxx:1002
 TAuthenticate.cxx:1003
 TAuthenticate.cxx:1004
 TAuthenticate.cxx:1005
 TAuthenticate.cxx:1006
 TAuthenticate.cxx:1007
 TAuthenticate.cxx:1008
 TAuthenticate.cxx:1009
 TAuthenticate.cxx:1010
 TAuthenticate.cxx:1011
 TAuthenticate.cxx:1012
 TAuthenticate.cxx:1013
 TAuthenticate.cxx:1014
 TAuthenticate.cxx:1015
 TAuthenticate.cxx:1016
 TAuthenticate.cxx:1017
 TAuthenticate.cxx:1018
 TAuthenticate.cxx:1019
 TAuthenticate.cxx:1020
 TAuthenticate.cxx:1021
 TAuthenticate.cxx:1022
 TAuthenticate.cxx:1023
 TAuthenticate.cxx:1024
 TAuthenticate.cxx:1025
 TAuthenticate.cxx:1026
 TAuthenticate.cxx:1027
 TAuthenticate.cxx:1028
 TAuthenticate.cxx:1029
 TAuthenticate.cxx:1030
 TAuthenticate.cxx:1031
 TAuthenticate.cxx:1032
 TAuthenticate.cxx:1033
 TAuthenticate.cxx:1034
 TAuthenticate.cxx:1035
 TAuthenticate.cxx:1036
 TAuthenticate.cxx:1037
 TAuthenticate.cxx:1038
 TAuthenticate.cxx:1039
 TAuthenticate.cxx:1040
 TAuthenticate.cxx:1041
 TAuthenticate.cxx:1042
 TAuthenticate.cxx:1043
 TAuthenticate.cxx:1044
 TAuthenticate.cxx:1045
 TAuthenticate.cxx:1046
 TAuthenticate.cxx:1047
 TAuthenticate.cxx:1048
 TAuthenticate.cxx:1049
 TAuthenticate.cxx:1050
 TAuthenticate.cxx:1051
 TAuthenticate.cxx:1052
 TAuthenticate.cxx:1053
 TAuthenticate.cxx:1054
 TAuthenticate.cxx:1055
 TAuthenticate.cxx:1056
 TAuthenticate.cxx:1057
 TAuthenticate.cxx:1058
 TAuthenticate.cxx:1059
 TAuthenticate.cxx:1060
 TAuthenticate.cxx:1061
 TAuthenticate.cxx:1062
 TAuthenticate.cxx:1063
 TAuthenticate.cxx:1064
 TAuthenticate.cxx:1065
 TAuthenticate.cxx:1066
 TAuthenticate.cxx:1067
 TAuthenticate.cxx:1068
 TAuthenticate.cxx:1069
 TAuthenticate.cxx:1070
 TAuthenticate.cxx:1071
 TAuthenticate.cxx:1072
 TAuthenticate.cxx:1073
 TAuthenticate.cxx:1074
 TAuthenticate.cxx:1075
 TAuthenticate.cxx:1076
 TAuthenticate.cxx:1077
 TAuthenticate.cxx:1078
 TAuthenticate.cxx:1079
 TAuthenticate.cxx:1080
 TAuthenticate.cxx:1081
 TAuthenticate.cxx:1082
 TAuthenticate.cxx:1083
 TAuthenticate.cxx:1084
 TAuthenticate.cxx:1085
 TAuthenticate.cxx:1086
 TAuthenticate.cxx:1087
 TAuthenticate.cxx:1088
 TAuthenticate.cxx:1089
 TAuthenticate.cxx:1090
 TAuthenticate.cxx:1091
 TAuthenticate.cxx:1092
 TAuthenticate.cxx:1093
 TAuthenticate.cxx:1094
 TAuthenticate.cxx:1095
 TAuthenticate.cxx:1096
 TAuthenticate.cxx:1097
 TAuthenticate.cxx:1098
 TAuthenticate.cxx:1099
 TAuthenticate.cxx:1100
 TAuthenticate.cxx:1101
 TAuthenticate.cxx:1102
 TAuthenticate.cxx:1103
 TAuthenticate.cxx:1104
 TAuthenticate.cxx:1105
 TAuthenticate.cxx:1106
 TAuthenticate.cxx:1107
 TAuthenticate.cxx:1108
 TAuthenticate.cxx:1109
 TAuthenticate.cxx:1110
 TAuthenticate.cxx:1111
 TAuthenticate.cxx:1112
 TAuthenticate.cxx:1113
 TAuthenticate.cxx:1114
 TAuthenticate.cxx:1115
 TAuthenticate.cxx:1116
 TAuthenticate.cxx:1117
 TAuthenticate.cxx:1118
 TAuthenticate.cxx:1119
 TAuthenticate.cxx:1120
 TAuthenticate.cxx:1121
 TAuthenticate.cxx:1122
 TAuthenticate.cxx:1123
 TAuthenticate.cxx:1124
 TAuthenticate.cxx:1125
 TAuthenticate.cxx:1126
 TAuthenticate.cxx:1127
 TAuthenticate.cxx:1128
 TAuthenticate.cxx:1129
 TAuthenticate.cxx:1130
 TAuthenticate.cxx:1131
 TAuthenticate.cxx:1132
 TAuthenticate.cxx:1133
 TAuthenticate.cxx:1134
 TAuthenticate.cxx:1135
 TAuthenticate.cxx:1136
 TAuthenticate.cxx:1137
 TAuthenticate.cxx:1138
 TAuthenticate.cxx:1139
 TAuthenticate.cxx:1140
 TAuthenticate.cxx:1141
 TAuthenticate.cxx:1142
 TAuthenticate.cxx:1143
 TAuthenticate.cxx:1144
 TAuthenticate.cxx:1145
 TAuthenticate.cxx:1146
 TAuthenticate.cxx:1147
 TAuthenticate.cxx:1148
 TAuthenticate.cxx:1149
 TAuthenticate.cxx:1150
 TAuthenticate.cxx:1151
 TAuthenticate.cxx:1152
 TAuthenticate.cxx:1153
 TAuthenticate.cxx:1154
 TAuthenticate.cxx:1155
 TAuthenticate.cxx:1156
 TAuthenticate.cxx:1157
 TAuthenticate.cxx:1158
 TAuthenticate.cxx:1159
 TAuthenticate.cxx:1160
 TAuthenticate.cxx:1161
 TAuthenticate.cxx:1162
 TAuthenticate.cxx:1163
 TAuthenticate.cxx:1164
 TAuthenticate.cxx:1165
 TAuthenticate.cxx:1166
 TAuthenticate.cxx:1167
 TAuthenticate.cxx:1168
 TAuthenticate.cxx:1169
 TAuthenticate.cxx:1170
 TAuthenticate.cxx:1171
 TAuthenticate.cxx:1172
 TAuthenticate.cxx:1173
 TAuthenticate.cxx:1174
 TAuthenticate.cxx:1175
 TAuthenticate.cxx:1176
 TAuthenticate.cxx:1177
 TAuthenticate.cxx:1178
 TAuthenticate.cxx:1179
 TAuthenticate.cxx:1180
 TAuthenticate.cxx:1181
 TAuthenticate.cxx:1182
 TAuthenticate.cxx:1183
 TAuthenticate.cxx:1184
 TAuthenticate.cxx:1185
 TAuthenticate.cxx:1186
 TAuthenticate.cxx:1187
 TAuthenticate.cxx:1188
 TAuthenticate.cxx:1189
 TAuthenticate.cxx:1190
 TAuthenticate.cxx:1191
 TAuthenticate.cxx:1192
 TAuthenticate.cxx:1193
 TAuthenticate.cxx:1194
 TAuthenticate.cxx:1195
 TAuthenticate.cxx:1196
 TAuthenticate.cxx:1197
 TAuthenticate.cxx:1198
 TAuthenticate.cxx:1199
 TAuthenticate.cxx:1200
 TAuthenticate.cxx:1201
 TAuthenticate.cxx:1202
 TAuthenticate.cxx:1203
 TAuthenticate.cxx:1204
 TAuthenticate.cxx:1205
 TAuthenticate.cxx:1206
 TAuthenticate.cxx:1207
 TAuthenticate.cxx:1208
 TAuthenticate.cxx:1209
 TAuthenticate.cxx:1210
 TAuthenticate.cxx:1211
 TAuthenticate.cxx:1212
 TAuthenticate.cxx:1213
 TAuthenticate.cxx:1214
 TAuthenticate.cxx:1215
 TAuthenticate.cxx:1216
 TAuthenticate.cxx:1217
 TAuthenticate.cxx:1218
 TAuthenticate.cxx:1219
 TAuthenticate.cxx:1220
 TAuthenticate.cxx:1221
 TAuthenticate.cxx:1222
 TAuthenticate.cxx:1223
 TAuthenticate.cxx:1224
 TAuthenticate.cxx:1225
 TAuthenticate.cxx:1226
 TAuthenticate.cxx:1227
 TAuthenticate.cxx:1228
 TAuthenticate.cxx:1229
 TAuthenticate.cxx:1230
 TAuthenticate.cxx:1231
 TAuthenticate.cxx:1232
 TAuthenticate.cxx:1233
 TAuthenticate.cxx:1234
 TAuthenticate.cxx:1235
 TAuthenticate.cxx:1236
 TAuthenticate.cxx:1237
 TAuthenticate.cxx:1238
 TAuthenticate.cxx:1239
 TAuthenticate.cxx:1240
 TAuthenticate.cxx:1241
 TAuthenticate.cxx:1242
 TAuthenticate.cxx:1243
 TAuthenticate.cxx:1244
 TAuthenticate.cxx:1245
 TAuthenticate.cxx:1246
 TAuthenticate.cxx:1247
 TAuthenticate.cxx:1248
 TAuthenticate.cxx:1249
 TAuthenticate.cxx:1250
 TAuthenticate.cxx:1251
 TAuthenticate.cxx:1252
 TAuthenticate.cxx:1253
 TAuthenticate.cxx:1254
 TAuthenticate.cxx:1255
 TAuthenticate.cxx:1256
 TAuthenticate.cxx:1257
 TAuthenticate.cxx:1258
 TAuthenticate.cxx:1259
 TAuthenticate.cxx:1260
 TAuthenticate.cxx:1261
 TAuthenticate.cxx:1262
 TAuthenticate.cxx:1263
 TAuthenticate.cxx:1264
 TAuthenticate.cxx:1265
 TAuthenticate.cxx:1266
 TAuthenticate.cxx:1267
 TAuthenticate.cxx:1268
 TAuthenticate.cxx:1269
 TAuthenticate.cxx:1270
 TAuthenticate.cxx:1271
 TAuthenticate.cxx:1272
 TAuthenticate.cxx:1273
 TAuthenticate.cxx:1274
 TAuthenticate.cxx:1275
 TAuthenticate.cxx:1276
 TAuthenticate.cxx:1277
 TAuthenticate.cxx:1278
 TAuthenticate.cxx:1279
 TAuthenticate.cxx:1280
 TAuthenticate.cxx:1281
 TAuthenticate.cxx:1282
 TAuthenticate.cxx:1283
 TAuthenticate.cxx:1284
 TAuthenticate.cxx:1285
 TAuthenticate.cxx:1286
 TAuthenticate.cxx:1287
 TAuthenticate.cxx:1288
 TAuthenticate.cxx:1289
 TAuthenticate.cxx:1290
 TAuthenticate.cxx:1291
 TAuthenticate.cxx:1292
 TAuthenticate.cxx:1293
 TAuthenticate.cxx:1294
 TAuthenticate.cxx:1295
 TAuthenticate.cxx:1296
 TAuthenticate.cxx:1297
 TAuthenticate.cxx:1298
 TAuthenticate.cxx:1299
 TAuthenticate.cxx:1300
 TAuthenticate.cxx:1301
 TAuthenticate.cxx:1302
 TAuthenticate.cxx:1303
 TAuthenticate.cxx:1304
 TAuthenticate.cxx:1305
 TAuthenticate.cxx:1306
 TAuthenticate.cxx:1307
 TAuthenticate.cxx:1308
 TAuthenticate.cxx:1309
 TAuthenticate.cxx:1310
 TAuthenticate.cxx:1311
 TAuthenticate.cxx:1312
 TAuthenticate.cxx:1313
 TAuthenticate.cxx:1314
 TAuthenticate.cxx:1315
 TAuthenticate.cxx:1316
 TAuthenticate.cxx:1317
 TAuthenticate.cxx:1318
 TAuthenticate.cxx:1319
 TAuthenticate.cxx:1320
 TAuthenticate.cxx:1321
 TAuthenticate.cxx:1322
 TAuthenticate.cxx:1323
 TAuthenticate.cxx:1324
 TAuthenticate.cxx:1325
 TAuthenticate.cxx:1326
 TAuthenticate.cxx:1327
 TAuthenticate.cxx:1328
 TAuthenticate.cxx:1329
 TAuthenticate.cxx:1330
 TAuthenticate.cxx:1331
 TAuthenticate.cxx:1332
 TAuthenticate.cxx:1333
 TAuthenticate.cxx:1334
 TAuthenticate.cxx:1335
 TAuthenticate.cxx:1336
 TAuthenticate.cxx:1337
 TAuthenticate.cxx:1338
 TAuthenticate.cxx:1339
 TAuthenticate.cxx:1340
 TAuthenticate.cxx:1341
 TAuthenticate.cxx:1342
 TAuthenticate.cxx:1343
 TAuthenticate.cxx:1344
 TAuthenticate.cxx:1345
 TAuthenticate.cxx:1346
 TAuthenticate.cxx:1347
 TAuthenticate.cxx:1348
 TAuthenticate.cxx:1349
 TAuthenticate.cxx:1350
 TAuthenticate.cxx:1351
 TAuthenticate.cxx:1352
 TAuthenticate.cxx:1353
 TAuthenticate.cxx:1354
 TAuthenticate.cxx:1355
 TAuthenticate.cxx:1356
 TAuthenticate.cxx:1357
 TAuthenticate.cxx:1358
 TAuthenticate.cxx:1359
 TAuthenticate.cxx:1360
 TAuthenticate.cxx:1361
 TAuthenticate.cxx:1362
 TAuthenticate.cxx:1363
 TAuthenticate.cxx:1364
 TAuthenticate.cxx:1365
 TAuthenticate.cxx:1366
 TAuthenticate.cxx:1367
 TAuthenticate.cxx:1368
 TAuthenticate.cxx:1369
 TAuthenticate.cxx:1370
 TAuthenticate.cxx:1371
 TAuthenticate.cxx:1372
 TAuthenticate.cxx:1373
 TAuthenticate.cxx:1374
 TAuthenticate.cxx:1375
 TAuthenticate.cxx:1376
 TAuthenticate.cxx:1377
 TAuthenticate.cxx:1378
 TAuthenticate.cxx:1379
 TAuthenticate.cxx:1380
 TAuthenticate.cxx:1381
 TAuthenticate.cxx:1382
 TAuthenticate.cxx:1383
 TAuthenticate.cxx:1384
 TAuthenticate.cxx:1385
 TAuthenticate.cxx:1386
 TAuthenticate.cxx:1387
 TAuthenticate.cxx:1388
 TAuthenticate.cxx:1389
 TAuthenticate.cxx:1390
 TAuthenticate.cxx:1391
 TAuthenticate.cxx:1392
 TAuthenticate.cxx:1393
 TAuthenticate.cxx:1394
 TAuthenticate.cxx:1395
 TAuthenticate.cxx:1396
 TAuthenticate.cxx:1397
 TAuthenticate.cxx:1398
 TAuthenticate.cxx:1399
 TAuthenticate.cxx:1400
 TAuthenticate.cxx:1401
 TAuthenticate.cxx:1402
 TAuthenticate.cxx:1403
 TAuthenticate.cxx:1404
 TAuthenticate.cxx:1405
 TAuthenticate.cxx:1406
 TAuthenticate.cxx:1407
 TAuthenticate.cxx:1408
 TAuthenticate.cxx:1409
 TAuthenticate.cxx:1410
 TAuthenticate.cxx:1411
 TAuthenticate.cxx:1412
 TAuthenticate.cxx:1413
 TAuthenticate.cxx:1414
 TAuthenticate.cxx:1415
 TAuthenticate.cxx:1416
 TAuthenticate.cxx:1417
 TAuthenticate.cxx:1418
 TAuthenticate.cxx:1419
 TAuthenticate.cxx:1420
 TAuthenticate.cxx:1421
 TAuthenticate.cxx:1422
 TAuthenticate.cxx:1423
 TAuthenticate.cxx:1424
 TAuthenticate.cxx:1425
 TAuthenticate.cxx:1426
 TAuthenticate.cxx:1427
 TAuthenticate.cxx:1428
 TAuthenticate.cxx:1429
 TAuthenticate.cxx:1430
 TAuthenticate.cxx:1431
 TAuthenticate.cxx:1432
 TAuthenticate.cxx:1433
 TAuthenticate.cxx:1434
 TAuthenticate.cxx:1435
 TAuthenticate.cxx:1436
 TAuthenticate.cxx:1437
 TAuthenticate.cxx:1438
 TAuthenticate.cxx:1439
 TAuthenticate.cxx:1440
 TAuthenticate.cxx:1441
 TAuthenticate.cxx:1442
 TAuthenticate.cxx:1443
 TAuthenticate.cxx:1444
 TAuthenticate.cxx:1445
 TAuthenticate.cxx:1446
 TAuthenticate.cxx:1447
 TAuthenticate.cxx:1448
 TAuthenticate.cxx:1449
 TAuthenticate.cxx:1450
 TAuthenticate.cxx:1451
 TAuthenticate.cxx:1452
 TAuthenticate.cxx:1453
 TAuthenticate.cxx:1454
 TAuthenticate.cxx:1455
 TAuthenticate.cxx:1456
 TAuthenticate.cxx:1457
 TAuthenticate.cxx:1458
 TAuthenticate.cxx:1459
 TAuthenticate.cxx:1460
 TAuthenticate.cxx:1461
 TAuthenticate.cxx:1462
 TAuthenticate.cxx:1463
 TAuthenticate.cxx:1464
 TAuthenticate.cxx:1465
 TAuthenticate.cxx:1466
 TAuthenticate.cxx:1467
 TAuthenticate.cxx:1468
 TAuthenticate.cxx:1469
 TAuthenticate.cxx:1470
 TAuthenticate.cxx:1471
 TAuthenticate.cxx:1472
 TAuthenticate.cxx:1473
 TAuthenticate.cxx:1474
 TAuthenticate.cxx:1475
 TAuthenticate.cxx:1476
 TAuthenticate.cxx:1477
 TAuthenticate.cxx:1478
 TAuthenticate.cxx:1479
 TAuthenticate.cxx:1480
 TAuthenticate.cxx:1481
 TAuthenticate.cxx:1482
 TAuthenticate.cxx:1483
 TAuthenticate.cxx:1484
 TAuthenticate.cxx:1485
 TAuthenticate.cxx:1486
 TAuthenticate.cxx:1487
 TAuthenticate.cxx:1488
 TAuthenticate.cxx:1489
 TAuthenticate.cxx:1490
 TAuthenticate.cxx:1491
 TAuthenticate.cxx:1492
 TAuthenticate.cxx:1493
 TAuthenticate.cxx:1494
 TAuthenticate.cxx:1495
 TAuthenticate.cxx:1496
 TAuthenticate.cxx:1497
 TAuthenticate.cxx:1498
 TAuthenticate.cxx:1499
 TAuthenticate.cxx:1500
 TAuthenticate.cxx:1501
 TAuthenticate.cxx:1502
 TAuthenticate.cxx:1503
 TAuthenticate.cxx:1504
 TAuthenticate.cxx:1505
 TAuthenticate.cxx:1506
 TAuthenticate.cxx:1507
 TAuthenticate.cxx:1508
 TAuthenticate.cxx:1509
 TAuthenticate.cxx:1510
 TAuthenticate.cxx:1511
 TAuthenticate.cxx:1512
 TAuthenticate.cxx:1513
 TAuthenticate.cxx:1514
 TAuthenticate.cxx:1515
 TAuthenticate.cxx:1516
 TAuthenticate.cxx:1517
 TAuthenticate.cxx:1518
 TAuthenticate.cxx:1519
 TAuthenticate.cxx:1520
 TAuthenticate.cxx:1521
 TAuthenticate.cxx:1522
 TAuthenticate.cxx:1523
 TAuthenticate.cxx:1524
 TAuthenticate.cxx:1525
 TAuthenticate.cxx:1526
 TAuthenticate.cxx:1527
 TAuthenticate.cxx:1528
 TAuthenticate.cxx:1529
 TAuthenticate.cxx:1530
 TAuthenticate.cxx:1531
 TAuthenticate.cxx:1532
 TAuthenticate.cxx:1533
 TAuthenticate.cxx:1534
 TAuthenticate.cxx:1535
 TAuthenticate.cxx:1536
 TAuthenticate.cxx:1537
 TAuthenticate.cxx:1538
 TAuthenticate.cxx:1539
 TAuthenticate.cxx:1540
 TAuthenticate.cxx:1541
 TAuthenticate.cxx:1542
 TAuthenticate.cxx:1543
 TAuthenticate.cxx:1544
 TAuthenticate.cxx:1545
 TAuthenticate.cxx:1546
 TAuthenticate.cxx:1547
 TAuthenticate.cxx:1548
 TAuthenticate.cxx:1549
 TAuthenticate.cxx:1550
 TAuthenticate.cxx:1551
 TAuthenticate.cxx:1552
 TAuthenticate.cxx:1553
 TAuthenticate.cxx:1554
 TAuthenticate.cxx:1555
 TAuthenticate.cxx:1556
 TAuthenticate.cxx:1557
 TAuthenticate.cxx:1558
 TAuthenticate.cxx:1559
 TAuthenticate.cxx:1560
 TAuthenticate.cxx:1561
 TAuthenticate.cxx:1562
 TAuthenticate.cxx:1563
 TAuthenticate.cxx:1564
 TAuthenticate.cxx:1565
 TAuthenticate.cxx:1566
 TAuthenticate.cxx:1567
 TAuthenticate.cxx:1568
 TAuthenticate.cxx:1569
 TAuthenticate.cxx:1570
 TAuthenticate.cxx:1571
 TAuthenticate.cxx:1572
 TAuthenticate.cxx:1573
 TAuthenticate.cxx:1574
 TAuthenticate.cxx:1575
 TAuthenticate.cxx:1576
 TAuthenticate.cxx:1577
 TAuthenticate.cxx:1578
 TAuthenticate.cxx:1579
 TAuthenticate.cxx:1580
 TAuthenticate.cxx:1581
 TAuthenticate.cxx:1582
 TAuthenticate.cxx:1583
 TAuthenticate.cxx:1584
 TAuthenticate.cxx:1585
 TAuthenticate.cxx:1586
 TAuthenticate.cxx:1587
 TAuthenticate.cxx:1588
 TAuthenticate.cxx:1589
 TAuthenticate.cxx:1590
 TAuthenticate.cxx:1591
 TAuthenticate.cxx:1592
 TAuthenticate.cxx:1593
 TAuthenticate.cxx:1594
 TAuthenticate.cxx:1595
 TAuthenticate.cxx:1596
 TAuthenticate.cxx:1597
 TAuthenticate.cxx:1598
 TAuthenticate.cxx:1599
 TAuthenticate.cxx:1600
 TAuthenticate.cxx:1601
 TAuthenticate.cxx:1602
 TAuthenticate.cxx:1603
 TAuthenticate.cxx:1604
 TAuthenticate.cxx:1605
 TAuthenticate.cxx:1606
 TAuthenticate.cxx:1607
 TAuthenticate.cxx:1608
 TAuthenticate.cxx:1609
 TAuthenticate.cxx:1610
 TAuthenticate.cxx:1611
 TAuthenticate.cxx:1612
 TAuthenticate.cxx:1613
 TAuthenticate.cxx:1614
 TAuthenticate.cxx:1615
 TAuthenticate.cxx:1616
 TAuthenticate.cxx:1617
 TAuthenticate.cxx:1618
 TAuthenticate.cxx:1619
 TAuthenticate.cxx:1620
 TAuthenticate.cxx:1621
 TAuthenticate.cxx:1622
 TAuthenticate.cxx:1623
 TAuthenticate.cxx:1624
 TAuthenticate.cxx:1625
 TAuthenticate.cxx:1626
 TAuthenticate.cxx:1627
 TAuthenticate.cxx:1628
 TAuthenticate.cxx:1629
 TAuthenticate.cxx:1630
 TAuthenticate.cxx:1631
 TAuthenticate.cxx:1632
 TAuthenticate.cxx:1633
 TAuthenticate.cxx:1634
 TAuthenticate.cxx:1635
 TAuthenticate.cxx:1636
 TAuthenticate.cxx:1637
 TAuthenticate.cxx:1638
 TAuthenticate.cxx:1639
 TAuthenticate.cxx:1640
 TAuthenticate.cxx:1641
 TAuthenticate.cxx:1642
 TAuthenticate.cxx:1643
 TAuthenticate.cxx:1644
 TAuthenticate.cxx:1645
 TAuthenticate.cxx:1646
 TAuthenticate.cxx:1647
 TAuthenticate.cxx:1648
 TAuthenticate.cxx:1649
 TAuthenticate.cxx:1650
 TAuthenticate.cxx:1651
 TAuthenticate.cxx:1652
 TAuthenticate.cxx:1653
 TAuthenticate.cxx:1654
 TAuthenticate.cxx:1655
 TAuthenticate.cxx:1656
 TAuthenticate.cxx:1657
 TAuthenticate.cxx:1658
 TAuthenticate.cxx:1659
 TAuthenticate.cxx:1660
 TAuthenticate.cxx:1661
 TAuthenticate.cxx:1662
 TAuthenticate.cxx:1663
 TAuthenticate.cxx:1664
 TAuthenticate.cxx:1665
 TAuthenticate.cxx:1666
 TAuthenticate.cxx:1667
 TAuthenticate.cxx:1668
 TAuthenticate.cxx:1669
 TAuthenticate.cxx:1670
 TAuthenticate.cxx:1671
 TAuthenticate.cxx:1672
 TAuthenticate.cxx:1673
 TAuthenticate.cxx:1674
 TAuthenticate.cxx:1675
 TAuthenticate.cxx:1676
 TAuthenticate.cxx:1677
 TAuthenticate.cxx:1678
 TAuthenticate.cxx:1679
 TAuthenticate.cxx:1680
 TAuthenticate.cxx:1681
 TAuthenticate.cxx:1682
 TAuthenticate.cxx:1683
 TAuthenticate.cxx:1684
 TAuthenticate.cxx:1685
 TAuthenticate.cxx:1686
 TAuthenticate.cxx:1687
 TAuthenticate.cxx:1688
 TAuthenticate.cxx:1689
 TAuthenticate.cxx:1690
 TAuthenticate.cxx:1691
 TAuthenticate.cxx:1692
 TAuthenticate.cxx:1693
 TAuthenticate.cxx:1694
 TAuthenticate.cxx:1695
 TAuthenticate.cxx:1696
 TAuthenticate.cxx:1697
 TAuthenticate.cxx:1698
 TAuthenticate.cxx:1699
 TAuthenticate.cxx:1700
 TAuthenticate.cxx:1701
 TAuthenticate.cxx:1702
 TAuthenticate.cxx:1703
 TAuthenticate.cxx:1704
 TAuthenticate.cxx:1705
 TAuthenticate.cxx:1706
 TAuthenticate.cxx:1707
 TAuthenticate.cxx:1708
 TAuthenticate.cxx:1709
 TAuthenticate.cxx:1710
 TAuthenticate.cxx:1711
 TAuthenticate.cxx:1712
 TAuthenticate.cxx:1713
 TAuthenticate.cxx:1714
 TAuthenticate.cxx:1715
 TAuthenticate.cxx:1716
 TAuthenticate.cxx:1717
 TAuthenticate.cxx:1718
 TAuthenticate.cxx:1719
 TAuthenticate.cxx:1720
 TAuthenticate.cxx:1721
 TAuthenticate.cxx:1722
 TAuthenticate.cxx:1723
 TAuthenticate.cxx:1724
 TAuthenticate.cxx:1725
 TAuthenticate.cxx:1726
 TAuthenticate.cxx:1727
 TAuthenticate.cxx:1728
 TAuthenticate.cxx:1729
 TAuthenticate.cxx:1730
 TAuthenticate.cxx:1731
 TAuthenticate.cxx:1732
 TAuthenticate.cxx:1733
 TAuthenticate.cxx:1734
 TAuthenticate.cxx:1735
 TAuthenticate.cxx:1736
 TAuthenticate.cxx:1737
 TAuthenticate.cxx:1738
 TAuthenticate.cxx:1739
 TAuthenticate.cxx:1740
 TAuthenticate.cxx:1741
 TAuthenticate.cxx:1742
 TAuthenticate.cxx:1743
 TAuthenticate.cxx:1744
 TAuthenticate.cxx:1745
 TAuthenticate.cxx:1746
 TAuthenticate.cxx:1747
 TAuthenticate.cxx:1748
 TAuthenticate.cxx:1749
 TAuthenticate.cxx:1750
 TAuthenticate.cxx:1751
 TAuthenticate.cxx:1752
 TAuthenticate.cxx:1753
 TAuthenticate.cxx:1754
 TAuthenticate.cxx:1755
 TAuthenticate.cxx:1756
 TAuthenticate.cxx:1757
 TAuthenticate.cxx:1758
 TAuthenticate.cxx:1759
 TAuthenticate.cxx:1760
 TAuthenticate.cxx:1761
 TAuthenticate.cxx:1762
 TAuthenticate.cxx:1763
 TAuthenticate.cxx:1764
 TAuthenticate.cxx:1765
 TAuthenticate.cxx:1766
 TAuthenticate.cxx:1767
 TAuthenticate.cxx:1768
 TAuthenticate.cxx:1769
 TAuthenticate.cxx:1770
 TAuthenticate.cxx:1771
 TAuthenticate.cxx:1772
 TAuthenticate.cxx:1773
 TAuthenticate.cxx:1774
 TAuthenticate.cxx:1775
 TAuthenticate.cxx:1776
 TAuthenticate.cxx:1777
 TAuthenticate.cxx:1778
 TAuthenticate.cxx:1779
 TAuthenticate.cxx:1780
 TAuthenticate.cxx:1781
 TAuthenticate.cxx:1782
 TAuthenticate.cxx:1783
 TAuthenticate.cxx:1784
 TAuthenticate.cxx:1785
 TAuthenticate.cxx:1786
 TAuthenticate.cxx:1787
 TAuthenticate.cxx:1788
 TAuthenticate.cxx:1789
 TAuthenticate.cxx:1790
 TAuthenticate.cxx:1791
 TAuthenticate.cxx:1792
 TAuthenticate.cxx:1793
 TAuthenticate.cxx:1794
 TAuthenticate.cxx:1795
 TAuthenticate.cxx:1796
 TAuthenticate.cxx:1797
 TAuthenticate.cxx:1798
 TAuthenticate.cxx:1799
 TAuthenticate.cxx:1800
 TAuthenticate.cxx:1801
 TAuthenticate.cxx:1802
 TAuthenticate.cxx:1803
 TAuthenticate.cxx:1804
 TAuthenticate.cxx:1805
 TAuthenticate.cxx:1806
 TAuthenticate.cxx:1807
 TAuthenticate.cxx:1808
 TAuthenticate.cxx:1809
 TAuthenticate.cxx:1810
 TAuthenticate.cxx:1811
 TAuthenticate.cxx:1812
 TAuthenticate.cxx:1813
 TAuthenticate.cxx:1814
 TAuthenticate.cxx:1815
 TAuthenticate.cxx:1816
 TAuthenticate.cxx:1817
 TAuthenticate.cxx:1818
 TAuthenticate.cxx:1819
 TAuthenticate.cxx:1820
 TAuthenticate.cxx:1821
 TAuthenticate.cxx:1822
 TAuthenticate.cxx:1823
 TAuthenticate.cxx:1824
 TAuthenticate.cxx:1825
 TAuthenticate.cxx:1826
 TAuthenticate.cxx:1827
 TAuthenticate.cxx:1828
 TAuthenticate.cxx:1829
 TAuthenticate.cxx:1830
 TAuthenticate.cxx:1831
 TAuthenticate.cxx:1832
 TAuthenticate.cxx:1833
 TAuthenticate.cxx:1834
 TAuthenticate.cxx:1835
 TAuthenticate.cxx:1836
 TAuthenticate.cxx:1837
 TAuthenticate.cxx:1838
 TAuthenticate.cxx:1839
 TAuthenticate.cxx:1840
 TAuthenticate.cxx:1841
 TAuthenticate.cxx:1842
 TAuthenticate.cxx:1843
 TAuthenticate.cxx:1844
 TAuthenticate.cxx:1845
 TAuthenticate.cxx:1846
 TAuthenticate.cxx:1847
 TAuthenticate.cxx:1848
 TAuthenticate.cxx:1849
 TAuthenticate.cxx:1850
 TAuthenticate.cxx:1851
 TAuthenticate.cxx:1852
 TAuthenticate.cxx:1853
 TAuthenticate.cxx:1854
 TAuthenticate.cxx:1855
 TAuthenticate.cxx:1856
 TAuthenticate.cxx:1857
 TAuthenticate.cxx:1858
 TAuthenticate.cxx:1859
 TAuthenticate.cxx:1860
 TAuthenticate.cxx:1861
 TAuthenticate.cxx:1862
 TAuthenticate.cxx:1863
 TAuthenticate.cxx:1864
 TAuthenticate.cxx:1865
 TAuthenticate.cxx:1866
 TAuthenticate.cxx:1867
 TAuthenticate.cxx:1868
 TAuthenticate.cxx:1869
 TAuthenticate.cxx:1870
 TAuthenticate.cxx:1871
 TAuthenticate.cxx:1872
 TAuthenticate.cxx:1873
 TAuthenticate.cxx:1874
 TAuthenticate.cxx:1875
 TAuthenticate.cxx:1876
 TAuthenticate.cxx:1877
 TAuthenticate.cxx:1878
 TAuthenticate.cxx:1879
 TAuthenticate.cxx:1880
 TAuthenticate.cxx:1881
 TAuthenticate.cxx:1882
 TAuthenticate.cxx:1883
 TAuthenticate.cxx:1884
 TAuthenticate.cxx:1885
 TAuthenticate.cxx:1886
 TAuthenticate.cxx:1887
 TAuthenticate.cxx:1888
 TAuthenticate.cxx:1889
 TAuthenticate.cxx:1890
 TAuthenticate.cxx:1891
 TAuthenticate.cxx:1892
 TAuthenticate.cxx:1893
 TAuthenticate.cxx:1894
 TAuthenticate.cxx:1895
 TAuthenticate.cxx:1896
 TAuthenticate.cxx:1897
 TAuthenticate.cxx:1898
 TAuthenticate.cxx:1899
 TAuthenticate.cxx:1900
 TAuthenticate.cxx:1901
 TAuthenticate.cxx:1902
 TAuthenticate.cxx:1903
 TAuthenticate.cxx:1904
 TAuthenticate.cxx:1905
 TAuthenticate.cxx:1906
 TAuthenticate.cxx:1907
 TAuthenticate.cxx:1908
 TAuthenticate.cxx:1909
 TAuthenticate.cxx:1910
 TAuthenticate.cxx:1911
 TAuthenticate.cxx:1912
 TAuthenticate.cxx:1913
 TAuthenticate.cxx:1914
 TAuthenticate.cxx:1915
 TAuthenticate.cxx:1916
 TAuthenticate.cxx:1917
 TAuthenticate.cxx:1918
 TAuthenticate.cxx:1919
 TAuthenticate.cxx:1920
 TAuthenticate.cxx:1921
 TAuthenticate.cxx:1922
 TAuthenticate.cxx:1923
 TAuthenticate.cxx:1924
 TAuthenticate.cxx:1925
 TAuthenticate.cxx:1926
 TAuthenticate.cxx:1927
 TAuthenticate.cxx:1928
 TAuthenticate.cxx:1929
 TAuthenticate.cxx:1930
 TAuthenticate.cxx:1931
 TAuthenticate.cxx:1932
 TAuthenticate.cxx:1933
 TAuthenticate.cxx:1934
 TAuthenticate.cxx:1935
 TAuthenticate.cxx:1936
 TAuthenticate.cxx:1937
 TAuthenticate.cxx:1938
 TAuthenticate.cxx:1939
 TAuthenticate.cxx:1940
 TAuthenticate.cxx:1941
 TAuthenticate.cxx:1942
 TAuthenticate.cxx:1943
 TAuthenticate.cxx:1944
 TAuthenticate.cxx:1945
 TAuthenticate.cxx:1946
 TAuthenticate.cxx:1947
 TAuthenticate.cxx:1948
 TAuthenticate.cxx:1949
 TAuthenticate.cxx:1950
 TAuthenticate.cxx:1951
 TAuthenticate.cxx:1952
 TAuthenticate.cxx:1953
 TAuthenticate.cxx:1954
 TAuthenticate.cxx:1955
 TAuthenticate.cxx:1956
 TAuthenticate.cxx:1957
 TAuthenticate.cxx:1958
 TAuthenticate.cxx:1959
 TAuthenticate.cxx:1960
 TAuthenticate.cxx:1961
 TAuthenticate.cxx:1962
 TAuthenticate.cxx:1963
 TAuthenticate.cxx:1964
 TAuthenticate.cxx:1965
 TAuthenticate.cxx:1966
 TAuthenticate.cxx:1967
 TAuthenticate.cxx:1968
 TAuthenticate.cxx:1969
 TAuthenticate.cxx:1970
 TAuthenticate.cxx:1971
 TAuthenticate.cxx:1972
 TAuthenticate.cxx:1973
 TAuthenticate.cxx:1974
 TAuthenticate.cxx:1975
 TAuthenticate.cxx:1976
 TAuthenticate.cxx:1977
 TAuthenticate.cxx:1978
 TAuthenticate.cxx:1979
 TAuthenticate.cxx:1980
 TAuthenticate.cxx:1981
 TAuthenticate.cxx:1982
 TAuthenticate.cxx:1983
 TAuthenticate.cxx:1984
 TAuthenticate.cxx:1985
 TAuthenticate.cxx:1986
 TAuthenticate.cxx:1987
 TAuthenticate.cxx:1988
 TAuthenticate.cxx:1989
 TAuthenticate.cxx:1990
 TAuthenticate.cxx:1991
 TAuthenticate.cxx:1992
 TAuthenticate.cxx:1993
 TAuthenticate.cxx:1994
 TAuthenticate.cxx:1995
 TAuthenticate.cxx:1996
 TAuthenticate.cxx:1997
 TAuthenticate.cxx:1998
 TAuthenticate.cxx:1999
 TAuthenticate.cxx:2000
 TAuthenticate.cxx:2001
 TAuthenticate.cxx:2002
 TAuthenticate.cxx:2003
 TAuthenticate.cxx:2004
 TAuthenticate.cxx:2005
 TAuthenticate.cxx:2006
 TAuthenticate.cxx:2007
 TAuthenticate.cxx:2008
 TAuthenticate.cxx:2009
 TAuthenticate.cxx:2010
 TAuthenticate.cxx:2011
 TAuthenticate.cxx:2012
 TAuthenticate.cxx:2013
 TAuthenticate.cxx:2014
 TAuthenticate.cxx:2015
 TAuthenticate.cxx:2016
 TAuthenticate.cxx:2017
 TAuthenticate.cxx:2018
 TAuthenticate.cxx:2019
 TAuthenticate.cxx:2020
 TAuthenticate.cxx:2021
 TAuthenticate.cxx:2022
 TAuthenticate.cxx:2023
 TAuthenticate.cxx:2024
 TAuthenticate.cxx:2025
 TAuthenticate.cxx:2026
 TAuthenticate.cxx:2027
 TAuthenticate.cxx:2028
 TAuthenticate.cxx:2029
 TAuthenticate.cxx:2030
 TAuthenticate.cxx:2031
 TAuthenticate.cxx:2032
 TAuthenticate.cxx:2033
 TAuthenticate.cxx:2034
 TAuthenticate.cxx:2035
 TAuthenticate.cxx:2036
 TAuthenticate.cxx:2037
 TAuthenticate.cxx:2038
 TAuthenticate.cxx:2039
 TAuthenticate.cxx:2040
 TAuthenticate.cxx:2041
 TAuthenticate.cxx:2042
 TAuthenticate.cxx:2043
 TAuthenticate.cxx:2044
 TAuthenticate.cxx:2045
 TAuthenticate.cxx:2046
 TAuthenticate.cxx:2047
 TAuthenticate.cxx:2048
 TAuthenticate.cxx:2049
 TAuthenticate.cxx:2050
 TAuthenticate.cxx:2051
 TAuthenticate.cxx:2052
 TAuthenticate.cxx:2053
 TAuthenticate.cxx:2054
 TAuthenticate.cxx:2055
 TAuthenticate.cxx:2056
 TAuthenticate.cxx:2057
 TAuthenticate.cxx:2058
 TAuthenticate.cxx:2059
 TAuthenticate.cxx:2060
 TAuthenticate.cxx:2061
 TAuthenticate.cxx:2062
 TAuthenticate.cxx:2063
 TAuthenticate.cxx:2064
 TAuthenticate.cxx:2065
 TAuthenticate.cxx:2066
 TAuthenticate.cxx:2067
 TAuthenticate.cxx:2068
 TAuthenticate.cxx:2069
 TAuthenticate.cxx:2070
 TAuthenticate.cxx:2071
 TAuthenticate.cxx:2072
 TAuthenticate.cxx:2073
 TAuthenticate.cxx:2074
 TAuthenticate.cxx:2075
 TAuthenticate.cxx:2076
 TAuthenticate.cxx:2077
 TAuthenticate.cxx:2078
 TAuthenticate.cxx:2079
 TAuthenticate.cxx:2080
 TAuthenticate.cxx:2081
 TAuthenticate.cxx:2082
 TAuthenticate.cxx:2083
 TAuthenticate.cxx:2084
 TAuthenticate.cxx:2085
 TAuthenticate.cxx:2086
 TAuthenticate.cxx:2087
 TAuthenticate.cxx:2088
 TAuthenticate.cxx:2089
 TAuthenticate.cxx:2090
 TAuthenticate.cxx:2091
 TAuthenticate.cxx:2092
 TAuthenticate.cxx:2093
 TAuthenticate.cxx:2094
 TAuthenticate.cxx:2095
 TAuthenticate.cxx:2096
 TAuthenticate.cxx:2097
 TAuthenticate.cxx:2098
 TAuthenticate.cxx:2099
 TAuthenticate.cxx:2100
 TAuthenticate.cxx:2101
 TAuthenticate.cxx:2102
 TAuthenticate.cxx:2103
 TAuthenticate.cxx:2104
 TAuthenticate.cxx:2105
 TAuthenticate.cxx:2106
 TAuthenticate.cxx:2107
 TAuthenticate.cxx:2108
 TAuthenticate.cxx:2109
 TAuthenticate.cxx:2110
 TAuthenticate.cxx:2111
 TAuthenticate.cxx:2112
 TAuthenticate.cxx:2113
 TAuthenticate.cxx:2114
 TAuthenticate.cxx:2115
 TAuthenticate.cxx:2116
 TAuthenticate.cxx:2117
 TAuthenticate.cxx:2118
 TAuthenticate.cxx:2119
 TAuthenticate.cxx:2120
 TAuthenticate.cxx:2121
 TAuthenticate.cxx:2122
 TAuthenticate.cxx:2123
 TAuthenticate.cxx:2124
 TAuthenticate.cxx:2125
 TAuthenticate.cxx:2126
 TAuthenticate.cxx:2127
 TAuthenticate.cxx:2128
 TAuthenticate.cxx:2129
 TAuthenticate.cxx:2130
 TAuthenticate.cxx:2131
 TAuthenticate.cxx:2132
 TAuthenticate.cxx:2133
 TAuthenticate.cxx:2134
 TAuthenticate.cxx:2135
 TAuthenticate.cxx:2136
 TAuthenticate.cxx:2137
 TAuthenticate.cxx:2138
 TAuthenticate.cxx:2139
 TAuthenticate.cxx:2140
 TAuthenticate.cxx:2141
 TAuthenticate.cxx:2142
 TAuthenticate.cxx:2143
 TAuthenticate.cxx:2144
 TAuthenticate.cxx:2145
 TAuthenticate.cxx:2146
 TAuthenticate.cxx:2147
 TAuthenticate.cxx:2148
 TAuthenticate.cxx:2149
 TAuthenticate.cxx:2150
 TAuthenticate.cxx:2151
 TAuthenticate.cxx:2152
 TAuthenticate.cxx:2153
 TAuthenticate.cxx:2154
 TAuthenticate.cxx:2155
 TAuthenticate.cxx:2156
 TAuthenticate.cxx:2157
 TAuthenticate.cxx:2158
 TAuthenticate.cxx:2159
 TAuthenticate.cxx:2160
 TAuthenticate.cxx:2161
 TAuthenticate.cxx:2162
 TAuthenticate.cxx:2163
 TAuthenticate.cxx:2164
 TAuthenticate.cxx:2165
 TAuthenticate.cxx:2166
 TAuthenticate.cxx:2167
 TAuthenticate.cxx:2168
 TAuthenticate.cxx:2169
 TAuthenticate.cxx:2170
 TAuthenticate.cxx:2171
 TAuthenticate.cxx:2172
 TAuthenticate.cxx:2173
 TAuthenticate.cxx:2174
 TAuthenticate.cxx:2175
 TAuthenticate.cxx:2176
 TAuthenticate.cxx:2177
 TAuthenticate.cxx:2178
 TAuthenticate.cxx:2179
 TAuthenticate.cxx:2180
 TAuthenticate.cxx:2181
 TAuthenticate.cxx:2182
 TAuthenticate.cxx:2183
 TAuthenticate.cxx:2184
 TAuthenticate.cxx:2185
 TAuthenticate.cxx:2186
 TAuthenticate.cxx:2187
 TAuthenticate.cxx:2188
 TAuthenticate.cxx:2189
 TAuthenticate.cxx:2190
 TAuthenticate.cxx:2191
 TAuthenticate.cxx:2192
 TAuthenticate.cxx:2193
 TAuthenticate.cxx:2194
 TAuthenticate.cxx:2195
 TAuthenticate.cxx:2196
 TAuthenticate.cxx:2197
 TAuthenticate.cxx:2198
 TAuthenticate.cxx:2199
 TAuthenticate.cxx:2200
 TAuthenticate.cxx:2201
 TAuthenticate.cxx:2202
 TAuthenticate.cxx:2203
 TAuthenticate.cxx:2204
 TAuthenticate.cxx:2205
 TAuthenticate.cxx:2206
 TAuthenticate.cxx:2207
 TAuthenticate.cxx:2208
 TAuthenticate.cxx:2209
 TAuthenticate.cxx:2210
 TAuthenticate.cxx:2211
 TAuthenticate.cxx:2212
 TAuthenticate.cxx:2213
 TAuthenticate.cxx:2214
 TAuthenticate.cxx:2215
 TAuthenticate.cxx:2216
 TAuthenticate.cxx:2217
 TAuthenticate.cxx:2218
 TAuthenticate.cxx:2219
 TAuthenticate.cxx:2220
 TAuthenticate.cxx:2221
 TAuthenticate.cxx:2222
 TAuthenticate.cxx:2223
 TAuthenticate.cxx:2224
 TAuthenticate.cxx:2225
 TAuthenticate.cxx:2226
 TAuthenticate.cxx:2227
 TAuthenticate.cxx:2228
 TAuthenticate.cxx:2229
 TAuthenticate.cxx:2230
 TAuthenticate.cxx:2231
 TAuthenticate.cxx:2232
 TAuthenticate.cxx:2233
 TAuthenticate.cxx:2234
 TAuthenticate.cxx:2235
 TAuthenticate.cxx:2236
 TAuthenticate.cxx:2237
 TAuthenticate.cxx:2238
 TAuthenticate.cxx:2239
 TAuthenticate.cxx:2240
 TAuthenticate.cxx:2241
 TAuthenticate.cxx:2242
 TAuthenticate.cxx:2243
 TAuthenticate.cxx:2244
 TAuthenticate.cxx:2245
 TAuthenticate.cxx:2246
 TAuthenticate.cxx:2247
 TAuthenticate.cxx:2248
 TAuthenticate.cxx:2249
 TAuthenticate.cxx:2250
 TAuthenticate.cxx:2251
 TAuthenticate.cxx:2252
 TAuthenticate.cxx:2253
 TAuthenticate.cxx:2254
 TAuthenticate.cxx:2255
 TAuthenticate.cxx:2256
 TAuthenticate.cxx:2257
 TAuthenticate.cxx:2258
 TAuthenticate.cxx:2259
 TAuthenticate.cxx:2260
 TAuthenticate.cxx:2261
 TAuthenticate.cxx:2262
 TAuthenticate.cxx:2263
 TAuthenticate.cxx:2264
 TAuthenticate.cxx:2265
 TAuthenticate.cxx:2266
 TAuthenticate.cxx:2267
 TAuthenticate.cxx:2268
 TAuthenticate.cxx:2269
 TAuthenticate.cxx:2270
 TAuthenticate.cxx:2271
 TAuthenticate.cxx:2272
 TAuthenticate.cxx:2273
 TAuthenticate.cxx:2274
 TAuthenticate.cxx:2275
 TAuthenticate.cxx:2276
 TAuthenticate.cxx:2277
 TAuthenticate.cxx:2278
 TAuthenticate.cxx:2279
 TAuthenticate.cxx:2280
 TAuthenticate.cxx:2281
 TAuthenticate.cxx:2282
 TAuthenticate.cxx:2283
 TAuthenticate.cxx:2284
 TAuthenticate.cxx:2285
 TAuthenticate.cxx:2286
 TAuthenticate.cxx:2287
 TAuthenticate.cxx:2288
 TAuthenticate.cxx:2289
 TAuthenticate.cxx:2290
 TAuthenticate.cxx:2291
 TAuthenticate.cxx:2292
 TAuthenticate.cxx:2293
 TAuthenticate.cxx:2294
 TAuthenticate.cxx:2295
 TAuthenticate.cxx:2296
 TAuthenticate.cxx:2297
 TAuthenticate.cxx:2298
 TAuthenticate.cxx:2299
 TAuthenticate.cxx:2300
 TAuthenticate.cxx:2301
 TAuthenticate.cxx:2302
 TAuthenticate.cxx:2303
 TAuthenticate.cxx:2304
 TAuthenticate.cxx:2305
 TAuthenticate.cxx:2306
 TAuthenticate.cxx:2307
 TAuthenticate.cxx:2308
 TAuthenticate.cxx:2309
 TAuthenticate.cxx:2310
 TAuthenticate.cxx:2311
 TAuthenticate.cxx:2312
 TAuthenticate.cxx:2313
 TAuthenticate.cxx:2314
 TAuthenticate.cxx:2315
 TAuthenticate.cxx:2316
 TAuthenticate.cxx:2317
 TAuthenticate.cxx:2318
 TAuthenticate.cxx:2319
 TAuthenticate.cxx:2320
 TAuthenticate.cxx:2321
 TAuthenticate.cxx:2322
 TAuthenticate.cxx:2323
 TAuthenticate.cxx:2324
 TAuthenticate.cxx:2325
 TAuthenticate.cxx:2326
 TAuthenticate.cxx:2327
 TAuthenticate.cxx:2328
 TAuthenticate.cxx:2329
 TAuthenticate.cxx:2330
 TAuthenticate.cxx:2331
 TAuthenticate.cxx:2332
 TAuthenticate.cxx:2333
 TAuthenticate.cxx:2334
 TAuthenticate.cxx:2335
 TAuthenticate.cxx:2336
 TAuthenticate.cxx:2337
 TAuthenticate.cxx:2338
 TAuthenticate.cxx:2339
 TAuthenticate.cxx:2340
 TAuthenticate.cxx:2341
 TAuthenticate.cxx:2342
 TAuthenticate.cxx:2343
 TAuthenticate.cxx:2344
 TAuthenticate.cxx:2345
 TAuthenticate.cxx:2346
 TAuthenticate.cxx:2347
 TAuthenticate.cxx:2348
 TAuthenticate.cxx:2349
 TAuthenticate.cxx:2350
 TAuthenticate.cxx:2351
 TAuthenticate.cxx:2352
 TAuthenticate.cxx:2353
 TAuthenticate.cxx:2354
 TAuthenticate.cxx:2355
 TAuthenticate.cxx:2356
 TAuthenticate.cxx:2357
 TAuthenticate.cxx:2358
 TAuthenticate.cxx:2359
 TAuthenticate.cxx:2360
 TAuthenticate.cxx:2361
 TAuthenticate.cxx:2362
 TAuthenticate.cxx:2363
 TAuthenticate.cxx:2364
 TAuthenticate.cxx:2365
 TAuthenticate.cxx:2366
 TAuthenticate.cxx:2367
 TAuthenticate.cxx:2368
 TAuthenticate.cxx:2369
 TAuthenticate.cxx:2370
 TAuthenticate.cxx:2371
 TAuthenticate.cxx:2372
 TAuthenticate.cxx:2373
 TAuthenticate.cxx:2374
 TAuthenticate.cxx:2375
 TAuthenticate.cxx:2376
 TAuthenticate.cxx:2377
 TAuthenticate.cxx:2378
 TAuthenticate.cxx:2379
 TAuthenticate.cxx:2380
 TAuthenticate.cxx:2381
 TAuthenticate.cxx:2382
 TAuthenticate.cxx:2383
 TAuthenticate.cxx:2384
 TAuthenticate.cxx:2385
 TAuthenticate.cxx:2386
 TAuthenticate.cxx:2387
 TAuthenticate.cxx:2388
 TAuthenticate.cxx:2389
 TAuthenticate.cxx:2390
 TAuthenticate.cxx:2391
 TAuthenticate.cxx:2392
 TAuthenticate.cxx:2393
 TAuthenticate.cxx:2394
 TAuthenticate.cxx:2395
 TAuthenticate.cxx:2396
 TAuthenticate.cxx:2397
 TAuthenticate.cxx:2398
 TAuthenticate.cxx:2399
 TAuthenticate.cxx:2400
 TAuthenticate.cxx:2401
 TAuthenticate.cxx:2402
 TAuthenticate.cxx:2403
 TAuthenticate.cxx:2404
 TAuthenticate.cxx:2405
 TAuthenticate.cxx:2406
 TAuthenticate.cxx:2407
 TAuthenticate.cxx:2408
 TAuthenticate.cxx:2409
 TAuthenticate.cxx:2410
 TAuthenticate.cxx:2411
 TAuthenticate.cxx:2412
 TAuthenticate.cxx:2413
 TAuthenticate.cxx:2414
 TAuthenticate.cxx:2415
 TAuthenticate.cxx:2416
 TAuthenticate.cxx:2417
 TAuthenticate.cxx:2418
 TAuthenticate.cxx:2419
 TAuthenticate.cxx:2420
 TAuthenticate.cxx:2421
 TAuthenticate.cxx:2422
 TAuthenticate.cxx:2423
 TAuthenticate.cxx:2424
 TAuthenticate.cxx:2425
 TAuthenticate.cxx:2426
 TAuthenticate.cxx:2427
 TAuthenticate.cxx:2428
 TAuthenticate.cxx:2429
 TAuthenticate.cxx:2430
 TAuthenticate.cxx:2431
 TAuthenticate.cxx:2432
 TAuthenticate.cxx:2433
 TAuthenticate.cxx:2434
 TAuthenticate.cxx:2435
 TAuthenticate.cxx:2436
 TAuthenticate.cxx:2437
 TAuthenticate.cxx:2438
 TAuthenticate.cxx:2439
 TAuthenticate.cxx:2440
 TAuthenticate.cxx:2441
 TAuthenticate.cxx:2442
 TAuthenticate.cxx:2443
 TAuthenticate.cxx:2444
 TAuthenticate.cxx:2445
 TAuthenticate.cxx:2446
 TAuthenticate.cxx:2447
 TAuthenticate.cxx:2448
 TAuthenticate.cxx:2449
 TAuthenticate.cxx:2450
 TAuthenticate.cxx:2451
 TAuthenticate.cxx:2452
 TAuthenticate.cxx:2453
 TAuthenticate.cxx:2454
 TAuthenticate.cxx:2455
 TAuthenticate.cxx:2456
 TAuthenticate.cxx:2457
 TAuthenticate.cxx:2458
 TAuthenticate.cxx:2459
 TAuthenticate.cxx:2460
 TAuthenticate.cxx:2461
 TAuthenticate.cxx:2462
 TAuthenticate.cxx:2463
 TAuthenticate.cxx:2464
 TAuthenticate.cxx:2465
 TAuthenticate.cxx:2466
 TAuthenticate.cxx:2467
 TAuthenticate.cxx:2468
 TAuthenticate.cxx:2469
 TAuthenticate.cxx:2470
 TAuthenticate.cxx:2471
 TAuthenticate.cxx:2472
 TAuthenticate.cxx:2473
 TAuthenticate.cxx:2474
 TAuthenticate.cxx:2475
 TAuthenticate.cxx:2476
 TAuthenticate.cxx:2477
 TAuthenticate.cxx:2478
 TAuthenticate.cxx:2479
 TAuthenticate.cxx:2480
 TAuthenticate.cxx:2481
 TAuthenticate.cxx:2482
 TAuthenticate.cxx:2483
 TAuthenticate.cxx:2484
 TAuthenticate.cxx:2485
 TAuthenticate.cxx:2486
 TAuthenticate.cxx:2487
 TAuthenticate.cxx:2488
 TAuthenticate.cxx:2489
 TAuthenticate.cxx:2490
 TAuthenticate.cxx:2491
 TAuthenticate.cxx:2492
 TAuthenticate.cxx:2493
 TAuthenticate.cxx:2494
 TAuthenticate.cxx:2495
 TAuthenticate.cxx:2496
 TAuthenticate.cxx:2497
 TAuthenticate.cxx:2498
 TAuthenticate.cxx:2499
 TAuthenticate.cxx:2500
 TAuthenticate.cxx:2501
 TAuthenticate.cxx:2502
 TAuthenticate.cxx:2503
 TAuthenticate.cxx:2504
 TAuthenticate.cxx:2505
 TAuthenticate.cxx:2506
 TAuthenticate.cxx:2507
 TAuthenticate.cxx:2508
 TAuthenticate.cxx:2509
 TAuthenticate.cxx:2510
 TAuthenticate.cxx:2511
 TAuthenticate.cxx:2512
 TAuthenticate.cxx:2513
 TAuthenticate.cxx:2514
 TAuthenticate.cxx:2515
 TAuthenticate.cxx:2516
 TAuthenticate.cxx:2517
 TAuthenticate.cxx:2518
 TAuthenticate.cxx:2519
 TAuthenticate.cxx:2520
 TAuthenticate.cxx:2521
 TAuthenticate.cxx:2522
 TAuthenticate.cxx:2523
 TAuthenticate.cxx:2524
 TAuthenticate.cxx:2525
 TAuthenticate.cxx:2526
 TAuthenticate.cxx:2527
 TAuthenticate.cxx:2528
 TAuthenticate.cxx:2529
 TAuthenticate.cxx:2530
 TAuthenticate.cxx:2531
 TAuthenticate.cxx:2532
 TAuthenticate.cxx:2533
 TAuthenticate.cxx:2534
 TAuthenticate.cxx:2535
 TAuthenticate.cxx:2536
 TAuthenticate.cxx:2537
 TAuthenticate.cxx:2538
 TAuthenticate.cxx:2539
 TAuthenticate.cxx:2540
 TAuthenticate.cxx:2541
 TAuthenticate.cxx:2542
 TAuthenticate.cxx:2543
 TAuthenticate.cxx:2544
 TAuthenticate.cxx:2545
 TAuthenticate.cxx:2546
 TAuthenticate.cxx:2547
 TAuthenticate.cxx:2548
 TAuthenticate.cxx:2549
 TAuthenticate.cxx:2550
 TAuthenticate.cxx:2551
 TAuthenticate.cxx:2552
 TAuthenticate.cxx:2553
 TAuthenticate.cxx:2554
 TAuthenticate.cxx:2555
 TAuthenticate.cxx:2556
 TAuthenticate.cxx:2557
 TAuthenticate.cxx:2558
 TAuthenticate.cxx:2559
 TAuthenticate.cxx:2560
 TAuthenticate.cxx:2561
 TAuthenticate.cxx:2562
 TAuthenticate.cxx:2563
 TAuthenticate.cxx:2564
 TAuthenticate.cxx:2565
 TAuthenticate.cxx:2566
 TAuthenticate.cxx:2567
 TAuthenticate.cxx:2568
 TAuthenticate.cxx:2569
 TAuthenticate.cxx:2570
 TAuthenticate.cxx:2571
 TAuthenticate.cxx:2572
 TAuthenticate.cxx:2573
 TAuthenticate.cxx:2574
 TAuthenticate.cxx:2575
 TAuthenticate.cxx:2576
 TAuthenticate.cxx:2577
 TAuthenticate.cxx:2578
 TAuthenticate.cxx:2579
 TAuthenticate.cxx:2580
 TAuthenticate.cxx:2581
 TAuthenticate.cxx:2582
 TAuthenticate.cxx:2583
 TAuthenticate.cxx:2584
 TAuthenticate.cxx:2585
 TAuthenticate.cxx:2586
 TAuthenticate.cxx:2587
 TAuthenticate.cxx:2588
 TAuthenticate.cxx:2589
 TAuthenticate.cxx:2590
 TAuthenticate.cxx:2591
 TAuthenticate.cxx:2592
 TAuthenticate.cxx:2593
 TAuthenticate.cxx:2594
 TAuthenticate.cxx:2595
 TAuthenticate.cxx:2596
 TAuthenticate.cxx:2597
 TAuthenticate.cxx:2598
 TAuthenticate.cxx:2599
 TAuthenticate.cxx:2600
 TAuthenticate.cxx:2601
 TAuthenticate.cxx:2602
 TAuthenticate.cxx:2603
 TAuthenticate.cxx:2604
 TAuthenticate.cxx:2605
 TAuthenticate.cxx:2606
 TAuthenticate.cxx:2607
 TAuthenticate.cxx:2608
 TAuthenticate.cxx:2609
 TAuthenticate.cxx:2610
 TAuthenticate.cxx:2611
 TAuthenticate.cxx:2612
 TAuthenticate.cxx:2613
 TAuthenticate.cxx:2614
 TAuthenticate.cxx:2615
 TAuthenticate.cxx:2616
 TAuthenticate.cxx:2617
 TAuthenticate.cxx:2618
 TAuthenticate.cxx:2619
 TAuthenticate.cxx:2620
 TAuthenticate.cxx:2621
 TAuthenticate.cxx:2622
 TAuthenticate.cxx:2623
 TAuthenticate.cxx:2624
 TAuthenticate.cxx:2625
 TAuthenticate.cxx:2626
 TAuthenticate.cxx:2627
 TAuthenticate.cxx:2628
 TAuthenticate.cxx:2629
 TAuthenticate.cxx:2630
 TAuthenticate.cxx:2631
 TAuthenticate.cxx:2632
 TAuthenticate.cxx:2633
 TAuthenticate.cxx:2634
 TAuthenticate.cxx:2635
 TAuthenticate.cxx:2636
 TAuthenticate.cxx:2637
 TAuthenticate.cxx:2638
 TAuthenticate.cxx:2639
 TAuthenticate.cxx:2640
 TAuthenticate.cxx:2641
 TAuthenticate.cxx:2642
 TAuthenticate.cxx:2643
 TAuthenticate.cxx:2644
 TAuthenticate.cxx:2645
 TAuthenticate.cxx:2646
 TAuthenticate.cxx:2647
 TAuthenticate.cxx:2648
 TAuthenticate.cxx:2649
 TAuthenticate.cxx:2650
 TAuthenticate.cxx:2651
 TAuthenticate.cxx:2652
 TAuthenticate.cxx:2653
 TAuthenticate.cxx:2654
 TAuthenticate.cxx:2655
 TAuthenticate.cxx:2656
 TAuthenticate.cxx:2657
 TAuthenticate.cxx:2658
 TAuthenticate.cxx:2659
 TAuthenticate.cxx:2660
 TAuthenticate.cxx:2661
 TAuthenticate.cxx:2662
 TAuthenticate.cxx:2663
 TAuthenticate.cxx:2664
 TAuthenticate.cxx:2665
 TAuthenticate.cxx:2666
 TAuthenticate.cxx:2667
 TAuthenticate.cxx:2668
 TAuthenticate.cxx:2669
 TAuthenticate.cxx:2670
 TAuthenticate.cxx:2671
 TAuthenticate.cxx:2672
 TAuthenticate.cxx:2673
 TAuthenticate.cxx:2674
 TAuthenticate.cxx:2675
 TAuthenticate.cxx:2676
 TAuthenticate.cxx:2677
 TAuthenticate.cxx:2678
 TAuthenticate.cxx:2679
 TAuthenticate.cxx:2680
 TAuthenticate.cxx:2681
 TAuthenticate.cxx:2682
 TAuthenticate.cxx:2683
 TAuthenticate.cxx:2684
 TAuthenticate.cxx:2685
 TAuthenticate.cxx:2686
 TAuthenticate.cxx:2687
 TAuthenticate.cxx:2688
 TAuthenticate.cxx:2689
 TAuthenticate.cxx:2690
 TAuthenticate.cxx:2691
 TAuthenticate.cxx:2692
 TAuthenticate.cxx:2693
 TAuthenticate.cxx:2694
 TAuthenticate.cxx:2695
 TAuthenticate.cxx:2696
 TAuthenticate.cxx:2697
 TAuthenticate.cxx:2698
 TAuthenticate.cxx:2699
 TAuthenticate.cxx:2700
 TAuthenticate.cxx:2701
 TAuthenticate.cxx:2702
 TAuthenticate.cxx:2703
 TAuthenticate.cxx:2704
 TAuthenticate.cxx:2705
 TAuthenticate.cxx:2706
 TAuthenticate.cxx:2707
 TAuthenticate.cxx:2708
 TAuthenticate.cxx:2709
 TAuthenticate.cxx:2710
 TAuthenticate.cxx:2711
 TAuthenticate.cxx:2712
 TAuthenticate.cxx:2713
 TAuthenticate.cxx:2714
 TAuthenticate.cxx:2715
 TAuthenticate.cxx:2716
 TAuthenticate.cxx:2717
 TAuthenticate.cxx:2718
 TAuthenticate.cxx:2719
 TAuthenticate.cxx:2720
 TAuthenticate.cxx:2721
 TAuthenticate.cxx:2722
 TAuthenticate.cxx:2723
 TAuthenticate.cxx:2724
 TAuthenticate.cxx:2725
 TAuthenticate.cxx:2726
 TAuthenticate.cxx:2727
 TAuthenticate.cxx:2728
 TAuthenticate.cxx:2729
 TAuthenticate.cxx:2730
 TAuthenticate.cxx:2731
 TAuthenticate.cxx:2732
 TAuthenticate.cxx:2733
 TAuthenticate.cxx:2734
 TAuthenticate.cxx:2735
 TAuthenticate.cxx:2736
 TAuthenticate.cxx:2737
 TAuthenticate.cxx:2738
 TAuthenticate.cxx:2739
 TAuthenticate.cxx:2740
 TAuthenticate.cxx:2741
 TAuthenticate.cxx:2742
 TAuthenticate.cxx:2743
 TAuthenticate.cxx:2744
 TAuthenticate.cxx:2745
 TAuthenticate.cxx:2746
 TAuthenticate.cxx:2747
 TAuthenticate.cxx:2748
 TAuthenticate.cxx:2749
 TAuthenticate.cxx:2750
 TAuthenticate.cxx:2751
 TAuthenticate.cxx:2752
 TAuthenticate.cxx:2753
 TAuthenticate.cxx:2754
 TAuthenticate.cxx:2755
 TAuthenticate.cxx:2756
 TAuthenticate.cxx:2757
 TAuthenticate.cxx:2758
 TAuthenticate.cxx:2759
 TAuthenticate.cxx:2760
 TAuthenticate.cxx:2761
 TAuthenticate.cxx:2762
 TAuthenticate.cxx:2763
 TAuthenticate.cxx:2764
 TAuthenticate.cxx:2765
 TAuthenticate.cxx:2766
 TAuthenticate.cxx:2767
 TAuthenticate.cxx:2768
 TAuthenticate.cxx:2769
 TAuthenticate.cxx:2770
 TAuthenticate.cxx:2771
 TAuthenticate.cxx:2772
 TAuthenticate.cxx:2773
 TAuthenticate.cxx:2774
 TAuthenticate.cxx:2775
 TAuthenticate.cxx:2776
 TAuthenticate.cxx:2777
 TAuthenticate.cxx:2778
 TAuthenticate.cxx:2779
 TAuthenticate.cxx:2780
 TAuthenticate.cxx:2781
 TAuthenticate.cxx:2782
 TAuthenticate.cxx:2783
 TAuthenticate.cxx:2784
 TAuthenticate.cxx:2785
 TAuthenticate.cxx:2786
 TAuthenticate.cxx:2787
 TAuthenticate.cxx:2788
 TAuthenticate.cxx:2789
 TAuthenticate.cxx:2790
 TAuthenticate.cxx:2791
 TAuthenticate.cxx:2792
 TAuthenticate.cxx:2793
 TAuthenticate.cxx:2794
 TAuthenticate.cxx:2795
 TAuthenticate.cxx:2796
 TAuthenticate.cxx:2797
 TAuthenticate.cxx:2798
 TAuthenticate.cxx:2799
 TAuthenticate.cxx:2800
 TAuthenticate.cxx:2801
 TAuthenticate.cxx:2802
 TAuthenticate.cxx:2803
 TAuthenticate.cxx:2804
 TAuthenticate.cxx:2805
 TAuthenticate.cxx:2806
 TAuthenticate.cxx:2807
 TAuthenticate.cxx:2808
 TAuthenticate.cxx:2809
 TAuthenticate.cxx:2810
 TAuthenticate.cxx:2811
 TAuthenticate.cxx:2812
 TAuthenticate.cxx:2813
 TAuthenticate.cxx:2814
 TAuthenticate.cxx:2815
 TAuthenticate.cxx:2816
 TAuthenticate.cxx:2817
 TAuthenticate.cxx:2818
 TAuthenticate.cxx:2819
 TAuthenticate.cxx:2820
 TAuthenticate.cxx:2821
 TAuthenticate.cxx:2822
 TAuthenticate.cxx:2823
 TAuthenticate.cxx:2824
 TAuthenticate.cxx:2825
 TAuthenticate.cxx:2826
 TAuthenticate.cxx:2827
 TAuthenticate.cxx:2828
 TAuthenticate.cxx:2829
 TAuthenticate.cxx:2830
 TAuthenticate.cxx:2831
 TAuthenticate.cxx:2832
 TAuthenticate.cxx:2833
 TAuthenticate.cxx:2834
 TAuthenticate.cxx:2835
 TAuthenticate.cxx:2836
 TAuthenticate.cxx:2837
 TAuthenticate.cxx:2838
 TAuthenticate.cxx:2839
 TAuthenticate.cxx:2840
 TAuthenticate.cxx:2841
 TAuthenticate.cxx:2842
 TAuthenticate.cxx:2843
 TAuthenticate.cxx:2844
 TAuthenticate.cxx:2845
 TAuthenticate.cxx:2846
 TAuthenticate.cxx:2847
 TAuthenticate.cxx:2848
 TAuthenticate.cxx:2849
 TAuthenticate.cxx:2850
 TAuthenticate.cxx:2851
 TAuthenticate.cxx:2852
 TAuthenticate.cxx:2853
 TAuthenticate.cxx:2854
 TAuthenticate.cxx:2855
 TAuthenticate.cxx:2856
 TAuthenticate.cxx:2857
 TAuthenticate.cxx:2858
 TAuthenticate.cxx:2859
 TAuthenticate.cxx:2860
 TAuthenticate.cxx:2861
 TAuthenticate.cxx:2862
 TAuthenticate.cxx:2863
 TAuthenticate.cxx:2864
 TAuthenticate.cxx:2865
 TAuthenticate.cxx:2866
 TAuthenticate.cxx:2867
 TAuthenticate.cxx:2868
 TAuthenticate.cxx:2869
 TAuthenticate.cxx:2870
 TAuthenticate.cxx:2871
 TAuthenticate.cxx:2872
 TAuthenticate.cxx:2873
 TAuthenticate.cxx:2874
 TAuthenticate.cxx:2875
 TAuthenticate.cxx:2876
 TAuthenticate.cxx:2877
 TAuthenticate.cxx:2878
 TAuthenticate.cxx:2879
 TAuthenticate.cxx:2880
 TAuthenticate.cxx:2881
 TAuthenticate.cxx:2882
 TAuthenticate.cxx:2883
 TAuthenticate.cxx:2884
 TAuthenticate.cxx:2885
 TAuthenticate.cxx:2886
 TAuthenticate.cxx:2887
 TAuthenticate.cxx:2888
 TAuthenticate.cxx:2889
 TAuthenticate.cxx:2890
 TAuthenticate.cxx:2891
 TAuthenticate.cxx:2892
 TAuthenticate.cxx:2893
 TAuthenticate.cxx:2894
 TAuthenticate.cxx:2895
 TAuthenticate.cxx:2896
 TAuthenticate.cxx:2897
 TAuthenticate.cxx:2898
 TAuthenticate.cxx:2899
 TAuthenticate.cxx:2900
 TAuthenticate.cxx:2901
 TAuthenticate.cxx:2902
 TAuthenticate.cxx:2903
 TAuthenticate.cxx:2904
 TAuthenticate.cxx:2905
 TAuthenticate.cxx:2906
 TAuthenticate.cxx:2907
 TAuthenticate.cxx:2908
 TAuthenticate.cxx:2909
 TAuthenticate.cxx:2910
 TAuthenticate.cxx:2911
 TAuthenticate.cxx:2912
 TAuthenticate.cxx:2913
 TAuthenticate.cxx:2914
 TAuthenticate.cxx:2915
 TAuthenticate.cxx:2916
 TAuthenticate.cxx:2917
 TAuthenticate.cxx:2918
 TAuthenticate.cxx:2919
 TAuthenticate.cxx:2920
 TAuthenticate.cxx:2921
 TAuthenticate.cxx:2922
 TAuthenticate.cxx:2923
 TAuthenticate.cxx:2924
 TAuthenticate.cxx:2925
 TAuthenticate.cxx:2926
 TAuthenticate.cxx:2927
 TAuthenticate.cxx:2928
 TAuthenticate.cxx:2929
 TAuthenticate.cxx:2930
 TAuthenticate.cxx:2931
 TAuthenticate.cxx:2932
 TAuthenticate.cxx:2933
 TAuthenticate.cxx:2934
 TAuthenticate.cxx:2935
 TAuthenticate.cxx:2936
 TAuthenticate.cxx:2937
 TAuthenticate.cxx:2938
 TAuthenticate.cxx:2939
 TAuthenticate.cxx:2940
 TAuthenticate.cxx:2941
 TAuthenticate.cxx:2942
 TAuthenticate.cxx:2943
 TAuthenticate.cxx:2944
 TAuthenticate.cxx:2945
 TAuthenticate.cxx:2946
 TAuthenticate.cxx:2947
 TAuthenticate.cxx:2948
 TAuthenticate.cxx:2949
 TAuthenticate.cxx:2950
 TAuthenticate.cxx:2951
 TAuthenticate.cxx:2952
 TAuthenticate.cxx:2953
 TAuthenticate.cxx:2954
 TAuthenticate.cxx:2955
 TAuthenticate.cxx:2956
 TAuthenticate.cxx:2957
 TAuthenticate.cxx:2958
 TAuthenticate.cxx:2959
 TAuthenticate.cxx:2960
 TAuthenticate.cxx:2961
 TAuthenticate.cxx:2962
 TAuthenticate.cxx:2963
 TAuthenticate.cxx:2964
 TAuthenticate.cxx:2965
 TAuthenticate.cxx:2966
 TAuthenticate.cxx:2967
 TAuthenticate.cxx:2968
 TAuthenticate.cxx:2969
 TAuthenticate.cxx:2970
 TAuthenticate.cxx:2971
 TAuthenticate.cxx:2972
 TAuthenticate.cxx:2973
 TAuthenticate.cxx:2974
 TAuthenticate.cxx:2975
 TAuthenticate.cxx:2976
 TAuthenticate.cxx:2977
 TAuthenticate.cxx:2978
 TAuthenticate.cxx:2979
 TAuthenticate.cxx:2980
 TAuthenticate.cxx:2981
 TAuthenticate.cxx:2982
 TAuthenticate.cxx:2983
 TAuthenticate.cxx:2984
 TAuthenticate.cxx:2985
 TAuthenticate.cxx:2986
 TAuthenticate.cxx:2987
 TAuthenticate.cxx:2988
 TAuthenticate.cxx:2989
 TAuthenticate.cxx:2990
 TAuthenticate.cxx:2991
 TAuthenticate.cxx:2992
 TAuthenticate.cxx:2993
 TAuthenticate.cxx:2994
 TAuthenticate.cxx:2995
 TAuthenticate.cxx:2996
 TAuthenticate.cxx:2997
 TAuthenticate.cxx:2998
 TAuthenticate.cxx:2999
 TAuthenticate.cxx:3000
 TAuthenticate.cxx:3001
 TAuthenticate.cxx:3002
 TAuthenticate.cxx:3003
 TAuthenticate.cxx:3004
 TAuthenticate.cxx:3005
 TAuthenticate.cxx:3006
 TAuthenticate.cxx:3007
 TAuthenticate.cxx:3008
 TAuthenticate.cxx:3009
 TAuthenticate.cxx:3010
 TAuthenticate.cxx:3011
 TAuthenticate.cxx:3012
 TAuthenticate.cxx:3013
 TAuthenticate.cxx:3014
 TAuthenticate.cxx:3015
 TAuthenticate.cxx:3016
 TAuthenticate.cxx:3017
 TAuthenticate.cxx:3018
 TAuthenticate.cxx:3019
 TAuthenticate.cxx:3020
 TAuthenticate.cxx:3021
 TAuthenticate.cxx:3022
 TAuthenticate.cxx:3023
 TAuthenticate.cxx:3024
 TAuthenticate.cxx:3025
 TAuthenticate.cxx:3026
 TAuthenticate.cxx:3027
 TAuthenticate.cxx:3028
 TAuthenticate.cxx:3029
 TAuthenticate.cxx:3030
 TAuthenticate.cxx:3031
 TAuthenticate.cxx:3032
 TAuthenticate.cxx:3033
 TAuthenticate.cxx:3034
 TAuthenticate.cxx:3035
 TAuthenticate.cxx:3036
 TAuthenticate.cxx:3037
 TAuthenticate.cxx:3038
 TAuthenticate.cxx:3039
 TAuthenticate.cxx:3040
 TAuthenticate.cxx:3041
 TAuthenticate.cxx:3042
 TAuthenticate.cxx:3043
 TAuthenticate.cxx:3044
 TAuthenticate.cxx:3045
 TAuthenticate.cxx:3046
 TAuthenticate.cxx:3047
 TAuthenticate.cxx:3048
 TAuthenticate.cxx:3049
 TAuthenticate.cxx:3050
 TAuthenticate.cxx:3051
 TAuthenticate.cxx:3052
 TAuthenticate.cxx:3053
 TAuthenticate.cxx:3054
 TAuthenticate.cxx:3055
 TAuthenticate.cxx:3056
 TAuthenticate.cxx:3057
 TAuthenticate.cxx:3058
 TAuthenticate.cxx:3059
 TAuthenticate.cxx:3060
 TAuthenticate.cxx:3061
 TAuthenticate.cxx:3062
 TAuthenticate.cxx:3063
 TAuthenticate.cxx:3064
 TAuthenticate.cxx:3065
 TAuthenticate.cxx:3066
 TAuthenticate.cxx:3067
 TAuthenticate.cxx:3068
 TAuthenticate.cxx:3069
 TAuthenticate.cxx:3070
 TAuthenticate.cxx:3071
 TAuthenticate.cxx:3072
 TAuthenticate.cxx:3073
 TAuthenticate.cxx:3074
 TAuthenticate.cxx:3075
 TAuthenticate.cxx:3076
 TAuthenticate.cxx:3077
 TAuthenticate.cxx:3078
 TAuthenticate.cxx:3079
 TAuthenticate.cxx:3080
 TAuthenticate.cxx:3081
 TAuthenticate.cxx:3082
 TAuthenticate.cxx:3083
 TAuthenticate.cxx:3084
 TAuthenticate.cxx:3085
 TAuthenticate.cxx:3086
 TAuthenticate.cxx:3087
 TAuthenticate.cxx:3088
 TAuthenticate.cxx:3089
 TAuthenticate.cxx:3090
 TAuthenticate.cxx:3091
 TAuthenticate.cxx:3092
 TAuthenticate.cxx:3093
 TAuthenticate.cxx:3094
 TAuthenticate.cxx:3095
 TAuthenticate.cxx:3096
 TAuthenticate.cxx:3097
 TAuthenticate.cxx:3098
 TAuthenticate.cxx:3099
 TAuthenticate.cxx:3100
 TAuthenticate.cxx:3101
 TAuthenticate.cxx:3102
 TAuthenticate.cxx:3103
 TAuthenticate.cxx:3104
 TAuthenticate.cxx:3105
 TAuthenticate.cxx:3106
 TAuthenticate.cxx:3107
 TAuthenticate.cxx:3108
 TAuthenticate.cxx:3109
 TAuthenticate.cxx:3110
 TAuthenticate.cxx:3111
 TAuthenticate.cxx:3112
 TAuthenticate.cxx:3113
 TAuthenticate.cxx:3114
 TAuthenticate.cxx:3115
 TAuthenticate.cxx:3116
 TAuthenticate.cxx:3117
 TAuthenticate.cxx:3118
 TAuthenticate.cxx:3119
 TAuthenticate.cxx:3120
 TAuthenticate.cxx:3121
 TAuthenticate.cxx:3122
 TAuthenticate.cxx:3123
 TAuthenticate.cxx:3124
 TAuthenticate.cxx:3125
 TAuthenticate.cxx:3126
 TAuthenticate.cxx:3127
 TAuthenticate.cxx:3128
 TAuthenticate.cxx:3129
 TAuthenticate.cxx:3130
 TAuthenticate.cxx:3131
 TAuthenticate.cxx:3132
 TAuthenticate.cxx:3133
 TAuthenticate.cxx:3134
 TAuthenticate.cxx:3135
 TAuthenticate.cxx:3136
 TAuthenticate.cxx:3137
 TAuthenticate.cxx:3138
 TAuthenticate.cxx:3139
 TAuthenticate.cxx:3140
 TAuthenticate.cxx:3141
 TAuthenticate.cxx:3142
 TAuthenticate.cxx:3143
 TAuthenticate.cxx:3144
 TAuthenticate.cxx:3145
 TAuthenticate.cxx:3146
 TAuthenticate.cxx:3147
 TAuthenticate.cxx:3148
 TAuthenticate.cxx:3149
 TAuthenticate.cxx:3150
 TAuthenticate.cxx:3151
 TAuthenticate.cxx:3152
 TAuthenticate.cxx:3153
 TAuthenticate.cxx:3154
 TAuthenticate.cxx:3155
 TAuthenticate.cxx:3156
 TAuthenticate.cxx:3157
 TAuthenticate.cxx:3158
 TAuthenticate.cxx:3159
 TAuthenticate.cxx:3160
 TAuthenticate.cxx:3161
 TAuthenticate.cxx:3162
 TAuthenticate.cxx:3163
 TAuthenticate.cxx:3164
 TAuthenticate.cxx:3165
 TAuthenticate.cxx:3166
 TAuthenticate.cxx:3167
 TAuthenticate.cxx:3168
 TAuthenticate.cxx:3169
 TAuthenticate.cxx:3170
 TAuthenticate.cxx:3171
 TAuthenticate.cxx:3172
 TAuthenticate.cxx:3173
 TAuthenticate.cxx:3174
 TAuthenticate.cxx:3175
 TAuthenticate.cxx:3176
 TAuthenticate.cxx:3177
 TAuthenticate.cxx:3178
 TAuthenticate.cxx:3179
 TAuthenticate.cxx:3180
 TAuthenticate.cxx:3181
 TAuthenticate.cxx:3182
 TAuthenticate.cxx:3183
 TAuthenticate.cxx:3184
 TAuthenticate.cxx:3185
 TAuthenticate.cxx:3186
 TAuthenticate.cxx:3187
 TAuthenticate.cxx:3188
 TAuthenticate.cxx:3189
 TAuthenticate.cxx:3190
 TAuthenticate.cxx:3191
 TAuthenticate.cxx:3192
 TAuthenticate.cxx:3193
 TAuthenticate.cxx:3194
 TAuthenticate.cxx:3195
 TAuthenticate.cxx:3196
 TAuthenticate.cxx:3197
 TAuthenticate.cxx:3198
 TAuthenticate.cxx:3199
 TAuthenticate.cxx:3200
 TAuthenticate.cxx:3201
 TAuthenticate.cxx:3202
 TAuthenticate.cxx:3203
 TAuthenticate.cxx:3204
 TAuthenticate.cxx:3205
 TAuthenticate.cxx:3206
 TAuthenticate.cxx:3207
 TAuthenticate.cxx:3208
 TAuthenticate.cxx:3209
 TAuthenticate.cxx:3210
 TAuthenticate.cxx:3211
 TAuthenticate.cxx:3212
 TAuthenticate.cxx:3213
 TAuthenticate.cxx:3214
 TAuthenticate.cxx:3215
 TAuthenticate.cxx:3216
 TAuthenticate.cxx:3217
 TAuthenticate.cxx:3218
 TAuthenticate.cxx:3219
 TAuthenticate.cxx:3220
 TAuthenticate.cxx:3221
 TAuthenticate.cxx:3222
 TAuthenticate.cxx:3223
 TAuthenticate.cxx:3224
 TAuthenticate.cxx:3225
 TAuthenticate.cxx:3226
 TAuthenticate.cxx:3227
 TAuthenticate.cxx:3228
 TAuthenticate.cxx:3229
 TAuthenticate.cxx:3230
 TAuthenticate.cxx:3231
 TAuthenticate.cxx:3232
 TAuthenticate.cxx:3233
 TAuthenticate.cxx:3234
 TAuthenticate.cxx:3235
 TAuthenticate.cxx:3236
 TAuthenticate.cxx:3237
 TAuthenticate.cxx:3238
 TAuthenticate.cxx:3239
 TAuthenticate.cxx:3240
 TAuthenticate.cxx:3241
 TAuthenticate.cxx:3242
 TAuthenticate.cxx:3243
 TAuthenticate.cxx:3244
 TAuthenticate.cxx:3245
 TAuthenticate.cxx:3246
 TAuthenticate.cxx:3247
 TAuthenticate.cxx:3248
 TAuthenticate.cxx:3249
 TAuthenticate.cxx:3250
 TAuthenticate.cxx:3251
 TAuthenticate.cxx:3252
 TAuthenticate.cxx:3253
 TAuthenticate.cxx:3254
 TAuthenticate.cxx:3255
 TAuthenticate.cxx:3256
 TAuthenticate.cxx:3257
 TAuthenticate.cxx:3258
 TAuthenticate.cxx:3259
 TAuthenticate.cxx:3260
 TAuthenticate.cxx:3261
 TAuthenticate.cxx:3262
 TAuthenticate.cxx:3263
 TAuthenticate.cxx:3264
 TAuthenticate.cxx:3265
 TAuthenticate.cxx:3266
 TAuthenticate.cxx:3267
 TAuthenticate.cxx:3268
 TAuthenticate.cxx:3269
 TAuthenticate.cxx:3270
 TAuthenticate.cxx:3271
 TAuthenticate.cxx:3272
 TAuthenticate.cxx:3273
 TAuthenticate.cxx:3274
 TAuthenticate.cxx:3275
 TAuthenticate.cxx:3276
 TAuthenticate.cxx:3277
 TAuthenticate.cxx:3278
 TAuthenticate.cxx:3279
 TAuthenticate.cxx:3280
 TAuthenticate.cxx:3281
 TAuthenticate.cxx:3282
 TAuthenticate.cxx:3283
 TAuthenticate.cxx:3284
 TAuthenticate.cxx:3285
 TAuthenticate.cxx:3286
 TAuthenticate.cxx:3287
 TAuthenticate.cxx:3288
 TAuthenticate.cxx:3289
 TAuthenticate.cxx:3290
 TAuthenticate.cxx:3291
 TAuthenticate.cxx:3292
 TAuthenticate.cxx:3293
 TAuthenticate.cxx:3294
 TAuthenticate.cxx:3295
 TAuthenticate.cxx:3296
 TAuthenticate.cxx:3297
 TAuthenticate.cxx:3298
 TAuthenticate.cxx:3299
 TAuthenticate.cxx:3300
 TAuthenticate.cxx:3301
 TAuthenticate.cxx:3302
 TAuthenticate.cxx:3303
 TAuthenticate.cxx:3304
 TAuthenticate.cxx:3305
 TAuthenticate.cxx:3306
 TAuthenticate.cxx:3307
 TAuthenticate.cxx:3308
 TAuthenticate.cxx:3309
 TAuthenticate.cxx:3310
 TAuthenticate.cxx:3311
 TAuthenticate.cxx:3312
 TAuthenticate.cxx:3313
 TAuthenticate.cxx:3314
 TAuthenticate.cxx:3315
 TAuthenticate.cxx:3316
 TAuthenticate.cxx:3317
 TAuthenticate.cxx:3318
 TAuthenticate.cxx:3319
 TAuthenticate.cxx:3320
 TAuthenticate.cxx:3321
 TAuthenticate.cxx:3322
 TAuthenticate.cxx:3323
 TAuthenticate.cxx:3324
 TAuthenticate.cxx:3325
 TAuthenticate.cxx:3326
 TAuthenticate.cxx:3327
 TAuthenticate.cxx:3328
 TAuthenticate.cxx:3329
 TAuthenticate.cxx:3330
 TAuthenticate.cxx:3331
 TAuthenticate.cxx:3332
 TAuthenticate.cxx:3333
 TAuthenticate.cxx:3334
 TAuthenticate.cxx:3335
 TAuthenticate.cxx:3336
 TAuthenticate.cxx:3337
 TAuthenticate.cxx:3338
 TAuthenticate.cxx:3339
 TAuthenticate.cxx:3340
 TAuthenticate.cxx:3341
 TAuthenticate.cxx:3342
 TAuthenticate.cxx:3343
 TAuthenticate.cxx:3344
 TAuthenticate.cxx:3345
 TAuthenticate.cxx:3346
 TAuthenticate.cxx:3347
 TAuthenticate.cxx:3348
 TAuthenticate.cxx:3349
 TAuthenticate.cxx:3350
 TAuthenticate.cxx:3351
 TAuthenticate.cxx:3352
 TAuthenticate.cxx:3353
 TAuthenticate.cxx:3354
 TAuthenticate.cxx:3355
 TAuthenticate.cxx:3356
 TAuthenticate.cxx:3357
 TAuthenticate.cxx:3358
 TAuthenticate.cxx:3359
 TAuthenticate.cxx:3360
 TAuthenticate.cxx:3361
 TAuthenticate.cxx:3362
 TAuthenticate.cxx:3363
 TAuthenticate.cxx:3364
 TAuthenticate.cxx:3365
 TAuthenticate.cxx:3366
 TAuthenticate.cxx:3367
 TAuthenticate.cxx:3368
 TAuthenticate.cxx:3369
 TAuthenticate.cxx:3370
 TAuthenticate.cxx:3371
 TAuthenticate.cxx:3372
 TAuthenticate.cxx:3373
 TAuthenticate.cxx:3374
 TAuthenticate.cxx:3375
 TAuthenticate.cxx:3376
 TAuthenticate.cxx:3377
 TAuthenticate.cxx:3378
 TAuthenticate.cxx:3379
 TAuthenticate.cxx:3380
 TAuthenticate.cxx:3381
 TAuthenticate.cxx:3382
 TAuthenticate.cxx:3383
 TAuthenticate.cxx:3384
 TAuthenticate.cxx:3385
 TAuthenticate.cxx:3386
 TAuthenticate.cxx:3387
 TAuthenticate.cxx:3388
 TAuthenticate.cxx:3389
 TAuthenticate.cxx:3390
 TAuthenticate.cxx:3391
 TAuthenticate.cxx:3392
 TAuthenticate.cxx:3393
 TAuthenticate.cxx:3394
 TAuthenticate.cxx:3395
 TAuthenticate.cxx:3396
 TAuthenticate.cxx:3397
 TAuthenticate.cxx:3398
 TAuthenticate.cxx:3399
 TAuthenticate.cxx:3400
 TAuthenticate.cxx:3401
 TAuthenticate.cxx:3402
 TAuthenticate.cxx:3403
 TAuthenticate.cxx:3404
 TAuthenticate.cxx:3405
 TAuthenticate.cxx:3406
 TAuthenticate.cxx:3407
 TAuthenticate.cxx:3408
 TAuthenticate.cxx:3409
 TAuthenticate.cxx:3410
 TAuthenticate.cxx:3411
 TAuthenticate.cxx:3412
 TAuthenticate.cxx:3413
 TAuthenticate.cxx:3414
 TAuthenticate.cxx:3415
 TAuthenticate.cxx:3416
 TAuthenticate.cxx:3417
 TAuthenticate.cxx:3418
 TAuthenticate.cxx:3419
 TAuthenticate.cxx:3420
 TAuthenticate.cxx:3421
 TAuthenticate.cxx:3422
 TAuthenticate.cxx:3423
 TAuthenticate.cxx:3424
 TAuthenticate.cxx:3425
 TAuthenticate.cxx:3426
 TAuthenticate.cxx:3427
 TAuthenticate.cxx:3428
 TAuthenticate.cxx:3429
 TAuthenticate.cxx:3430
 TAuthenticate.cxx:3431
 TAuthenticate.cxx:3432
 TAuthenticate.cxx:3433
 TAuthenticate.cxx:3434
 TAuthenticate.cxx:3435
 TAuthenticate.cxx:3436
 TAuthenticate.cxx:3437
 TAuthenticate.cxx:3438
 TAuthenticate.cxx:3439
 TAuthenticate.cxx:3440
 TAuthenticate.cxx:3441
 TAuthenticate.cxx:3442
 TAuthenticate.cxx:3443
 TAuthenticate.cxx:3444
 TAuthenticate.cxx:3445
 TAuthenticate.cxx:3446
 TAuthenticate.cxx:3447
 TAuthenticate.cxx:3448
 TAuthenticate.cxx:3449
 TAuthenticate.cxx:3450
 TAuthenticate.cxx:3451
 TAuthenticate.cxx:3452
 TAuthenticate.cxx:3453
 TAuthenticate.cxx:3454
 TAuthenticate.cxx:3455
 TAuthenticate.cxx:3456
 TAuthenticate.cxx:3457
 TAuthenticate.cxx:3458
 TAuthenticate.cxx:3459
 TAuthenticate.cxx:3460
 TAuthenticate.cxx:3461
 TAuthenticate.cxx:3462
 TAuthenticate.cxx:3463
 TAuthenticate.cxx:3464
 TAuthenticate.cxx:3465
 TAuthenticate.cxx:3466
 TAuthenticate.cxx:3467
 TAuthenticate.cxx:3468
 TAuthenticate.cxx:3469
 TAuthenticate.cxx:3470
 TAuthenticate.cxx:3471
 TAuthenticate.cxx:3472
 TAuthenticate.cxx:3473
 TAuthenticate.cxx:3474
 TAuthenticate.cxx:3475
 TAuthenticate.cxx:3476
 TAuthenticate.cxx:3477
 TAuthenticate.cxx:3478
 TAuthenticate.cxx:3479
 TAuthenticate.cxx:3480
 TAuthenticate.cxx:3481
 TAuthenticate.cxx:3482
 TAuthenticate.cxx:3483
 TAuthenticate.cxx:3484
 TAuthenticate.cxx:3485
 TAuthenticate.cxx:3486
 TAuthenticate.cxx:3487
 TAuthenticate.cxx:3488
 TAuthenticate.cxx:3489
 TAuthenticate.cxx:3490
 TAuthenticate.cxx:3491
 TAuthenticate.cxx:3492
 TAuthenticate.cxx:3493
 TAuthenticate.cxx:3494
 TAuthenticate.cxx:3495
 TAuthenticate.cxx:3496
 TAuthenticate.cxx:3497
 TAuthenticate.cxx:3498
 TAuthenticate.cxx:3499
 TAuthenticate.cxx:3500
 TAuthenticate.cxx:3501
 TAuthenticate.cxx:3502
 TAuthenticate.cxx:3503
 TAuthenticate.cxx:3504
 TAuthenticate.cxx:3505
 TAuthenticate.cxx:3506
 TAuthenticate.cxx:3507
 TAuthenticate.cxx:3508
 TAuthenticate.cxx:3509
 TAuthenticate.cxx:3510
 TAuthenticate.cxx:3511
 TAuthenticate.cxx:3512
 TAuthenticate.cxx:3513
 TAuthenticate.cxx:3514
 TAuthenticate.cxx:3515
 TAuthenticate.cxx:3516
 TAuthenticate.cxx:3517
 TAuthenticate.cxx:3518
 TAuthenticate.cxx:3519
 TAuthenticate.cxx:3520
 TAuthenticate.cxx:3521
 TAuthenticate.cxx:3522
 TAuthenticate.cxx:3523
 TAuthenticate.cxx:3524
 TAuthenticate.cxx:3525
 TAuthenticate.cxx:3526
 TAuthenticate.cxx:3527
 TAuthenticate.cxx:3528
 TAuthenticate.cxx:3529
 TAuthenticate.cxx:3530
 TAuthenticate.cxx:3531
 TAuthenticate.cxx:3532
 TAuthenticate.cxx:3533
 TAuthenticate.cxx:3534
 TAuthenticate.cxx:3535
 TAuthenticate.cxx:3536
 TAuthenticate.cxx:3537
 TAuthenticate.cxx:3538
 TAuthenticate.cxx:3539
 TAuthenticate.cxx:3540
 TAuthenticate.cxx:3541
 TAuthenticate.cxx:3542
 TAuthenticate.cxx:3543
 TAuthenticate.cxx:3544
 TAuthenticate.cxx:3545
 TAuthenticate.cxx:3546
 TAuthenticate.cxx:3547
 TAuthenticate.cxx:3548
 TAuthenticate.cxx:3549
 TAuthenticate.cxx:3550
 TAuthenticate.cxx:3551
 TAuthenticate.cxx:3552
 TAuthenticate.cxx:3553
 TAuthenticate.cxx:3554
 TAuthenticate.cxx:3555
 TAuthenticate.cxx:3556
 TAuthenticate.cxx:3557
 TAuthenticate.cxx:3558
 TAuthenticate.cxx:3559
 TAuthenticate.cxx:3560
 TAuthenticate.cxx:3561
 TAuthenticate.cxx:3562
 TAuthenticate.cxx:3563
 TAuthenticate.cxx:3564
 TAuthenticate.cxx:3565
 TAuthenticate.cxx:3566
 TAuthenticate.cxx:3567
 TAuthenticate.cxx:3568
 TAuthenticate.cxx:3569
 TAuthenticate.cxx:3570
 TAuthenticate.cxx:3571
 TAuthenticate.cxx:3572
 TAuthenticate.cxx:3573
 TAuthenticate.cxx:3574
 TAuthenticate.cxx:3575
 TAuthenticate.cxx:3576
 TAuthenticate.cxx:3577
 TAuthenticate.cxx:3578
 TAuthenticate.cxx:3579
 TAuthenticate.cxx:3580
 TAuthenticate.cxx:3581
 TAuthenticate.cxx:3582
 TAuthenticate.cxx:3583
 TAuthenticate.cxx:3584
 TAuthenticate.cxx:3585
 TAuthenticate.cxx:3586
 TAuthenticate.cxx:3587
 TAuthenticate.cxx:3588
 TAuthenticate.cxx:3589
 TAuthenticate.cxx:3590
 TAuthenticate.cxx:3591
 TAuthenticate.cxx:3592
 TAuthenticate.cxx:3593
 TAuthenticate.cxx:3594
 TAuthenticate.cxx:3595
 TAuthenticate.cxx:3596
 TAuthenticate.cxx:3597
 TAuthenticate.cxx:3598
 TAuthenticate.cxx:3599
 TAuthenticate.cxx:3600
 TAuthenticate.cxx:3601
 TAuthenticate.cxx:3602
 TAuthenticate.cxx:3603
 TAuthenticate.cxx:3604
 TAuthenticate.cxx:3605
 TAuthenticate.cxx:3606
 TAuthenticate.cxx:3607
 TAuthenticate.cxx:3608
 TAuthenticate.cxx:3609
 TAuthenticate.cxx:3610
 TAuthenticate.cxx:3611
 TAuthenticate.cxx:3612
 TAuthenticate.cxx:3613
 TAuthenticate.cxx:3614
 TAuthenticate.cxx:3615
 TAuthenticate.cxx:3616
 TAuthenticate.cxx:3617
 TAuthenticate.cxx:3618
 TAuthenticate.cxx:3619
 TAuthenticate.cxx:3620
 TAuthenticate.cxx:3621
 TAuthenticate.cxx:3622
 TAuthenticate.cxx:3623
 TAuthenticate.cxx:3624
 TAuthenticate.cxx:3625
 TAuthenticate.cxx:3626
 TAuthenticate.cxx:3627
 TAuthenticate.cxx:3628
 TAuthenticate.cxx:3629
 TAuthenticate.cxx:3630
 TAuthenticate.cxx:3631
 TAuthenticate.cxx:3632
 TAuthenticate.cxx:3633
 TAuthenticate.cxx:3634
 TAuthenticate.cxx:3635
 TAuthenticate.cxx:3636
 TAuthenticate.cxx:3637
 TAuthenticate.cxx:3638
 TAuthenticate.cxx:3639
 TAuthenticate.cxx:3640
 TAuthenticate.cxx:3641
 TAuthenticate.cxx:3642
 TAuthenticate.cxx:3643
 TAuthenticate.cxx:3644
 TAuthenticate.cxx:3645
 TAuthenticate.cxx:3646
 TAuthenticate.cxx:3647
 TAuthenticate.cxx:3648
 TAuthenticate.cxx:3649
 TAuthenticate.cxx:3650
 TAuthenticate.cxx:3651
 TAuthenticate.cxx:3652
 TAuthenticate.cxx:3653
 TAuthenticate.cxx:3654
 TAuthenticate.cxx:3655
 TAuthenticate.cxx:3656
 TAuthenticate.cxx:3657
 TAuthenticate.cxx:3658
 TAuthenticate.cxx:3659
 TAuthenticate.cxx:3660
 TAuthenticate.cxx:3661
 TAuthenticate.cxx:3662
 TAuthenticate.cxx:3663
 TAuthenticate.cxx:3664
 TAuthenticate.cxx:3665
 TAuthenticate.cxx:3666
 TAuthenticate.cxx:3667
 TAuthenticate.cxx:3668
 TAuthenticate.cxx:3669
 TAuthenticate.cxx:3670
 TAuthenticate.cxx:3671
 TAuthenticate.cxx:3672
 TAuthenticate.cxx:3673
 TAuthenticate.cxx:3674
 TAuthenticate.cxx:3675
 TAuthenticate.cxx:3676
 TAuthenticate.cxx:3677
 TAuthenticate.cxx:3678
 TAuthenticate.cxx:3679
 TAuthenticate.cxx:3680
 TAuthenticate.cxx:3681
 TAuthenticate.cxx:3682
 TAuthenticate.cxx:3683
 TAuthenticate.cxx:3684
 TAuthenticate.cxx:3685
 TAuthenticate.cxx:3686
 TAuthenticate.cxx:3687
 TAuthenticate.cxx:3688
 TAuthenticate.cxx:3689
 TAuthenticate.cxx:3690
 TAuthenticate.cxx:3691
 TAuthenticate.cxx:3692
 TAuthenticate.cxx:3693
 TAuthenticate.cxx:3694
 TAuthenticate.cxx:3695
 TAuthenticate.cxx:3696
 TAuthenticate.cxx:3697
 TAuthenticate.cxx:3698
 TAuthenticate.cxx:3699
 TAuthenticate.cxx:3700
 TAuthenticate.cxx:3701
 TAuthenticate.cxx:3702
 TAuthenticate.cxx:3703
 TAuthenticate.cxx:3704
 TAuthenticate.cxx:3705
 TAuthenticate.cxx:3706
 TAuthenticate.cxx:3707
 TAuthenticate.cxx:3708
 TAuthenticate.cxx:3709
 TAuthenticate.cxx:3710
 TAuthenticate.cxx:3711
 TAuthenticate.cxx:3712
 TAuthenticate.cxx:3713
 TAuthenticate.cxx:3714
 TAuthenticate.cxx:3715
 TAuthenticate.cxx:3716
 TAuthenticate.cxx:3717
 TAuthenticate.cxx:3718
 TAuthenticate.cxx:3719
 TAuthenticate.cxx:3720
 TAuthenticate.cxx:3721
 TAuthenticate.cxx:3722
 TAuthenticate.cxx:3723
 TAuthenticate.cxx:3724
 TAuthenticate.cxx:3725
 TAuthenticate.cxx:3726
 TAuthenticate.cxx:3727
 TAuthenticate.cxx:3728
 TAuthenticate.cxx:3729
 TAuthenticate.cxx:3730
 TAuthenticate.cxx:3731
 TAuthenticate.cxx:3732
 TAuthenticate.cxx:3733
 TAuthenticate.cxx:3734
 TAuthenticate.cxx:3735
 TAuthenticate.cxx:3736
 TAuthenticate.cxx:3737
 TAuthenticate.cxx:3738
 TAuthenticate.cxx:3739
 TAuthenticate.cxx:3740
 TAuthenticate.cxx:3741
 TAuthenticate.cxx:3742
 TAuthenticate.cxx:3743
 TAuthenticate.cxx:3744
 TAuthenticate.cxx:3745
 TAuthenticate.cxx:3746
 TAuthenticate.cxx:3747
 TAuthenticate.cxx:3748
 TAuthenticate.cxx:3749
 TAuthenticate.cxx:3750
 TAuthenticate.cxx:3751
 TAuthenticate.cxx:3752
 TAuthenticate.cxx:3753
 TAuthenticate.cxx:3754
 TAuthenticate.cxx:3755
 TAuthenticate.cxx:3756
 TAuthenticate.cxx:3757
 TAuthenticate.cxx:3758
 TAuthenticate.cxx:3759
 TAuthenticate.cxx:3760
 TAuthenticate.cxx:3761
 TAuthenticate.cxx:3762
 TAuthenticate.cxx:3763
 TAuthenticate.cxx:3764
 TAuthenticate.cxx:3765
 TAuthenticate.cxx:3766
 TAuthenticate.cxx:3767
 TAuthenticate.cxx:3768
 TAuthenticate.cxx:3769
 TAuthenticate.cxx:3770
 TAuthenticate.cxx:3771
 TAuthenticate.cxx:3772
 TAuthenticate.cxx:3773
 TAuthenticate.cxx:3774
 TAuthenticate.cxx:3775
 TAuthenticate.cxx:3776
 TAuthenticate.cxx:3777
 TAuthenticate.cxx:3778
 TAuthenticate.cxx:3779
 TAuthenticate.cxx:3780
 TAuthenticate.cxx:3781
 TAuthenticate.cxx:3782
 TAuthenticate.cxx:3783
 TAuthenticate.cxx:3784
 TAuthenticate.cxx:3785
 TAuthenticate.cxx:3786
 TAuthenticate.cxx:3787
 TAuthenticate.cxx:3788
 TAuthenticate.cxx:3789
 TAuthenticate.cxx:3790
 TAuthenticate.cxx:3791
 TAuthenticate.cxx:3792
 TAuthenticate.cxx:3793
 TAuthenticate.cxx:3794
 TAuthenticate.cxx:3795
 TAuthenticate.cxx:3796
 TAuthenticate.cxx:3797
 TAuthenticate.cxx:3798
 TAuthenticate.cxx:3799
 TAuthenticate.cxx:3800
 TAuthenticate.cxx:3801
 TAuthenticate.cxx:3802
 TAuthenticate.cxx:3803
 TAuthenticate.cxx:3804
 TAuthenticate.cxx:3805
 TAuthenticate.cxx:3806
 TAuthenticate.cxx:3807
 TAuthenticate.cxx:3808
 TAuthenticate.cxx:3809
 TAuthenticate.cxx:3810
 TAuthenticate.cxx:3811
 TAuthenticate.cxx:3812
 TAuthenticate.cxx:3813
 TAuthenticate.cxx:3814
 TAuthenticate.cxx:3815
 TAuthenticate.cxx:3816
 TAuthenticate.cxx:3817
 TAuthenticate.cxx:3818
 TAuthenticate.cxx:3819
 TAuthenticate.cxx:3820
 TAuthenticate.cxx:3821
 TAuthenticate.cxx:3822
 TAuthenticate.cxx:3823
 TAuthenticate.cxx:3824
 TAuthenticate.cxx:3825
 TAuthenticate.cxx:3826
 TAuthenticate.cxx:3827
 TAuthenticate.cxx:3828
 TAuthenticate.cxx:3829
 TAuthenticate.cxx:3830
 TAuthenticate.cxx:3831
 TAuthenticate.cxx:3832
 TAuthenticate.cxx:3833
 TAuthenticate.cxx:3834
 TAuthenticate.cxx:3835
 TAuthenticate.cxx:3836
 TAuthenticate.cxx:3837
 TAuthenticate.cxx:3838
 TAuthenticate.cxx:3839
 TAuthenticate.cxx:3840
 TAuthenticate.cxx:3841
 TAuthenticate.cxx:3842
 TAuthenticate.cxx:3843
 TAuthenticate.cxx:3844
 TAuthenticate.cxx:3845
 TAuthenticate.cxx:3846
 TAuthenticate.cxx:3847
 TAuthenticate.cxx:3848
 TAuthenticate.cxx:3849
 TAuthenticate.cxx:3850
 TAuthenticate.cxx:3851
 TAuthenticate.cxx:3852
 TAuthenticate.cxx:3853
 TAuthenticate.cxx:3854
 TAuthenticate.cxx:3855
 TAuthenticate.cxx:3856
 TAuthenticate.cxx:3857
 TAuthenticate.cxx:3858
 TAuthenticate.cxx:3859
 TAuthenticate.cxx:3860
 TAuthenticate.cxx:3861
 TAuthenticate.cxx:3862
 TAuthenticate.cxx:3863
 TAuthenticate.cxx:3864
 TAuthenticate.cxx:3865
 TAuthenticate.cxx:3866
 TAuthenticate.cxx:3867
 TAuthenticate.cxx:3868
 TAuthenticate.cxx:3869
 TAuthenticate.cxx:3870
 TAuthenticate.cxx:3871
 TAuthenticate.cxx:3872
 TAuthenticate.cxx:3873
 TAuthenticate.cxx:3874
 TAuthenticate.cxx:3875
 TAuthenticate.cxx:3876
 TAuthenticate.cxx:3877
 TAuthenticate.cxx:3878
 TAuthenticate.cxx:3879
 TAuthenticate.cxx:3880
 TAuthenticate.cxx:3881
 TAuthenticate.cxx:3882
 TAuthenticate.cxx:3883
 TAuthenticate.cxx:3884
 TAuthenticate.cxx:3885
 TAuthenticate.cxx:3886
 TAuthenticate.cxx:3887
 TAuthenticate.cxx:3888
 TAuthenticate.cxx:3889
 TAuthenticate.cxx:3890
 TAuthenticate.cxx:3891
 TAuthenticate.cxx:3892
 TAuthenticate.cxx:3893
 TAuthenticate.cxx:3894
 TAuthenticate.cxx:3895
 TAuthenticate.cxx:3896
 TAuthenticate.cxx:3897
 TAuthenticate.cxx:3898
 TAuthenticate.cxx:3899
 TAuthenticate.cxx:3900
 TAuthenticate.cxx:3901
 TAuthenticate.cxx:3902
 TAuthenticate.cxx:3903
 TAuthenticate.cxx:3904
 TAuthenticate.cxx:3905
 TAuthenticate.cxx:3906
 TAuthenticate.cxx:3907
 TAuthenticate.cxx:3908
 TAuthenticate.cxx:3909
 TAuthenticate.cxx:3910
 TAuthenticate.cxx:3911
 TAuthenticate.cxx:3912
 TAuthenticate.cxx:3913
 TAuthenticate.cxx:3914
 TAuthenticate.cxx:3915
 TAuthenticate.cxx:3916
 TAuthenticate.cxx:3917
 TAuthenticate.cxx:3918
 TAuthenticate.cxx:3919
 TAuthenticate.cxx:3920
 TAuthenticate.cxx:3921
 TAuthenticate.cxx:3922
 TAuthenticate.cxx:3923
 TAuthenticate.cxx:3924
 TAuthenticate.cxx:3925
 TAuthenticate.cxx:3926
 TAuthenticate.cxx:3927
 TAuthenticate.cxx:3928
 TAuthenticate.cxx:3929
 TAuthenticate.cxx:3930
 TAuthenticate.cxx:3931
 TAuthenticate.cxx:3932
 TAuthenticate.cxx:3933
 TAuthenticate.cxx:3934
 TAuthenticate.cxx:3935
 TAuthenticate.cxx:3936
 TAuthenticate.cxx:3937
 TAuthenticate.cxx:3938
 TAuthenticate.cxx:3939
 TAuthenticate.cxx:3940
 TAuthenticate.cxx:3941
 TAuthenticate.cxx:3942
 TAuthenticate.cxx:3943
 TAuthenticate.cxx:3944
 TAuthenticate.cxx:3945
 TAuthenticate.cxx:3946
 TAuthenticate.cxx:3947
 TAuthenticate.cxx:3948
 TAuthenticate.cxx:3949
 TAuthenticate.cxx:3950
 TAuthenticate.cxx:3951
 TAuthenticate.cxx:3952
 TAuthenticate.cxx:3953
 TAuthenticate.cxx:3954
 TAuthenticate.cxx:3955
 TAuthenticate.cxx:3956
 TAuthenticate.cxx:3957
 TAuthenticate.cxx:3958
 TAuthenticate.cxx:3959
 TAuthenticate.cxx:3960
 TAuthenticate.cxx:3961
 TAuthenticate.cxx:3962
 TAuthenticate.cxx:3963
 TAuthenticate.cxx:3964
 TAuthenticate.cxx:3965
 TAuthenticate.cxx:3966
 TAuthenticate.cxx:3967
 TAuthenticate.cxx:3968
 TAuthenticate.cxx:3969
 TAuthenticate.cxx:3970
 TAuthenticate.cxx:3971
 TAuthenticate.cxx:3972
 TAuthenticate.cxx:3973
 TAuthenticate.cxx:3974
 TAuthenticate.cxx:3975
 TAuthenticate.cxx:3976
 TAuthenticate.cxx:3977
 TAuthenticate.cxx:3978
 TAuthenticate.cxx:3979
 TAuthenticate.cxx:3980
 TAuthenticate.cxx:3981
 TAuthenticate.cxx:3982
 TAuthenticate.cxx:3983
 TAuthenticate.cxx:3984
 TAuthenticate.cxx:3985
 TAuthenticate.cxx:3986
 TAuthenticate.cxx:3987
 TAuthenticate.cxx:3988
 TAuthenticate.cxx:3989
 TAuthenticate.cxx:3990
 TAuthenticate.cxx:3991
 TAuthenticate.cxx:3992
 TAuthenticate.cxx:3993
 TAuthenticate.cxx:3994
 TAuthenticate.cxx:3995
 TAuthenticate.cxx:3996
 TAuthenticate.cxx:3997
 TAuthenticate.cxx:3998
 TAuthenticate.cxx:3999
 TAuthenticate.cxx:4000
 TAuthenticate.cxx:4001
 TAuthenticate.cxx:4002
 TAuthenticate.cxx:4003
 TAuthenticate.cxx:4004
 TAuthenticate.cxx:4005
 TAuthenticate.cxx:4006
 TAuthenticate.cxx:4007
 TAuthenticate.cxx:4008
 TAuthenticate.cxx:4009
 TAuthenticate.cxx:4010
 TAuthenticate.cxx:4011
 TAuthenticate.cxx:4012
 TAuthenticate.cxx:4013
 TAuthenticate.cxx:4014
 TAuthenticate.cxx:4015
 TAuthenticate.cxx:4016
 TAuthenticate.cxx:4017
 TAuthenticate.cxx:4018
 TAuthenticate.cxx:4019
 TAuthenticate.cxx:4020
 TAuthenticate.cxx:4021
 TAuthenticate.cxx:4022
 TAuthenticate.cxx:4023
 TAuthenticate.cxx:4024
 TAuthenticate.cxx:4025
 TAuthenticate.cxx:4026
 TAuthenticate.cxx:4027
 TAuthenticate.cxx:4028
 TAuthenticate.cxx:4029
 TAuthenticate.cxx:4030
 TAuthenticate.cxx:4031
 TAuthenticate.cxx:4032
 TAuthenticate.cxx:4033
 TAuthenticate.cxx:4034
 TAuthenticate.cxx:4035
 TAuthenticate.cxx:4036
 TAuthenticate.cxx:4037
 TAuthenticate.cxx:4038
 TAuthenticate.cxx:4039
 TAuthenticate.cxx:4040
 TAuthenticate.cxx:4041
 TAuthenticate.cxx:4042
 TAuthenticate.cxx:4043
 TAuthenticate.cxx:4044
 TAuthenticate.cxx:4045
 TAuthenticate.cxx:4046
 TAuthenticate.cxx:4047
 TAuthenticate.cxx:4048
 TAuthenticate.cxx:4049
 TAuthenticate.cxx:4050
 TAuthenticate.cxx:4051
 TAuthenticate.cxx:4052
 TAuthenticate.cxx:4053
 TAuthenticate.cxx:4054
 TAuthenticate.cxx:4055
 TAuthenticate.cxx:4056
 TAuthenticate.cxx:4057
 TAuthenticate.cxx:4058
 TAuthenticate.cxx:4059
 TAuthenticate.cxx:4060
 TAuthenticate.cxx:4061
 TAuthenticate.cxx:4062
 TAuthenticate.cxx:4063
 TAuthenticate.cxx:4064
 TAuthenticate.cxx:4065
 TAuthenticate.cxx:4066
 TAuthenticate.cxx:4067
 TAuthenticate.cxx:4068
 TAuthenticate.cxx:4069
 TAuthenticate.cxx:4070
 TAuthenticate.cxx:4071
 TAuthenticate.cxx:4072
 TAuthenticate.cxx:4073
 TAuthenticate.cxx:4074
 TAuthenticate.cxx:4075
 TAuthenticate.cxx:4076
 TAuthenticate.cxx:4077
 TAuthenticate.cxx:4078
 TAuthenticate.cxx:4079
 TAuthenticate.cxx:4080
 TAuthenticate.cxx:4081
 TAuthenticate.cxx:4082
 TAuthenticate.cxx:4083
 TAuthenticate.cxx:4084
 TAuthenticate.cxx:4085
 TAuthenticate.cxx:4086
 TAuthenticate.cxx:4087
 TAuthenticate.cxx:4088
 TAuthenticate.cxx:4089
 TAuthenticate.cxx:4090
 TAuthenticate.cxx:4091
 TAuthenticate.cxx:4092
 TAuthenticate.cxx:4093
 TAuthenticate.cxx:4094
 TAuthenticate.cxx:4095
 TAuthenticate.cxx:4096
 TAuthenticate.cxx:4097
 TAuthenticate.cxx:4098
 TAuthenticate.cxx:4099
 TAuthenticate.cxx:4100
 TAuthenticate.cxx:4101
 TAuthenticate.cxx:4102
 TAuthenticate.cxx:4103
 TAuthenticate.cxx:4104
 TAuthenticate.cxx:4105
 TAuthenticate.cxx:4106
 TAuthenticate.cxx:4107
 TAuthenticate.cxx:4108
 TAuthenticate.cxx:4109
 TAuthenticate.cxx:4110
 TAuthenticate.cxx:4111
 TAuthenticate.cxx:4112
 TAuthenticate.cxx:4113
 TAuthenticate.cxx:4114
 TAuthenticate.cxx:4115
 TAuthenticate.cxx:4116
 TAuthenticate.cxx:4117
 TAuthenticate.cxx:4118
 TAuthenticate.cxx:4119
 TAuthenticate.cxx:4120
 TAuthenticate.cxx:4121
 TAuthenticate.cxx:4122
 TAuthenticate.cxx:4123
 TAuthenticate.cxx:4124
 TAuthenticate.cxx:4125
 TAuthenticate.cxx:4126
 TAuthenticate.cxx:4127
 TAuthenticate.cxx:4128
 TAuthenticate.cxx:4129
 TAuthenticate.cxx:4130
 TAuthenticate.cxx:4131
 TAuthenticate.cxx:4132
 TAuthenticate.cxx:4133
 TAuthenticate.cxx:4134
 TAuthenticate.cxx:4135
 TAuthenticate.cxx:4136
 TAuthenticate.cxx:4137
 TAuthenticate.cxx:4138
 TAuthenticate.cxx:4139
 TAuthenticate.cxx:4140
 TAuthenticate.cxx:4141
 TAuthenticate.cxx:4142
 TAuthenticate.cxx:4143
 TAuthenticate.cxx:4144
 TAuthenticate.cxx:4145
 TAuthenticate.cxx:4146
 TAuthenticate.cxx:4147
 TAuthenticate.cxx:4148
 TAuthenticate.cxx:4149
 TAuthenticate.cxx:4150
 TAuthenticate.cxx:4151
 TAuthenticate.cxx:4152
 TAuthenticate.cxx:4153
 TAuthenticate.cxx:4154
 TAuthenticate.cxx:4155
 TAuthenticate.cxx:4156
 TAuthenticate.cxx:4157
 TAuthenticate.cxx:4158
 TAuthenticate.cxx:4159
 TAuthenticate.cxx:4160
 TAuthenticate.cxx:4161
 TAuthenticate.cxx:4162
 TAuthenticate.cxx:4163
 TAuthenticate.cxx:4164
 TAuthenticate.cxx:4165
 TAuthenticate.cxx:4166
 TAuthenticate.cxx:4167
 TAuthenticate.cxx:4168
 TAuthenticate.cxx:4169
 TAuthenticate.cxx:4170
 TAuthenticate.cxx:4171
 TAuthenticate.cxx:4172
 TAuthenticate.cxx:4173
 TAuthenticate.cxx:4174
 TAuthenticate.cxx:4175
 TAuthenticate.cxx:4176
 TAuthenticate.cxx:4177
 TAuthenticate.cxx:4178
 TAuthenticate.cxx:4179
 TAuthenticate.cxx:4180
 TAuthenticate.cxx:4181
 TAuthenticate.cxx:4182
 TAuthenticate.cxx:4183
 TAuthenticate.cxx:4184
 TAuthenticate.cxx:4185
 TAuthenticate.cxx:4186
 TAuthenticate.cxx:4187
 TAuthenticate.cxx:4188
 TAuthenticate.cxx:4189
 TAuthenticate.cxx:4190
 TAuthenticate.cxx:4191
 TAuthenticate.cxx:4192
 TAuthenticate.cxx:4193
 TAuthenticate.cxx:4194
 TAuthenticate.cxx:4195
 TAuthenticate.cxx:4196
 TAuthenticate.cxx:4197
 TAuthenticate.cxx:4198
 TAuthenticate.cxx:4199
 TAuthenticate.cxx:4200
 TAuthenticate.cxx:4201
 TAuthenticate.cxx:4202
 TAuthenticate.cxx:4203
 TAuthenticate.cxx:4204
 TAuthenticate.cxx:4205
 TAuthenticate.cxx:4206
 TAuthenticate.cxx:4207
 TAuthenticate.cxx:4208
 TAuthenticate.cxx:4209
 TAuthenticate.cxx:4210
 TAuthenticate.cxx:4211
 TAuthenticate.cxx:4212
 TAuthenticate.cxx:4213
 TAuthenticate.cxx:4214
 TAuthenticate.cxx:4215
 TAuthenticate.cxx:4216
 TAuthenticate.cxx:4217
 TAuthenticate.cxx:4218
 TAuthenticate.cxx:4219
 TAuthenticate.cxx:4220
 TAuthenticate.cxx:4221
 TAuthenticate.cxx:4222
 TAuthenticate.cxx:4223
 TAuthenticate.cxx:4224
 TAuthenticate.cxx:4225
 TAuthenticate.cxx:4226
 TAuthenticate.cxx:4227
 TAuthenticate.cxx:4228
 TAuthenticate.cxx:4229
 TAuthenticate.cxx:4230
 TAuthenticate.cxx:4231
 TAuthenticate.cxx:4232
 TAuthenticate.cxx:4233
 TAuthenticate.cxx:4234
 TAuthenticate.cxx:4235
 TAuthenticate.cxx:4236
 TAuthenticate.cxx:4237
 TAuthenticate.cxx:4238
 TAuthenticate.cxx:4239
 TAuthenticate.cxx:4240
 TAuthenticate.cxx:4241
 TAuthenticate.cxx:4242
 TAuthenticate.cxx:4243
 TAuthenticate.cxx:4244
 TAuthenticate.cxx:4245
 TAuthenticate.cxx:4246
 TAuthenticate.cxx:4247
 TAuthenticate.cxx:4248
 TAuthenticate.cxx:4249
 TAuthenticate.cxx:4250
 TAuthenticate.cxx:4251
 TAuthenticate.cxx:4252
 TAuthenticate.cxx:4253
 TAuthenticate.cxx:4254
 TAuthenticate.cxx:4255
 TAuthenticate.cxx:4256
 TAuthenticate.cxx:4257
 TAuthenticate.cxx:4258
 TAuthenticate.cxx:4259
 TAuthenticate.cxx:4260
 TAuthenticate.cxx:4261
 TAuthenticate.cxx:4262
 TAuthenticate.cxx:4263
 TAuthenticate.cxx:4264
 TAuthenticate.cxx:4265
 TAuthenticate.cxx:4266
 TAuthenticate.cxx:4267
 TAuthenticate.cxx:4268
 TAuthenticate.cxx:4269
 TAuthenticate.cxx:4270
 TAuthenticate.cxx:4271
 TAuthenticate.cxx:4272
 TAuthenticate.cxx:4273
 TAuthenticate.cxx:4274
 TAuthenticate.cxx:4275
 TAuthenticate.cxx:4276
 TAuthenticate.cxx:4277
 TAuthenticate.cxx:4278
 TAuthenticate.cxx:4279
 TAuthenticate.cxx:4280
 TAuthenticate.cxx:4281
 TAuthenticate.cxx:4282
 TAuthenticate.cxx:4283
 TAuthenticate.cxx:4284
 TAuthenticate.cxx:4285
 TAuthenticate.cxx:4286
 TAuthenticate.cxx:4287
 TAuthenticate.cxx:4288
 TAuthenticate.cxx:4289
 TAuthenticate.cxx:4290
 TAuthenticate.cxx:4291
 TAuthenticate.cxx:4292
 TAuthenticate.cxx:4293
 TAuthenticate.cxx:4294
 TAuthenticate.cxx:4295
 TAuthenticate.cxx:4296
 TAuthenticate.cxx:4297
 TAuthenticate.cxx:4298
 TAuthenticate.cxx:4299
 TAuthenticate.cxx:4300
 TAuthenticate.cxx:4301
 TAuthenticate.cxx:4302
 TAuthenticate.cxx:4303
 TAuthenticate.cxx:4304
 TAuthenticate.cxx:4305
 TAuthenticate.cxx:4306
 TAuthenticate.cxx:4307
 TAuthenticate.cxx:4308
 TAuthenticate.cxx:4309
 TAuthenticate.cxx:4310
 TAuthenticate.cxx:4311
 TAuthenticate.cxx:4312
 TAuthenticate.cxx:4313
 TAuthenticate.cxx:4314
 TAuthenticate.cxx:4315
 TAuthenticate.cxx:4316
 TAuthenticate.cxx:4317
 TAuthenticate.cxx:4318
 TAuthenticate.cxx:4319
 TAuthenticate.cxx:4320
 TAuthenticate.cxx:4321
 TAuthenticate.cxx:4322
 TAuthenticate.cxx:4323
 TAuthenticate.cxx:4324
 TAuthenticate.cxx:4325
 TAuthenticate.cxx:4326
 TAuthenticate.cxx:4327
 TAuthenticate.cxx:4328
 TAuthenticate.cxx:4329
 TAuthenticate.cxx:4330
 TAuthenticate.cxx:4331
 TAuthenticate.cxx:4332
 TAuthenticate.cxx:4333
 TAuthenticate.cxx:4334
 TAuthenticate.cxx:4335
 TAuthenticate.cxx:4336
 TAuthenticate.cxx:4337
 TAuthenticate.cxx:4338
 TAuthenticate.cxx:4339
 TAuthenticate.cxx:4340
 TAuthenticate.cxx:4341
 TAuthenticate.cxx:4342
 TAuthenticate.cxx:4343
 TAuthenticate.cxx:4344
 TAuthenticate.cxx:4345
 TAuthenticate.cxx:4346
 TAuthenticate.cxx:4347
 TAuthenticate.cxx:4348
 TAuthenticate.cxx:4349
 TAuthenticate.cxx:4350
 TAuthenticate.cxx:4351
 TAuthenticate.cxx:4352
 TAuthenticate.cxx:4353
 TAuthenticate.cxx:4354
 TAuthenticate.cxx:4355
 TAuthenticate.cxx:4356
 TAuthenticate.cxx:4357
 TAuthenticate.cxx:4358
 TAuthenticate.cxx:4359
 TAuthenticate.cxx:4360
 TAuthenticate.cxx:4361
 TAuthenticate.cxx:4362
 TAuthenticate.cxx:4363
 TAuthenticate.cxx:4364
 TAuthenticate.cxx:4365
 TAuthenticate.cxx:4366
 TAuthenticate.cxx:4367
 TAuthenticate.cxx:4368
 TAuthenticate.cxx:4369
 TAuthenticate.cxx:4370
 TAuthenticate.cxx:4371
 TAuthenticate.cxx:4372
 TAuthenticate.cxx:4373
 TAuthenticate.cxx:4374
 TAuthenticate.cxx:4375
 TAuthenticate.cxx:4376
 TAuthenticate.cxx:4377
 TAuthenticate.cxx:4378
 TAuthenticate.cxx:4379
 TAuthenticate.cxx:4380
 TAuthenticate.cxx:4381
 TAuthenticate.cxx:4382
 TAuthenticate.cxx:4383
 TAuthenticate.cxx:4384
 TAuthenticate.cxx:4385
 TAuthenticate.cxx:4386
 TAuthenticate.cxx:4387
 TAuthenticate.cxx:4388
 TAuthenticate.cxx:4389
 TAuthenticate.cxx:4390
 TAuthenticate.cxx:4391
 TAuthenticate.cxx:4392
 TAuthenticate.cxx:4393
 TAuthenticate.cxx:4394
 TAuthenticate.cxx:4395
 TAuthenticate.cxx:4396
 TAuthenticate.cxx:4397
 TAuthenticate.cxx:4398
 TAuthenticate.cxx:4399
 TAuthenticate.cxx:4400
 TAuthenticate.cxx:4401
 TAuthenticate.cxx:4402
 TAuthenticate.cxx:4403
 TAuthenticate.cxx:4404
 TAuthenticate.cxx:4405
 TAuthenticate.cxx:4406
 TAuthenticate.cxx:4407
 TAuthenticate.cxx:4408
 TAuthenticate.cxx:4409
 TAuthenticate.cxx:4410
 TAuthenticate.cxx:4411
 TAuthenticate.cxx:4412
 TAuthenticate.cxx:4413
 TAuthenticate.cxx:4414
 TAuthenticate.cxx:4415
 TAuthenticate.cxx:4416
 TAuthenticate.cxx:4417
 TAuthenticate.cxx:4418
 TAuthenticate.cxx:4419
 TAuthenticate.cxx:4420
 TAuthenticate.cxx:4421
 TAuthenticate.cxx:4422
 TAuthenticate.cxx:4423
 TAuthenticate.cxx:4424
 TAuthenticate.cxx:4425
 TAuthenticate.cxx:4426
 TAuthenticate.cxx:4427
 TAuthenticate.cxx:4428
 TAuthenticate.cxx:4429
 TAuthenticate.cxx:4430
 TAuthenticate.cxx:4431
 TAuthenticate.cxx:4432
 TAuthenticate.cxx:4433
 TAuthenticate.cxx:4434
 TAuthenticate.cxx:4435
 TAuthenticate.cxx:4436
 TAuthenticate.cxx:4437
 TAuthenticate.cxx:4438
 TAuthenticate.cxx:4439
 TAuthenticate.cxx:4440
 TAuthenticate.cxx:4441
 TAuthenticate.cxx:4442
 TAuthenticate.cxx:4443
 TAuthenticate.cxx:4444
 TAuthenticate.cxx:4445
 TAuthenticate.cxx:4446
 TAuthenticate.cxx:4447
 TAuthenticate.cxx:4448
 TAuthenticate.cxx:4449
 TAuthenticate.cxx:4450
 TAuthenticate.cxx:4451
 TAuthenticate.cxx:4452
 TAuthenticate.cxx:4453
 TAuthenticate.cxx:4454
 TAuthenticate.cxx:4455
 TAuthenticate.cxx:4456
 TAuthenticate.cxx:4457
 TAuthenticate.cxx:4458
 TAuthenticate.cxx:4459
 TAuthenticate.cxx:4460
 TAuthenticate.cxx:4461
 TAuthenticate.cxx:4462
 TAuthenticate.cxx:4463
 TAuthenticate.cxx:4464
 TAuthenticate.cxx:4465
 TAuthenticate.cxx:4466
 TAuthenticate.cxx:4467
 TAuthenticate.cxx:4468
 TAuthenticate.cxx:4469
 TAuthenticate.cxx:4470
 TAuthenticate.cxx:4471
 TAuthenticate.cxx:4472
 TAuthenticate.cxx:4473
 TAuthenticate.cxx:4474
 TAuthenticate.cxx:4475
 TAuthenticate.cxx:4476
 TAuthenticate.cxx:4477
 TAuthenticate.cxx:4478
 TAuthenticate.cxx:4479
 TAuthenticate.cxx:4480
 TAuthenticate.cxx:4481
 TAuthenticate.cxx:4482
 TAuthenticate.cxx:4483
 TAuthenticate.cxx:4484
 TAuthenticate.cxx:4485
 TAuthenticate.cxx:4486
 TAuthenticate.cxx:4487
 TAuthenticate.cxx:4488
 TAuthenticate.cxx:4489
 TAuthenticate.cxx:4490
 TAuthenticate.cxx:4491
 TAuthenticate.cxx:4492
 TAuthenticate.cxx:4493
 TAuthenticate.cxx:4494
 TAuthenticate.cxx:4495
 TAuthenticate.cxx:4496
 TAuthenticate.cxx:4497
 TAuthenticate.cxx:4498
 TAuthenticate.cxx:4499
 TAuthenticate.cxx:4500
 TAuthenticate.cxx:4501
 TAuthenticate.cxx:4502
 TAuthenticate.cxx:4503
 TAuthenticate.cxx:4504
 TAuthenticate.cxx:4505
 TAuthenticate.cxx:4506
 TAuthenticate.cxx:4507
 TAuthenticate.cxx:4508
 TAuthenticate.cxx:4509
 TAuthenticate.cxx:4510
 TAuthenticate.cxx:4511
 TAuthenticate.cxx:4512
 TAuthenticate.cxx:4513
 TAuthenticate.cxx:4514
 TAuthenticate.cxx:4515
 TAuthenticate.cxx:4516
 TAuthenticate.cxx:4517
 TAuthenticate.cxx:4518
 TAuthenticate.cxx:4519
 TAuthenticate.cxx:4520
 TAuthenticate.cxx:4521
 TAuthenticate.cxx:4522
 TAuthenticate.cxx:4523
 TAuthenticate.cxx:4524
 TAuthenticate.cxx:4525
 TAuthenticate.cxx:4526
 TAuthenticate.cxx:4527
 TAuthenticate.cxx:4528
 TAuthenticate.cxx:4529
 TAuthenticate.cxx:4530
 TAuthenticate.cxx:4531
 TAuthenticate.cxx:4532
 TAuthenticate.cxx:4533
 TAuthenticate.cxx:4534
 TAuthenticate.cxx:4535
 TAuthenticate.cxx:4536
 TAuthenticate.cxx:4537
 TAuthenticate.cxx:4538
 TAuthenticate.cxx:4539
 TAuthenticate.cxx:4540
 TAuthenticate.cxx:4541
 TAuthenticate.cxx:4542
 TAuthenticate.cxx:4543
 TAuthenticate.cxx:4544
 TAuthenticate.cxx:4545
 TAuthenticate.cxx:4546
 TAuthenticate.cxx:4547
 TAuthenticate.cxx:4548
 TAuthenticate.cxx:4549
 TAuthenticate.cxx:4550
 TAuthenticate.cxx:4551
 TAuthenticate.cxx:4552
 TAuthenticate.cxx:4553
 TAuthenticate.cxx:4554
 TAuthenticate.cxx:4555
 TAuthenticate.cxx:4556
 TAuthenticate.cxx:4557
 TAuthenticate.cxx:4558
 TAuthenticate.cxx:4559
 TAuthenticate.cxx:4560
 TAuthenticate.cxx:4561
 TAuthenticate.cxx:4562
 TAuthenticate.cxx:4563
 TAuthenticate.cxx:4564
 TAuthenticate.cxx:4565
 TAuthenticate.cxx:4566
 TAuthenticate.cxx:4567
 TAuthenticate.cxx:4568
 TAuthenticate.cxx:4569
 TAuthenticate.cxx:4570
 TAuthenticate.cxx:4571
 TAuthenticate.cxx:4572
 TAuthenticate.cxx:4573
 TAuthenticate.cxx:4574
 TAuthenticate.cxx:4575
 TAuthenticate.cxx:4576
 TAuthenticate.cxx:4577
 TAuthenticate.cxx:4578
 TAuthenticate.cxx:4579
 TAuthenticate.cxx:4580
 TAuthenticate.cxx:4581
 TAuthenticate.cxx:4582
 TAuthenticate.cxx:4583
 TAuthenticate.cxx:4584
 TAuthenticate.cxx:4585
 TAuthenticate.cxx:4586
 TAuthenticate.cxx:4587
 TAuthenticate.cxx:4588
 TAuthenticate.cxx:4589
 TAuthenticate.cxx:4590
 TAuthenticate.cxx:4591
 TAuthenticate.cxx:4592
 TAuthenticate.cxx:4593
 TAuthenticate.cxx:4594
 TAuthenticate.cxx:4595
 TAuthenticate.cxx:4596
 TAuthenticate.cxx:4597
 TAuthenticate.cxx:4598
 TAuthenticate.cxx:4599
 TAuthenticate.cxx:4600
 TAuthenticate.cxx:4601
 TAuthenticate.cxx:4602
 TAuthenticate.cxx:4603
 TAuthenticate.cxx:4604
 TAuthenticate.cxx:4605
 TAuthenticate.cxx:4606
 TAuthenticate.cxx:4607
 TAuthenticate.cxx:4608
 TAuthenticate.cxx:4609
 TAuthenticate.cxx:4610
 TAuthenticate.cxx:4611
 TAuthenticate.cxx:4612
 TAuthenticate.cxx:4613
 TAuthenticate.cxx:4614
 TAuthenticate.cxx:4615
 TAuthenticate.cxx:4616
 TAuthenticate.cxx:4617
 TAuthenticate.cxx:4618
 TAuthenticate.cxx:4619
 TAuthenticate.cxx:4620
 TAuthenticate.cxx:4621
 TAuthenticate.cxx:4622
 TAuthenticate.cxx:4623
 TAuthenticate.cxx:4624
 TAuthenticate.cxx:4625
 TAuthenticate.cxx:4626
 TAuthenticate.cxx:4627
 TAuthenticate.cxx:4628
 TAuthenticate.cxx:4629
 TAuthenticate.cxx:4630
 TAuthenticate.cxx:4631
 TAuthenticate.cxx:4632
 TAuthenticate.cxx:4633
 TAuthenticate.cxx:4634
 TAuthenticate.cxx:4635
 TAuthenticate.cxx:4636
 TAuthenticate.cxx:4637
 TAuthenticate.cxx:4638
 TAuthenticate.cxx:4639
 TAuthenticate.cxx:4640
 TAuthenticate.cxx:4641
 TAuthenticate.cxx:4642
 TAuthenticate.cxx:4643
 TAuthenticate.cxx:4644
 TAuthenticate.cxx:4645
 TAuthenticate.cxx:4646
 TAuthenticate.cxx:4647
 TAuthenticate.cxx:4648
 TAuthenticate.cxx:4649
 TAuthenticate.cxx:4650
 TAuthenticate.cxx:4651
 TAuthenticate.cxx:4652
 TAuthenticate.cxx:4653
 TAuthenticate.cxx:4654
 TAuthenticate.cxx:4655
 TAuthenticate.cxx:4656
 TAuthenticate.cxx:4657
 TAuthenticate.cxx:4658
 TAuthenticate.cxx:4659
 TAuthenticate.cxx:4660
 TAuthenticate.cxx:4661
 TAuthenticate.cxx:4662
 TAuthenticate.cxx:4663
 TAuthenticate.cxx:4664
 TAuthenticate.cxx:4665
 TAuthenticate.cxx:4666
 TAuthenticate.cxx:4667
 TAuthenticate.cxx:4668
 TAuthenticate.cxx:4669
 TAuthenticate.cxx:4670
 TAuthenticate.cxx:4671
 TAuthenticate.cxx:4672
 TAuthenticate.cxx:4673
 TAuthenticate.cxx:4674
 TAuthenticate.cxx:4675
 TAuthenticate.cxx:4676
 TAuthenticate.cxx:4677
 TAuthenticate.cxx:4678
 TAuthenticate.cxx:4679
 TAuthenticate.cxx:4680
 TAuthenticate.cxx:4681
 TAuthenticate.cxx:4682
 TAuthenticate.cxx:4683
 TAuthenticate.cxx:4684
 TAuthenticate.cxx:4685
 TAuthenticate.cxx:4686
 TAuthenticate.cxx:4687
 TAuthenticate.cxx:4688
 TAuthenticate.cxx:4689
 TAuthenticate.cxx:4690
 TAuthenticate.cxx:4691
 TAuthenticate.cxx:4692
 TAuthenticate.cxx:4693
 TAuthenticate.cxx:4694
 TAuthenticate.cxx:4695
 TAuthenticate.cxx:4696
 TAuthenticate.cxx:4697
 TAuthenticate.cxx:4698
 TAuthenticate.cxx:4699
 TAuthenticate.cxx:4700
 TAuthenticate.cxx:4701
 TAuthenticate.cxx:4702
 TAuthenticate.cxx:4703
 TAuthenticate.cxx:4704
 TAuthenticate.cxx:4705
 TAuthenticate.cxx:4706
 TAuthenticate.cxx:4707
 TAuthenticate.cxx:4708
 TAuthenticate.cxx:4709
 TAuthenticate.cxx:4710
 TAuthenticate.cxx:4711
 TAuthenticate.cxx:4712
 TAuthenticate.cxx:4713
 TAuthenticate.cxx:4714
 TAuthenticate.cxx:4715
 TAuthenticate.cxx:4716
 TAuthenticate.cxx:4717
 TAuthenticate.cxx:4718
 TAuthenticate.cxx:4719
 TAuthenticate.cxx:4720
 TAuthenticate.cxx:4721
 TAuthenticate.cxx:4722
 TAuthenticate.cxx:4723
 TAuthenticate.cxx:4724
 TAuthenticate.cxx:4725
 TAuthenticate.cxx:4726
 TAuthenticate.cxx:4727
 TAuthenticate.cxx:4728
 TAuthenticate.cxx:4729
 TAuthenticate.cxx:4730
 TAuthenticate.cxx:4731
 TAuthenticate.cxx:4732
 TAuthenticate.cxx:4733
 TAuthenticate.cxx:4734
 TAuthenticate.cxx:4735
 TAuthenticate.cxx:4736
 TAuthenticate.cxx:4737
 TAuthenticate.cxx:4738
 TAuthenticate.cxx:4739
 TAuthenticate.cxx:4740
 TAuthenticate.cxx:4741
 TAuthenticate.cxx:4742
 TAuthenticate.cxx:4743
 TAuthenticate.cxx:4744
 TAuthenticate.cxx:4745
 TAuthenticate.cxx:4746