]>
Commit | Line | Data |
---|---|---|
1 | // -*- mode: cpp; mode: fold -*- | |
2 | // Description /*{{{*/ | |
3 | /* ###################################################################### | |
4 | ||
5 | Global Error Class - Global error mechanism | |
6 | ||
7 | We use a simple STL vector to store each error record. A PendingFlag | |
8 | is kept which indicates when the vector contains a Sever error. | |
9 | ||
10 | This source is placed in the Public Domain, do with it what you will | |
11 | It was originally written by Jason Gunthorpe. | |
12 | ||
13 | ##################################################################### */ | |
14 | /*}}}*/ | |
15 | // Include Files /*{{{*/ | |
16 | #include <apt-pkg/error.h> | |
17 | ||
18 | #include <iostream> | |
19 | #include <errno.h> | |
20 | #include <stdio.h> | |
21 | #include <unistd.h> | |
22 | ||
23 | #include <string> | |
24 | #include <cstring> | |
25 | ||
26 | #include "config.h" | |
27 | /*}}}*/ | |
28 | ||
29 | // Global Error Object /*{{{*/ | |
30 | /* If the implementation supports posix threads then the accessor function | |
31 | is compiled to be thread safe otherwise a non-safe version is used. A | |
32 | Per-Thread error object is maintained in much the same manner as libc | |
33 | manages errno */ | |
34 | #if defined(_POSIX_THREADS) && defined(HAVE_PTHREAD) | |
35 | #include <pthread.h> | |
36 | ||
37 | static pthread_key_t ErrorKey; | |
38 | static void ErrorDestroy(void *Obj) {delete (GlobalError *)Obj;}; | |
39 | static void KeyAlloc() {pthread_key_create(&ErrorKey,ErrorDestroy);}; | |
40 | ||
41 | GlobalError *_GetErrorObj() { | |
42 | static pthread_once_t Once = PTHREAD_ONCE_INIT; | |
43 | pthread_once(&Once,KeyAlloc); | |
44 | ||
45 | void *Res = pthread_getspecific(ErrorKey); | |
46 | if (Res == 0) | |
47 | pthread_setspecific(ErrorKey,Res = new GlobalError); | |
48 | return (GlobalError *)Res; | |
49 | } | |
50 | #else | |
51 | GlobalError *_GetErrorObj() { | |
52 | static GlobalError *Obj = new GlobalError; | |
53 | return Obj; | |
54 | } | |
55 | #endif | |
56 | /*}}}*/ | |
57 | // GlobalError::GlobalError - Constructor /*{{{*/ | |
58 | GlobalError::GlobalError() : PendingFlag(false) {} | |
59 | /*}}}*/ | |
60 | // GlobalError::FatalE - Get part of the error string from errno /*{{{*/ | |
61 | bool GlobalError::FatalE(const char *Function,const char *Description,...) { | |
62 | va_list args; | |
63 | va_start(args,Description); | |
64 | return InsertErrno(FATAL, Function, Description, args); | |
65 | } | |
66 | /*}}}*/ | |
67 | // GlobalError::Errno - Get part of the error string from errno /*{{{*/ | |
68 | bool GlobalError::Errno(const char *Function,const char *Description,...) { | |
69 | va_list args; | |
70 | va_start(args,Description); | |
71 | return InsertErrno(ERROR, Function, Description, args); | |
72 | } | |
73 | /*}}}*/ | |
74 | // GlobalError::WarningE - Get part of the warning string from errno /*{{{*/ | |
75 | bool GlobalError::WarningE(const char *Function,const char *Description,...) { | |
76 | va_list args; | |
77 | va_start(args,Description); | |
78 | return InsertErrno(WARNING, Function, Description, args); | |
79 | } | |
80 | /*}}}*/ | |
81 | // GlobalError::NoticeE - Get part of the notice string from errno /*{{{*/ | |
82 | bool GlobalError::NoticeE(const char *Function,const char *Description,...) { | |
83 | va_list args; | |
84 | va_start(args,Description); | |
85 | return InsertErrno(NOTICE, Function, Description, args); | |
86 | } | |
87 | /*}}}*/ | |
88 | // GlobalError::DebugE - Get part of the debug string from errno /*{{{*/ | |
89 | bool GlobalError::DebugE(const char *Function,const char *Description,...) { | |
90 | va_list args; | |
91 | va_start(args,Description); | |
92 | return InsertErrno(DEBUG, Function, Description, args); | |
93 | } | |
94 | /*}}}*/ | |
95 | // GlobalError::InsertErrno - Get part of the errortype string from errno/*{{{*/ | |
96 | bool GlobalError::InsertErrno(MsgType const &type, const char *Function, | |
97 | const char *Description,...) { | |
98 | va_list args; | |
99 | va_start(args,Description); | |
100 | return InsertErrno(type, Function, Description, args); | |
101 | } | |
102 | /*}}}*/ | |
103 | // GlobalError::InsertErrno - formats an error message with the errno /*{{{*/ | |
104 | bool GlobalError::InsertErrno(MsgType type, const char* Function, | |
105 | const char* Description, va_list &args) { | |
106 | char S[400]; | |
107 | snprintf(S, sizeof(S), "%s - %s (%i: %s)", Description, | |
108 | Function, errno, strerror(errno)); | |
109 | return Insert(type, S, args); | |
110 | } | |
111 | /*}}}*/ | |
112 | // GlobalError::Fatal - Add a fatal error to the list /*{{{*/ | |
113 | bool GlobalError::Fatal(const char *Description,...) { | |
114 | va_list args; | |
115 | va_start(args,Description); | |
116 | return Insert(FATAL, Description, args); | |
117 | } | |
118 | /*}}}*/ | |
119 | // GlobalError::Error - Add an error to the list /*{{{*/ | |
120 | bool GlobalError::Error(const char *Description,...) { | |
121 | va_list args; | |
122 | va_start(args,Description); | |
123 | return Insert(ERROR, Description, args); | |
124 | } | |
125 | /*}}}*/ | |
126 | // GlobalError::Warning - Add a warning to the list /*{{{*/ | |
127 | bool GlobalError::Warning(const char *Description,...) { | |
128 | va_list args; | |
129 | va_start(args,Description); | |
130 | return Insert(WARNING, Description, args); | |
131 | } | |
132 | /*}}}*/ | |
133 | // GlobalError::Notice - Add a notice to the list /*{{{*/ | |
134 | bool GlobalError::Notice(const char *Description,...) | |
135 | { | |
136 | va_list args; | |
137 | va_start(args,Description); | |
138 | return Insert(NOTICE, Description, args); | |
139 | } | |
140 | /*}}}*/ | |
141 | // GlobalError::Debug - Add a debug to the list /*{{{*/ | |
142 | bool GlobalError::Debug(const char *Description,...) | |
143 | { | |
144 | va_list args; | |
145 | va_start(args,Description); | |
146 | return Insert(DEBUG, Description, args); | |
147 | } | |
148 | /*}}}*/ | |
149 | // GlobalError::Insert - Add a errotype message to the list /*{{{*/ | |
150 | bool GlobalError::Insert(MsgType const &type, const char *Description,...) | |
151 | { | |
152 | va_list args; | |
153 | va_start(args,Description); | |
154 | return Insert(type, Description, args); | |
155 | } | |
156 | /*}}}*/ | |
157 | // GlobalError::Insert - Insert a new item at the end /*{{{*/ | |
158 | bool GlobalError::Insert(MsgType type, const char* Description, | |
159 | va_list &args) { | |
160 | char S[400]; | |
161 | vsnprintf(S,sizeof(S),Description,args); | |
162 | ||
163 | Item const m(S, type); | |
164 | Messages.push_back(m); | |
165 | ||
166 | if (type == ERROR || type == FATAL) | |
167 | PendingFlag = true; | |
168 | ||
169 | if (type == FATAL || type == DEBUG) | |
170 | std::clog << m << std::endl; | |
171 | ||
172 | return false; | |
173 | } | |
174 | /*}}}*/ | |
175 | // GlobalError::PopMessage - Pulls a single message out /*{{{*/ | |
176 | bool GlobalError::PopMessage(std::string &Text) { | |
177 | if (Messages.empty() == true) | |
178 | return false; | |
179 | ||
180 | Item const msg = Messages.front(); | |
181 | Messages.pop_front(); | |
182 | ||
183 | bool const Ret = (msg.Type == ERROR || msg.Type == FATAL); | |
184 | Text = msg.Text; | |
185 | if (PendingFlag == false || Ret == false) | |
186 | return Ret; | |
187 | ||
188 | // check if another error message is pending | |
189 | for (std::list<Item>::const_iterator m = Messages.begin(); | |
190 | m != Messages.end(); m++) | |
191 | if (m->Type == ERROR || m->Type == FATAL) | |
192 | return Ret; | |
193 | ||
194 | PendingFlag = false; | |
195 | return Ret; | |
196 | } | |
197 | /*}}}*/ | |
198 | // GlobalError::DumpErrors - Dump all of the errors/warns to cerr /*{{{*/ | |
199 | void GlobalError::DumpErrors(std::ostream &out, MsgType const &threshold, | |
200 | bool const &mergeStack) { | |
201 | if (mergeStack == true) | |
202 | for (std::list<MsgStack>::const_reverse_iterator s = Stacks.rbegin(); | |
203 | s != Stacks.rend(); ++s) | |
204 | Messages.insert(Messages.begin(), s->Messages.begin(), s->Messages.end()); | |
205 | ||
206 | for (std::list<Item>::const_iterator m = Messages.begin(); | |
207 | m != Messages.end(); m++) | |
208 | if (m->Type >= threshold) | |
209 | out << (*m) << std::endl; | |
210 | Discard(); | |
211 | } | |
212 | /*}}}*/ | |
213 | // GlobalError::Discard - Discard /*{{{*/ | |
214 | void GlobalError::Discard() { | |
215 | Messages.clear(); | |
216 | PendingFlag = false; | |
217 | }; | |
218 | /*}}}*/ | |
219 | // GlobalError::empty - does our error list include anything? /*{{{*/ | |
220 | bool GlobalError::empty(MsgType const &trashhold) const { | |
221 | if (PendingFlag == true) | |
222 | return false; | |
223 | ||
224 | if (Messages.empty() == true) | |
225 | return true; | |
226 | ||
227 | for (std::list<Item>::const_iterator m = Messages.begin(); | |
228 | m != Messages.end(); m++) | |
229 | if (m->Type >= trashhold) | |
230 | return false; | |
231 | ||
232 | return true; | |
233 | } | |
234 | /*}}}*/ | |
235 | // GlobalError::PushToStack /*{{{*/ | |
236 | void GlobalError::PushToStack() { | |
237 | MsgStack pack(Messages, PendingFlag); | |
238 | Stacks.push_back(pack); | |
239 | Discard(); | |
240 | } | |
241 | /*}}}*/ | |
242 | // GlobalError::RevertToStack /*{{{*/ | |
243 | void GlobalError::RevertToStack() { | |
244 | Discard(); | |
245 | MsgStack pack = Stacks.back(); | |
246 | Messages = pack.Messages; | |
247 | PendingFlag = pack.PendingFlag; | |
248 | Stacks.pop_back(); | |
249 | } | |
250 | /*}}}*/ | |
251 | // GlobalError::MergeWithStack /*{{{*/ | |
252 | void GlobalError::MergeWithStack() { | |
253 | MsgStack pack = Stacks.back(); | |
254 | Messages.insert(Messages.begin(), pack.Messages.begin(), pack.Messages.end()); | |
255 | PendingFlag = PendingFlag || pack.PendingFlag; | |
256 | Stacks.pop_back(); | |
257 | } | |
258 | /*}}}*/ |