apt-pkg/contrib/error.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: error.cc,v 1.11 2002/03/26 07:38:58 jgg Exp $
   4 /* ######################################################################
   5
   6    Global Erorr Class - Global error mechanism
   7
   8    We use a simple STL vector to store each error record. A PendingFlag
   9    is kept which indicates when the vector contains a Sever error.
  10
  11    This source is placed in the Public Domain, do with it what you will
  12    It was originally written by Jason Gunthorpe.
  13
  14    ##################################################################### */
  15                                                                         /*}}}*/
  16 // Include Files                                                        /*{{{*/
  17 #include <apt-pkg/error.h>
  18
  19 #include <iostream>
  20 #include <errno.h>
  21 #include <stdio.h>
  22 #include <string>
  23 #include <stdarg.h>
  24 #include <unistd.h>
  25
  26 #include "config.h"
  27                                                                         /*}}}*/
  28
  29 using namespace std;
  30
  31 // Global Error Object                                                  /*{{{*/
  32 /* If the implementation supports posix threads then the accessor function
  33    is compiled to be thread safe otherwise a non-safe version is used. A
  34    Per-Thread error object is maintained in much the same manner as libc
  35    manages errno */
  36 #if defined(_POSIX_THREADS) && defined(HAVE_PTHREAD)
  37  #include <pthread.h>
  38
  39  static pthread_key_t ErrorKey;
  40  static void ErrorDestroy(void *Obj) {delete (GlobalError *)Obj;};
  41  static void KeyAlloc() {pthread_key_create(&ErrorKey,ErrorDestroy);};
  42
  43  GlobalError *_GetErrorObj()
  44  {
  45     static pthread_once_t Once = PTHREAD_ONCE_INIT;
  46     pthread_once(&Once,KeyAlloc);
  47
  48     void *Res = pthread_getspecific(ErrorKey);
  49     if (Res == 0)
  50        pthread_setspecific(ErrorKey,Res = new GlobalError);
  51     return (GlobalError *)Res;
  52  }
  53 #else
  54  GlobalError *_GetErrorObj()
  55  {
  56     static GlobalError *Obj = new GlobalError;
  57     return Obj;
  58  }
  59 #endif
  60                                                                         /*}}}*/
  61
  62 // GlobalError::GlobalError - Constructor                               /*{{{*/
  63 // ---------------------------------------------------------------------
  64 /* */
  65 GlobalError::GlobalError() : List(0), PendingFlag(false)
  66 {
  67 }
  68                                                                         /*}}}*/
  69 // GlobalError::Errno - Get part of the error string from errno         /*{{{*/
  70 // ---------------------------------------------------------------------
  71 /* Function indicates the stdlib function that failed and Description is
  72    a user string that leads the text. Form is:
  73      Description - Function (errno: strerror)
  74    Carefull of the buffer overrun, sprintf.
  75  */
  76 bool GlobalError::Errno(const char *Function,const char *Description,...)
  77 {
  78    va_list args;
  79    va_start(args,Description);
  80
  81    // sprintf the description
  82    char S[400];
  83    vsnprintf(S,sizeof(S),Description,args);
  84    snprintf(S + strlen(S),sizeof(S) - strlen(S),
  85             " - %s (%i %s)",Function,errno,strerror(errno));
  86
  87    // Put it on the list
  88    Item *Itm = new Item;
  89    Itm->Text = S;
  90    Itm->Error = true;
  91    Insert(Itm);
  92
  93    PendingFlag = true;
  94
  95    return false;
  96 }
  97                                                                         /*}}}*/
  98 // GlobalError::WarningE - Get part of the warn string from errno       /*{{{*/
  99 // ---------------------------------------------------------------------
 100 /* Function indicates the stdlib function that failed and Description is
 101    a user string that leads the text. Form is:
 102      Description - Function (errno: strerror)
 103    Carefull of the buffer overrun, sprintf.
 104  */
 105 bool GlobalError::WarningE(const char *Function,const char *Description,...)
 106 {
 107    va_list args;
 108    va_start(args,Description);
 109
 110    // sprintf the description
 111    char S[400];
 112    vsnprintf(S,sizeof(S),Description,args);
 113    snprintf(S + strlen(S),sizeof(S) - strlen(S)," - %s (%i %s)",Function,errno,strerror(errno));
 114
 115    // Put it on the list
 116    Item *Itm = new Item;
 117    Itm->Text = S;
 118    Itm->Error = false;
 119    Insert(Itm);
 120
 121    return false;
 122 }
 123                                                                         /*}}}*/
 124 // GlobalError::Error - Add an error to the list                        /*{{{*/
 125 // ---------------------------------------------------------------------
 126 /* Just vsprintfs and pushes */
 127 bool GlobalError::Error(const char *Description,...)
 128 {
 129    va_list args;
 130    va_start(args,Description);
 131
 132    // sprintf the description
 133    char S[400];
 134    vsnprintf(S,sizeof(S),Description,args);
 135
 136    // Put it on the list
 137    Item *Itm = new Item;
 138    Itm->Text = S;
 139    Itm->Error = true;
 140    Insert(Itm);
 141
 142    PendingFlag = true;
 143
 144    return false;
 145 }
 146                                                                         /*}}}*/
 147 // GlobalError::Warning - Add a warning to the list                     /*{{{*/
 148 // ---------------------------------------------------------------------
 149 /* This doesn't set the pending error flag */
 150 bool GlobalError::Warning(const char *Description,...)
 151 {
 152    va_list args;
 153    va_start(args,Description);
 154
 155    // sprintf the description
 156    char S[400];
 157    vsnprintf(S,sizeof(S),Description,args);
 158
 159    // Put it on the list
 160    Item *Itm = new Item;
 161    Itm->Text = S;
 162    Itm->Error = false;
 163    Insert(Itm);
 164
 165    return false;
 166 }
 167                                                                         /*}}}*/
 168 // GlobalError::PopMessage - Pulls a single message out                 /*{{{*/
 169 // ---------------------------------------------------------------------
 170 /* This should be used in a loop checking empty() each cycle. It returns
 171    true if the message is an error. */
 172 bool GlobalError::PopMessage(string &Text)
 173 {
 174    if (List == 0)
 175       return false;
 176
 177    bool Ret = List->Error;
 178    Text = List->Text;
 179    Item *Old = List;
 180    List = List->Next;
 181    delete Old;
 182
 183    // This really should check the list to see if only warnings are left..
 184    if (List == 0)
 185       PendingFlag = false;
 186
 187    return Ret;
 188 }
 189                                                                         /*}}}*/
 190 // GlobalError::DumpErrors - Dump all of the errors/warns to cerr       /*{{{*/
 191 // ---------------------------------------------------------------------
 192 /* */
 193 void GlobalError::DumpErrors()
 194 {
 195    // Print any errors or warnings found
 196    string Err;
 197    while (empty() == false)
 198    {
 199       bool Type = PopMessage(Err);
 200       if (Type == true)
 201          cerr << "E: " << Err << endl;
 202       else
 203          cerr << "W: " << Err << endl;
 204    }
 205 }
 206                                                                         /*}}}*/
 207 // GlobalError::Discard - Discard                                                                       /*{{{*/
 208 // ---------------------------------------------------------------------
 209 /* */
 210 void GlobalError::Discard()
 211 {
 212    while (List != 0)
 213    {
 214       Item *Old = List;
 215       List = List->Next;
 216       delete Old;
 217    }
 218
 219    PendingFlag = false;
 220 };
 221                                                                         /*}}}*/
 222 // GlobalError::Insert - Insert a new item at the end                   /*{{{*/
 223 // ---------------------------------------------------------------------
 224 /* */
 225 void GlobalError::Insert(Item *Itm)
 226 {
 227    Item **End = &List;
 228    for (Item *I = List; I != 0; I = I->Next)
 229       End = &I->Next;
 230    Itm->Next = *End;
 231    *End = Itm;
 232 }
 233                                                                         /*}}}*/