Logo ROOT   6.21/01
Reference Guide
THostAuth.cxx
Go to the documentation of this file.
1 // @(#)root/auth:$Id$
2 // Author: G. Ganis 19/03/2003
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 //////////////////////////////////////////////////////////////////////////
13 // //
14 // THostAuth //
15 // //
16 // Contains details about host-specific authentication methods and the //
17 // result of their application. //
18 // Used by TAuthenticate. //
19 // //
20 //////////////////////////////////////////////////////////////////////////
21 
22 #include "RConfigure.h"
23 #include "TSystem.h"
24 #include "THostAuth.h"
25 #include "TRootSecContext.h"
26 #include "TAuthenticate.h"
27 #include "TSocket.h"
28 #include "TUrl.h"
29 #include <stdlib.h>
30 
31 
33 
34 ////////////////////////////////////////////////////////////////////////////////
35 /// Default constructor.
36 
38 {
39  Create(0, 0);
40 }
41 
42 ////////////////////////////////////////////////////////////////////////////////
43 /// Create hostauth object.
44 /// 'host' may contain also the server for whicb these directives
45 /// are valid in the form 'host:server' or 'server://host'
46 /// with server either "sock[d]", "root[d]", "proof[d]" or
47 /// 0, 1, 2, respectively.
48 
49 THostAuth::THostAuth(const char *host, const char *user, Int_t nmeth,
50  Int_t *authmeth, char **details) : TObject()
51 {
52  Create(host, user, nmeth, authmeth, details);
53 }
54 
55 ////////////////////////////////////////////////////////////////////////////////
56 /// Create hostauth object.
57 /// 'host' may contain also the server for whicb these directives
58 /// are valid in the form 'host:server' or 'server://host'
59 /// with server either "sock[d]", "root[d]", "proof[d]" or
60 /// 0, 1, 2, respectively.
61 
62 THostAuth::THostAuth(const char *host, Int_t server, const char *user,
63  Int_t nmeth, Int_t *authmeth, char **details) : TObject()
64 {
65  Create(host, user, nmeth, authmeth, details);
66 
67  fServer = server;
68 }
69 
70 ////////////////////////////////////////////////////////////////////////////////
71 /// Create hostauth object with one method only.
72 /// 'host' may contain also the server for whicb these directives
73 /// are valid in the form 'host:server' or 'server://host'
74 
75 THostAuth::THostAuth(const char *host, const char *user, Int_t authmeth,
76  const char *details) : TObject()
77 {
78  Create(host, user, 1, &authmeth, (char **)&details);
79 }
80 
81 ////////////////////////////////////////////////////////////////////////////////
82 /// Create hostauth object with one method only.
83 /// 'host' may contain also the server for whicb these directives
84 /// are valid in the form 'host:server' or 'server://host'
85 
86 THostAuth::THostAuth(const char *host, Int_t server, const char *user,
87  Int_t authmeth, const char *details) : TObject()
88 {
89  Create(host, user, 1, &authmeth, (char **)&details);
90  fServer = server;
91 }
92 
93 ////////////////////////////////////////////////////////////////////////////////
94 /// Create hostauth object.
95 /// 'host' may contain also the server for whicb these directives
96 /// are valid in the form 'host:server' or 'server://host'
97 /// with server either "sock[d]", "root[d]", "proof[d]" or
98 /// 0, 1, 2, respectively.
99 
100 void THostAuth::Create(const char *host, const char *user, Int_t nmeth,
101  Int_t *authmeth, char **details)
102 {
103  int i;
104 
105  // Host
106  fHost = host;
107 
108  fServer = -1;
109  // Extract server, if given
110  TString srv("");
111  if (fHost.Contains(":")) {
112  // .rootauthrc form: host:server
113  srv = fHost;
114  fHost.Remove(fHost.Index(":"));
115  srv.Remove(0,srv.Index(":")+1);
116  } else if (fHost.Contains("://")) {
117  // Url form: server://host
118  srv = TUrl(fHost).GetProtocol();
119  fHost.Remove(0,fHost.Index("://")+3);
120  }
121  if (srv.Length()) {
122  if (srv == "0" || srv.BeginsWith("sock"))
124  else if (srv == "1" || srv.BeginsWith("root"))
126  else if (srv == "2" || srv.BeginsWith("proof"))
128  }
129 
130  // Check and save the host FQDN ...
131  if (fHost != "default" && !fHost.Contains("*")) {
133  if (addr.IsValid())
134  fHost = addr.GetHostName();
135  }
136 
137  // User
138  fUser = user;
139  if (fUser == "")
140  fUser = gSystem->Getenv("USER");
141  if (fUser == "") {
143  if (u)
144  fUser = u->fUser;
145  delete u;
146  }
147 
148  // Methods indexes
149  fNumMethods = nmeth;
150  if (fNumMethods > 0) {
151  if (!authmeth)
152  fNumMethods = 0;
153  for (i = 0; i < kMAXSEC; i++) {
154  if (i < fNumMethods) {
155  fMethods[i] = authmeth[i];
156  fSuccess[i] = 0;
157  fFailure[i] = 0;
158  } else {
159  fMethods[i] = -1;
160  fSuccess[i] = -1;
161  fFailure[i] = -1;
162  }
163  }
164  }
165 
166  // Method details
167  if (fNumMethods > 0) {
168  for (i = 0; i < fNumMethods; i++) {
169  if (details && details[i] && strlen(details[i]) > 0) {
170  fDetails[i] = details[i];
171  } else {
172  // Use default instead
174  fDetails[i] = (const char *)tmp;
175  delete[] tmp;
176  }
177  }
178  }
179 
180  // List of TSecContext
181  fSecContexts = new TList;
182 
183  // Active when created
184  fActive = kTRUE;
185 }
186 
187 
188 ////////////////////////////////////////////////////////////////////////////////
189 /// Create hostauth object from directives given as a compact string
190 /// See THostAuth::AsString().
191 /// Used in proof context only; fServer not set; to be set by hand
192 /// with SetServer() method if really needed
193 
194 THostAuth::THostAuth(const char *asstring) : TObject()
195 {
196  fServer = -1;
197 
198  TString strtmp(asstring);
199  char *tmp = strdup(asstring);
200 
201  fHost = TString((const char *)strtok(tmp," "));
202  strtmp.ReplaceAll(fHost,"");
203  fHost.Remove(0,fHost.Index(":")+1);
204 
205  fUser = TString((const char *)strtok(0," "));
206  strtmp.ReplaceAll(fUser,"");
207  fUser.Remove(0,fUser.Index(":")+1);
208 
209  TString fNmet;
210  fNmet = TString((const char *)strtok(0," "));
211  strtmp.ReplaceAll(fNmet,"");
212  fNmet.Remove(0,fNmet.Index(":")+1);
213 
214  free(tmp);
215 
216  fNumMethods = atoi(fNmet.Data());
217  Int_t i = 0;
218  for (; i < fNumMethods; i++) {
219  TString det = strtmp;
220  det.Remove(0,det.Index("'")+1);
221  det.Resize(det.Index("'"));
222  // Remove leading spaces, if
223  char cmet[20];
224  sscanf(det.Data(),"%10s",cmet);
225  Int_t met = atoi(cmet);
226  if (met > -1 && met < kMAXSEC) {
227  det.ReplaceAll(cmet,"");
228  while (det.First(' ') == 0)
229  det.Remove(0,1);
230  while (det.Last(' ') == (det.Length() - 1))
231  det.Resize(det.Length() - 1);
232  fMethods[i] = met;
233  fSuccess[i] = 0;
234  fFailure[i] = 0;
235  fDetails[i] = det;
236  }
237  strtmp.Remove(0,strtmp.Index("'",strtmp.Index("'")+1)+1);
238  }
239  for (i = fNumMethods; i < kMAXSEC ; i++) {
240  fMethods[i] = -1;
241  fSuccess[i] = -1;
242  fFailure[i] = -1;
243  }
244 
245  // List of TSecContext
246  fSecContexts = new TList;
247 
248  // Active when created
249  fActive = kTRUE;
250 }
251 
252 
253 ////////////////////////////////////////////////////////////////////////////////
254 /// Copy ctor ...
255 
257 {
258  fHost = ha.fHost;
259  fServer = ha.fServer;
260  fUser = ha.fUser;
262  Int_t i = 0;
263  for (; i < kMAXSEC; i++) {
264  fMethods[i] = ha.fMethods[i];
265  fSuccess[i] = ha.fSuccess[i];
266  fFailure[i] = ha.fFailure[i];
267  fDetails[i] = ha.fDetails[i];
268  }
269  fSecContexts = ha.Established();
270  fActive = ha.fActive;
271 }
272 
273 ////////////////////////////////////////////////////////////////////////////////
274 /// Add method to the list. If already there, change its
275 /// details to 'details'
276 
277 void THostAuth::AddMethod(Int_t meth, const char *details)
278 {
279  // Check 'meth'
280  if (meth < 0 || meth >= kMAXSEC) return;
281 
282  // If already there, set details and return
283  if (HasMethod(meth)) {
284  SetDetails(meth,details);
285  return;
286  }
287 
288  // This is a new method
289  fMethods[fNumMethods] = meth;
290  fSuccess[fNumMethods] = 0;
291  fFailure[fNumMethods] = 0;
292  if (details && strlen(details) > 0) {
293  fDetails[fNumMethods] = details;
294  } else {
295  // Use default instead
296  char *tmp = TAuthenticate::GetDefaultDetails(meth,0,fUser);
297  fDetails[fNumMethods] = (const char *)tmp;
298  delete[] tmp;
299  }
300 
301  // Increment total number
302  fNumMethods++;
303 
304  if (gDebug > 3) Print();
305 }
306 
307 ////////////////////////////////////////////////////////////////////////////////
308 /// Remove method 'meth' from the list, if there ...
309 
311 {
312  // If we don't have it, nothing to do
313  Int_t pos = -1;
314  if (!HasMethod(meth,&pos)) return;
315 
316  // Now rescale info
317  Int_t i = 0, k = 0;
318  for (; i < fNumMethods; i++) {
319  if (i != pos) {
320  fMethods[k] = fMethods[i];
321  fSuccess[k] = fSuccess[i];
322  fFailure[k] = fFailure[i];
323  fDetails[k] = fDetails[i];
324  k++;
325  }
326  }
327 
328  // Decrement total number
329  fNumMethods--;
330 
331  // Free last position
332  fMethods[fNumMethods] = -1;
333  fSuccess[fNumMethods] = -1;
334  fFailure[fNumMethods] = -1;
336 
337  if (gDebug > 3) Print();
338 }
339 
340 ////////////////////////////////////////////////////////////////////////////////
341 /// Remove all methods, leaving Active status and
342 /// list of associted TSceContexts unchanged
343 
345 {
346  // Free all filled positions
347  Int_t i = 0;
348  for (; i < fNumMethods; i++) {
349  fMethods[i] = -1;
350  fSuccess[i] = -1;
351  fFailure[i] = -1;
352  fDetails[i].Resize(0);
353  }
354 
355  // Set total number to 0
356  fNumMethods = 0;
357 }
358 
359 ////////////////////////////////////////////////////////////////////////////////
360 /// The dtor.
361 
363 {
364  delete fSecContexts;
365 }
366 
367 ////////////////////////////////////////////////////////////////////////////////
368 /// Return authentication details for specified level
369 /// or "" if the specified level does not exist for this host.
370 
371 const char *THostAuth::GetDetails(Int_t level)
372 {
373  Int_t i = -1;
374  if (HasMethod(level,&i)) {
375  if (gDebug > 3)
376  Info("GetDetails"," %d: returning fDetails[%d]: %s",
377  level,i,fDetails[i].Data());
378  return fDetails[i];
379  }
380  static const char *empty = " ";
381  return empty;
382 }
383 
384 ////////////////////////////////////////////////////////////////////////////////
385 /// Return kTRUE if method 'level' is in the list
386 
388 {
389  int i;
390  for (i = 0; i < fNumMethods; i++) {
391  if (fMethods[i] == level) {
392  if (pos) *pos = i;
393  return kTRUE;
394  }
395  }
396  if (pos) *pos = -1;
397  return kFALSE;
398 }
399 
400 ////////////////////////////////////////////////////////////////////////////////
401 /// Set authentication details for specified level.
402 
403 void THostAuth::SetDetails(Int_t level, const char *details)
404 {
405  Int_t i = -1;
406  if (HasMethod(level,&i)) {
407  if (details && strlen(details) > 0) {
408  fDetails[i] = details;
409  } else {
410  // Use default instead
411  char *tmp = TAuthenticate::GetDefaultDetails(level,0,fUser);
412  fDetails[i] = (const char *)tmp;
413  delete[] tmp;
414  }
415  } else {
416  // Add new method ...
417  AddMethod(level, details);
418  }
419 }
420 
421 ////////////////////////////////////////////////////////////////////////////////
422 /// Print object content.
423 
424 void THostAuth::Print(Option_t *proc) const
425 {
426  char srvnam[5][8] = { "any", "sockd", "rootd", "proofd", "???" };
427 
428  Int_t isrv = (fServer >= -1 && fServer <= TSocket::kPROOFD) ?
430 
431  Info("Print",
432  "%s +------------------------------------------------------------------+",proc);
433  Info("Print","%s + Host:%s - srv:%s - User:%s - # of available methods:%d",
434  proc, fHost.Data(), srvnam[isrv], fUser.Data(), fNumMethods);
435  int i = 0;
436  for (i = 0; i < fNumMethods; i++){
437  Info("Print","%s + Method: %d (%s) Ok:%d Ko:%d Dets:%s", proc,
439  fSuccess[i], fFailure[i], fDetails[i].Data());
440  }
441  Info("Print",
442  "%s +------------------------------------------------------------------+",proc);
443 }
444 
445 ////////////////////////////////////////////////////////////////////////////////
446 /// Print info about established authentication vis-a-vis of this Host.
447 
449 {
450  Info("PrintEstablished",
451  "+------------------------------------------------------------------------------+");
452  Info("PrintEstablished","+ Host:%s - Number of active sec contexts: %d",
454 
455  // Check list
456  if (fSecContexts->GetSize()>0) {
457  TIter next(fSecContexts);
458  TSecContext *ctx = 0;
459  Int_t k = 1;
460  while ((ctx = (TSecContext *) next())) {
461  TString opt;
462  opt += k++;
463  ctx->Print(opt);
464  }
465  }
466  Info("PrintEstablished",
467  "+------------------------------------------------------------------------------+");
468 }
469 
470 ////////////////////////////////////////////////////////////////////////////////
471 /// Reorder nmet methods according fmet[nmet]
472 
473 void THostAuth::ReOrder(Int_t nmet, Int_t *fmet)
474 {
475  // Temporary arrays
476  Int_t tMethods[kMAXSEC] = {0};
477  Int_t tSuccess[kMAXSEC] = {0};
478  Int_t tFailure[kMAXSEC] = {0};
479  TString tDetails[kMAXSEC];
480  Int_t flag[kMAXSEC] = {0};
481 
482  // Copy info in the new order
483  Int_t j = 0;
484  for ( ; j < nmet; j++) {
485  Int_t i = -1;
486  if (HasMethod(fmet[j],&i)) {
487  tMethods[j] = fMethods[i];
488  tSuccess[j] = fSuccess[i];
489  tFailure[j] = fFailure[i];
490  tDetails[j] = fDetails[i];
491  flag[i]++;
492  } else if (fmet[j] >= 0 && fmet[j] < kMAXSEC) {
493  tMethods[j] = fmet[j];
494  tSuccess[j] = 0;
495  tFailure[j] = 0;
496  char *tmp = TAuthenticate::GetDefaultDetails(fmet[j],0,fUser);
497  tDetails[j] = (const char *)tmp;
498  delete[] tmp;
499  } else {
500  Warning("ReOrder","Method id out of range (%d) - skipping",fmet[j]);
501  }
502  }
503 
504  // Add existing methods not listed ... if any
505  Int_t k = nmet, i = 0;
506  for(; i < fNumMethods; i++){
507  if (flag[i] == 0) {
508  tMethods[k] = fMethods[i];
509  tSuccess[k] = fSuccess[i];
510  tFailure[k] = fFailure[i];
511  tDetails[k] = fDetails[i];
512  k++;
513  flag[i] = 1;
514  }
515  }
516 
517  // Restore from temporary
518  fNumMethods = k;
519  for (i = 0; i < fNumMethods; i++) {
520  fMethods[i] = tMethods[i];
521  fSuccess[i] = tSuccess[i];
522  fFailure[i] = tFailure[i];
523  fDetails[i] = tDetails[i];
524  }
525 
526  if (gDebug > 3) Print();
527 }
528 
529 ////////////////////////////////////////////////////////////////////////////////
530 /// Update info with the one in ha
531 /// Remaining methods, if any, get lower priority
532 
534 {
535  // Temporary arrays
536  Int_t tNumMethods = fNumMethods;
537  Int_t tMethods[kMAXSEC];
538  Int_t tSuccess[kMAXSEC];
539  Int_t tFailure[kMAXSEC];
540  TString tDetails[kMAXSEC];
541 
542  // Save existing info in temporary arrays
543  Int_t i = 0;
544  for ( ; i < fNumMethods; i++) {
545  tMethods[i] = fMethods[i];
546  tSuccess[i] = fSuccess[i];
547  tFailure[i] = fFailure[i];
548  tDetails[i] = fDetails[i];
549  }
550 
551  // Reset
552  Reset();
553 
554  // Get ha content in
555  for(i = 0; i < ha->NumMethods(); i++){
556  fMethods[i] = ha->GetMethod(i);
557  fSuccess[i] = ha->GetSuccess(i);
558  fFailure[i] = ha->GetFailure(i);
559  fDetails[i] = ha->GetDetailsByIdx(i);
560  }
561 
562  // Set new tmp size
563  fNumMethods = ha->NumMethods();
564 
565  // Add remaining methods with low priority
566  if (fNumMethods < kMAXSEC) {
567  for (i = 0; i < tNumMethods; i++) {
568  if (!HasMethod(tMethods[i]) && fNumMethods < kMAXSEC) {
569  fMethods[fNumMethods] = tMethods[i];
570  fSuccess[fNumMethods] = tSuccess[i];
571  fFailure[fNumMethods] = tFailure[i];
572  fDetails[fNumMethods] = tDetails[i];
573  fNumMethods++;
574  }
575  }
576  }
577  if (gDebug > 3) Print();
578 }
579 
580 ////////////////////////////////////////////////////////////////////////////////
581 /// Set 'method' to be the first used (if in the list ...).
582 
584 {
585  Int_t i = -1;
586  if (HasMethod(method,&i)) {
587 
588  Int_t tMe = fMethods[i];
589  Int_t tSu = fSuccess[i];
590  Int_t tFa = fFailure[i];
591  TString tDe = fDetails[i];
592 
593  // Rescale methods
594  Int_t j = i;
595  for (; j > 0; j--) {
596  fMethods[j] = fMethods[j-1];
597  fSuccess[j] = fSuccess[j-1];
598  fFailure[j] = fFailure[j-1];
599  fDetails[j] = fDetails[j-1];
600  }
601 
602  // The saved method first
603  fMethods[0] = tMe;
604  fSuccess[0] = tSu;
605  fFailure[0] = tFa;
606  fDetails[0] = tDe;
607  }
608 
609  if (gDebug > 3) Print();
610 }
611 
612 ////////////////////////////////////////////////////////////////////////////////
613 /// Set 'method' to be the last used (if in the list ...).
614 
616 {
617  Int_t i = -1;
618  if (HasMethod(method,&i)) {
619 
620  Int_t tMe = fMethods[i];
621  Int_t tSu = fSuccess[i];
622  Int_t tFa = fFailure[i];
623  TString tDe = fDetails[i];
624 
625  // Rescale methods
626  Int_t j = i;
627  for (; j < (fNumMethods - 1); j++) {
628  fMethods[j] = fMethods[j+1];
629  fSuccess[j] = fSuccess[j+1];
630  fFailure[j] = fFailure[j+1];
631  fDetails[j] = fDetails[j+1];
632  }
633 
634  // The saved method first
635  Int_t lp = fNumMethods - 1;
636  fMethods[lp] = tMe;
637  fSuccess[lp] = tSu;
638  fFailure[lp] = tFa;
639  fDetails[lp] = tDe;
640  }
641 
642  if (gDebug > 3) Print();
643 }
644 
645 ////////////////////////////////////////////////////////////////////////////////
646 /// Add new method in first position
647 /// If already in the list, set as first method 'level' with
648 /// authentication 'details'.
649 /// Faster then AddMethod(method,details)+SetFirst(method).
650 
651 void THostAuth::AddFirst(Int_t level, const char *details)
652 {
653  Int_t i = -1;
654  if (HasMethod(level,&i)) {
655  if (i > 0) {
656  SetDetails(level, details);
657  SetFirst(level);
658  }
659  if (gDebug > 3) Print();
660  return;
661  }
662 
663  // Rescale methods
664  for (i = fNumMethods; i > 0; i--) {
665  fMethods[i] = fMethods[i-1];
666  fSuccess[i] = fSuccess[i-1];
667  fFailure[i] = fFailure[i-1];
668  fDetails[i] = fDetails[i-1];
669  }
670 
671  // This method first
672  fMethods[0] = level;
673  fSuccess[0] = 0;
674  fFailure[0] = 0;
675  if (details && strlen(details) > 0) {
676  fDetails[0] = details;
677  } else {
678  // Use default instead
679  char *tmp = TAuthenticate::GetDefaultDetails(level,0,fUser);
680  fDetails[0] = (const char *)tmp;
681  delete[] tmp;
682  }
683 
684  // Increment total number
685  fNumMethods++;
686 
687  if (gDebug > 3) Print();
688 }
689 
690 
691 ////////////////////////////////////////////////////////////////////////////////
692 /// Count successes for 'method'
693 
695 {
696  int i;
697  for (i = 0; i < fNumMethods; i++) {
698  if (fMethods[i] == method) {
699  fSuccess[i]++;
700  break;
701  }
702  }
703 }
704 
705 ////////////////////////////////////////////////////////////////////////////////
706 /// Count failures for 'method'
707 
709 {
710  int i;
711  for (i = 0; i < fNumMethods; i++) {
712  if (fMethods[i] == method) {
713  fFailure[i]++;
714  break;
715  }
716  }
717 }
718 
719 ////////////////////////////////////////////////////////////////////////////////
720 /// Create a Security context and add it to local list
721 /// Return pointer to it to be stored in TAuthenticate
722 
723 TRootSecContext *THostAuth::CreateSecContext(const char *user, const char *host,
724  Int_t meth, Int_t offset,
725  const char *details, const char *token,
726  TDatime expdate, void *sctx, Int_t key)
727 {
728  TRootSecContext *ctx = new TRootSecContext(user, host, meth, offset, details,
729  token, expdate, sctx, key);
730  // Add it also to the local list if active
731  if (ctx->IsActive())
732  fSecContexts->Add(ctx);
733 
734  return ctx;
735 
736 }
737 
738 ////////////////////////////////////////////////////////////////////////////////
739 /// Return a static string with all info in a serialized form
740 
741 void THostAuth::AsString(TString &Out) const
742 {
743  Out = Form("h:%s u:%s n:%d",GetHost(),GetUser(),fNumMethods);
744 
745  Int_t i = 0;
746  for (; i < fNumMethods; i++) {
747  Out += TString(Form(" '%d %s'",fMethods[i],fDetails[i].Data()));
748  }
749 
750 }
void SetDetails(Int_t level, const char *details)
Set authentication details for specified level.
Definition: THostAuth.cxx:403
TString fDetails[kMAXSEC]
Definition: THostAuth.h:42
void AsString(TString &out) const
Return a static string with all info in a serialized form.
Definition: THostAuth.cxx:741
THostAuth()
Default constructor.
Definition: THostAuth.cxx:37
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:854
void PrintEstablished() const
Print info about established authentication vis-a-vis of this Host.
Definition: THostAuth.cxx:448
const char Option_t
Definition: RtypesCore.h:62
Bool_t fActive
Definition: THostAuth.h:45
virtual void Print(Option_t *option="F") const
If opt is "F" (default) print object content.
const char * GetHostName() const
Definition: TInetAddress.h:71
This class represents a WWW compatible URL.
Definition: TUrl.h:35
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:687
const char * GetProtocol() const
Definition: TUrl.h:66
This class represents an Internet Protocol (IP) address.
Definition: TInetAddress.h:36
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:634
const char * GetDetails(Int_t level)
Return authentication details for specified level or "" if the specified level does not exist for thi...
Definition: THostAuth.cxx:371
Int_t fMethods[kMAXSEC]
Definition: THostAuth.h:41
Basic string class.
Definition: TString.h:131
const Int_t kMAXSEC
Definition: AuthConst.h:26
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
static char * GetDefaultDetails(Int_t method, Int_t opt, const char *user)
Determine default authentication details for method &#39;sec&#39; and user &#39;usr&#39;.
void CountFailure(Int_t level)
Count failures for &#39;method&#39;.
Definition: THostAuth.cxx:708
Bool_t HasMethod(Int_t level, Int_t *pos=0)
Return kTRUE if method &#39;level&#39; is in the list.
Definition: THostAuth.cxx:387
const char * GetUser() const
Definition: THostAuth.h:94
Int_t GetSuccess(Int_t idx) const
Definition: THostAuth.h:82
Int_t fSuccess[kMAXSEC]
Definition: THostAuth.h:43
void CountSuccess(Int_t level)
Count successes for &#39;method&#39;.
Definition: THostAuth.cxx:694
Bool_t IsActive() const
Check remote OffSet and expiring Date.
void Create(const char *host, const char *user, Int_t nmeth=0, Int_t *authmeth=0, char **details=0)
Create hostauth object.
Definition: THostAuth.cxx:100
Int_t NumMethods() const
Definition: THostAuth.h:69
TList * Established() const
Definition: THostAuth.h:100
virtual const char * Getenv(const char *env)
Get environment variable.
Definition: TSystem.cxx:1646
virtual UserGroup_t * GetUserInfo(Int_t uid)
Returns all user info in the UserGroup_t structure.
Definition: TSystem.cxx:1582
Ssiz_t First(char c) const
Find first occurrence of a character c.
Definition: TString.cxx:499
virtual TInetAddress GetHostByName(const char *server)
Get Internet Protocol (IP) address of host.
Definition: TSystem.cxx:2328
A doubly linked list.
Definition: TList.h:44
TString fHost
Definition: THostAuth.h:37
void RemoveMethod(Int_t level)
Remove method &#39;meth&#39; from the list, if there ...
Definition: THostAuth.cxx:310
Int_t GetFailure(Int_t idx) const
Definition: THostAuth.h:81
TString fUser
Definition: TSystem.h:141
R__EXTERN TSystem * gSystem
Definition: TSystem.h:557
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition: TString.h:610
char * Form(const char *fmt,...)
Ssiz_t Length() const
Definition: TString.h:405
void AddMethod(Int_t level, const char *details=0)
Add method to the list.
Definition: THostAuth.cxx:277
const Bool_t kFALSE
Definition: RtypesCore.h:88
Int_t fNumMethods
Definition: THostAuth.h:40
TString & Remove(Ssiz_t pos)
Definition: TString.h:668
TRootSecContext * CreateSecContext(const char *user, const char *host, Int_t meth, Int_t offset, const char *details, const char *token, TDatime expdate=kROOTTZERO, void *ctx=0, Int_t key=-1)
Create a Security context and add it to local list Return pointer to it to be stored in TAuthenticate...
Definition: THostAuth.cxx:723
#define ClassImp(name)
Definition: Rtypes.h:365
Ssiz_t Last(char c) const
Find last occurrence of a character c.
Definition: TString.cxx:892
const char * GetHost() const
Definition: THostAuth.h:92
#define free
Definition: civetweb.c:1539
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:619
Int_t GetMethod(Int_t idx) const
Definition: THostAuth.h:70
Int_t fFailure[kMAXSEC]
Definition: THostAuth.h:44
void ReOrder(Int_t nmet, Int_t *fmet)
Reorder nmet methods according fmet[nmet].
Definition: THostAuth.cxx:473
TList * fSecContexts
Definition: THostAuth.h:47
Mother of all ROOT objects.
Definition: TObject.h:37
Bool_t IsValid() const
Definition: TInetAddress.h:76
virtual ~THostAuth()
The dtor.
Definition: THostAuth.cxx:362
void SetFirst(Int_t level)
Set &#39;method&#39; to be the first used (if in the list ...).
Definition: THostAuth.cxx:583
virtual void Add(TObject *obj)
Definition: TList.h:87
void Update(THostAuth *ha)
Update info with the one in ha Remaining methods, if any, get lower priority.
Definition: THostAuth.cxx:533
const char * GetDetailsByIdx(Int_t idx) const
Definition: THostAuth.h:89
R__EXTERN Int_t gDebug
Definition: Rtypes.h:91
void SetLast(Int_t level)
Set &#39;method&#39; to be the last used (if in the list ...).
Definition: THostAuth.cxx:615
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
void AddFirst(Int_t level, const char *details=0)
Add new method in first position If already in the list, set as first method &#39;level&#39; with authenticat...
Definition: THostAuth.cxx:651
virtual void Print(Option_t *option="") const
Print object content.
Definition: THostAuth.cxx:424
const Bool_t kTRUE
Definition: RtypesCore.h:87
TString fUser
Definition: THostAuth.h:39
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:866
Char_t fServer
Definition: THostAuth.h:38
void Resize(Ssiz_t n)
Resize the string. Truncate or add blanks as necessary.
Definition: TString.cxx:1095
This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130...
Definition: TDatime.h:37
const char * Data() const
Definition: TString.h:364
static const char * GetAuthMethod(Int_t idx)
Static method returning the method corresponding to idx.
void Reset()
Remove all methods, leaving Active status and list of associted TSceContexts unchanged.
Definition: THostAuth.cxx:344