1 /***************************************************************************
2 begin : Sun Dec 05 2003
3 copyright : (C) 2003 by Martin Preuss
4 email : martin@libchipcard.de
5
6 ***************************************************************************
7 * *
8 * This library is free software; you can redistribute it and/or *
9 * modify it under the terms of the GNU Lesser General Public *
10 * License as published by the Free Software Foundation; either *
11 * version 2.1 of the License, or (at your option) any later version. *
12 * *
13 * This library is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
16 * Lesser General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU Lesser General Public *
19 * License along with this library; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 * *
23 ***************************************************************************/
24
25
26 #ifdef HAVE_CONFIG_H
27 # include <config.h>
28 #endif
29
30 #include <gwenhywfar/gwenhywfarapi.h>
31 #include <gwenhywfar/misc.h>
32 #include <gwenhywfar/buffer.h>
33 #include <gwenhywfar/gui.h>
34
35 #include "logger_p.h"
36
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <errno.h>
40 #ifdef HAVE_SYSLOG_H
41 # include <syslog.h>
42 #endif
43 #include <string.h>
44 #ifdef HAVE_STRINGS_H
45 # include <strings.h>
46 #endif
47 #ifdef HAVE_TIME_H
48 # include <time.h>
49 #endif
50 #ifdef HAVE_UNISTD_H
51 # include <unistd.h>
52 #endif
53
54
55 static GWEN_LOGGER_DOMAIN *gwen_loggerdomains=0;
56
57
58
GWEN_Logger_ModuleInit(void)59 int GWEN_Logger_ModuleInit(void)
60 {
61 const char *s;
62 GWEN_LOGGER_LEVEL ll=GWEN_LoggerLevel_Warning;
63
64 GWEN_Logger_Open(GWEN_LOGDOMAIN,
65 "gwen",
66 0,
67 GWEN_LoggerType_Console,
68 GWEN_LoggerFacility_User);
69 s=getenv("GWEN_LOGLEVEL");
70 if (s) {
71 ll=GWEN_Logger_Name2Level(s);
72 if (ll==GWEN_LoggerLevel_Unknown)
73 ll=GWEN_LoggerLevel_Warning;
74 }
75 GWEN_Logger_SetLevel(GWEN_LOGDOMAIN, ll);
76 return 0;
77 }
78
79
80
GWEN_Logger_ModuleFini(void)81 int GWEN_Logger_ModuleFini(void)
82 {
83 GWEN_LOGGER_DOMAIN *ld;
84
85 while ((ld=gwen_loggerdomains)) {
86 GWEN_LoggerDomain_Del(ld);
87 GWEN_LoggerDomain_free(ld);
88 }
89 return 0;
90 }
91
92
93
GWEN_LoggerDomain_new(const char * name)94 GWEN_LOGGER_DOMAIN *GWEN_LoggerDomain_new(const char *name)
95 {
96 GWEN_LOGGER_DOMAIN *ld;
97
98 assert(name);
99 GWEN_NEW_OBJECT(GWEN_LOGGER_DOMAIN, ld);
100 ld->name=strdup(name);
101 return ld;
102 }
103
104
105
GWEN_LoggerDomain_free(GWEN_LOGGER_DOMAIN * ld)106 void GWEN_LoggerDomain_free(GWEN_LOGGER_DOMAIN *ld)
107 {
108 if (ld) {
109 free(ld->name);
110 GWEN_Logger_free(ld->logger);
111 GWEN_FREE_OBJECT(ld);
112 }
113 }
114
115
GWEN_LoggerDomain_Find(const char * name)116 GWEN_LOGGER_DOMAIN *GWEN_LoggerDomain_Find(const char *name)
117 {
118 GWEN_LOGGER_DOMAIN *ld;
119
120 assert(name);
121 ld=gwen_loggerdomains;
122 while (ld) {
123 if (strcasecmp(ld->name, name)==0)
124 break;
125 ld=ld->next;
126 }
127
128 return ld;
129 }
130
131
132
GWEN_LoggerDomain_Add(GWEN_LOGGER_DOMAIN * ld)133 void GWEN_LoggerDomain_Add(GWEN_LOGGER_DOMAIN *ld)
134 {
135 assert(ld);
136 GWEN_LIST_INSERT(GWEN_LOGGER_DOMAIN, ld, &gwen_loggerdomains);
137 }
138
139
140
GWEN_LoggerDomain_Del(GWEN_LOGGER_DOMAIN * ld)141 void GWEN_LoggerDomain_Del(GWEN_LOGGER_DOMAIN *ld)
142 {
143 assert(ld);
144 GWEN_LIST_DEL(GWEN_LOGGER_DOMAIN, ld, &gwen_loggerdomains);
145 }
146
147
148
GWEN_LoggerDomain_GetLogger(const char * name)149 GWEN_LOGGER *GWEN_LoggerDomain_GetLogger(const char *name)
150 {
151 GWEN_LOGGER_DOMAIN *ld;
152
153 if (!name)
154 name="default";
155
156 ld=GWEN_LoggerDomain_Find(name);
157 if (ld) {
158 return ld->logger;
159 }
160 ld=GWEN_LoggerDomain_new(name);
161 ld->logger=GWEN_Logger_new(ld);
162
163 GWEN_LoggerDomain_Add(ld);
164 return ld->logger;
165 }
166
167
168
GWEN_Logger_new(GWEN_LOGGER_DOMAIN * domain)169 GWEN_LOGGER *GWEN_Logger_new(GWEN_LOGGER_DOMAIN *domain)
170 {
171 GWEN_LOGGER *lg;
172
173 GWEN_NEW_OBJECT(GWEN_LOGGER, lg);
174 lg->usage=1;
175 lg->enabled=1;
176 lg->logType=GWEN_LoggerType_Console;
177 lg->logLevel=GWEN_LoggerLevel_Error;
178 lg->domain=domain;
179 return lg;
180 }
181
182
183
GWEN_Logger_free(GWEN_LOGGER * lg)184 void GWEN_Logger_free(GWEN_LOGGER *lg)
185 {
186 if (lg) {
187 assert(lg->usage);
188 if (--(lg->usage)==0) {
189 free(lg->logFile);
190 free(lg->logIdent);
191 GWEN_FREE_OBJECT(lg);
192 }
193 }
194 }
195
196
197
GWEN_Logger_Attach(GWEN_LOGGER * lg)198 void GWEN_Logger_Attach(GWEN_LOGGER *lg)
199 {
200 assert(lg);
201 lg->usage++;
202 }
203
204
205
GWEN_Logger_AddLogger(GWEN_LOGGER * oldLogger,GWEN_LOGGER * newLogger)206 void GWEN_Logger_AddLogger(GWEN_LOGGER *oldLogger, GWEN_LOGGER *newLogger)
207 {
208 assert(newLogger);
209
210 assert(oldLogger);
211 GWEN_LIST_ADD(GWEN_LOGGER, newLogger, &(oldLogger->next));
212 }
213
214
215
216 #ifndef NO_DEPRECATED_SYMBOLS
GWEN_Logger_SetDefaultLogger(GWEN_UNUSED GWEN_LOGGER * lg)217 void GWEN_Logger_SetDefaultLogger(GWEN_UNUSED GWEN_LOGGER *lg)
218 {
219 fprintf(stderr, "GWEN_Logger_SetDefaultLogger: Deprecated function\n");
220 }
221 #endif // ifndef NO_DEPRECATED_SYMBOLS
222
223
224
GWEN_Logger_Open(const char * logDomain,const char * ident,const char * file,GWEN_LOGGER_LOGTYPE logtype,GWEN_LOGGER_FACILITY facility)225 int GWEN_Logger_Open(const char *logDomain,
226 const char *ident,
227 const char *file,
228 GWEN_LOGGER_LOGTYPE logtype,
229 GWEN_LOGGER_FACILITY facility)
230 {
231 GWEN_LOGGER *lg;
232
233 lg=GWEN_LoggerDomain_GetLogger(logDomain);
234 assert(lg);
235 lg->logType=logtype;
236
237 GWEN_Logger_SetIdent(logDomain, ident);
238 GWEN_Logger_SetFilename(logDomain, file);
239
240 if (logtype==GWEN_LoggerType_File) {
241 /* logging to a file */
242 if (file==0) {
243 lg->logType=GWEN_LoggerType_Console;
244 lg->enabled=1;
245 fprintf(stderr, "LOGGER: No filename given, will log to console.\n");
246 }
247 else {
248 lg->logType=GWEN_LoggerType_File;
249 lg->enabled=1;
250 }
251 }
252 #ifdef HAVE_SYSLOG_H
253 else if (logtype==GWEN_LoggerType_Syslog) {
254 /* caller wants to log via syslog */
255 int fac;
256
257 switch (facility) {
258 case GWEN_LoggerFacility_Auth:
259 fac=LOG_AUTH;
260 break;
261 case GWEN_LoggerFacility_Daemon:
262 fac=LOG_DAEMON;
263 break;
264 case GWEN_LoggerFacility_Mail:
265 fac=LOG_MAIL;
266 break;
267 case GWEN_LoggerFacility_News:
268 fac=LOG_NEWS;
269 break;
270 case GWEN_LoggerFacility_User:
271 case GWEN_LoggerFacility_Unknown:
272 default:
273 fac=LOG_USER;
274 break;
275 }
276
277 openlog(ident,
278 LOG_CONS |
279 LOG_PID,
280 fac);
281 lg->enabled=1;
282 } /* if syslog */
283 #endif /* ifdef HAVE_SYSLOG_H */
284
285 else {
286 /* console or function */
287 lg->enabled=1;
288 }
289
290 lg->open=1;
291
292 GWEN_Logger_Log(logDomain, GWEN_LoggerLevel_Debug, "started");
293 return 0;
294 }
295
296
297
GWEN_Logger_Close(const char * logDomain)298 void GWEN_Logger_Close(const char *logDomain)
299 {
300 GWEN_LOGGER *lg;
301
302 lg=GWEN_LoggerDomain_GetLogger(logDomain);
303 assert(lg);
304 GWEN_Logger_Log(logDomain, GWEN_LoggerLevel_Debug, "stopped");
305 lg->logType=GWEN_LoggerType_Console;
306 lg->enabled=0;
307 #ifdef HAVE_SYSLOG_H
308 closelog();
309 #endif
310 lg->open=0;
311 /* remove logdomain after it has been closed */
312 GWEN_LoggerDomain_Del(lg->domain);
313 GWEN_LoggerDomain_free(lg->domain);
314 }
315
316
317
GWEN_Logger_IsOpen(const char * logDomain)318 int GWEN_Logger_IsOpen(const char *logDomain)
319 {
320 GWEN_LOGGER_DOMAIN *ld;
321
322 if (!logDomain)
323 logDomain="default";
324 ld=GWEN_LoggerDomain_Find(logDomain);
325 if (ld)
326 return ld->logger->open;
327 return 0;
328 }
329
330
GWEN_Logger__CreateMessage(GWEN_LOGGER * lg,GWEN_LOGGER_LEVEL priority,const char * s,GWEN_BUFFER * mbuf)331 int GWEN_Logger__CreateMessage(GWEN_LOGGER *lg,
332 GWEN_LOGGER_LEVEL priority, const char *s,
333 GWEN_BUFFER *mbuf)
334 {
335 #ifdef HAVE_SNPRINTF
336 unsigned int i;
337 #endif /* HAVE_SNPRINTF */
338 #ifdef HAVE_TIME_H
339 struct tm *t;
340 time_t tt;
341 #endif /* HAVE_TIME_H */
342 char buffer[256];
343
344 assert(lg);
345 if (lg->logIdent) {
346 if (strlen(lg->logIdent)+32>=sizeof(buffer)) {
347 fprintf(stderr, " LOGGER: Logbuffer too small (1).\n");
348 return 1;
349 }
350 }
351
352 #ifdef HAVE_TIME_H
353 tt=time(0);
354 t=localtime(&tt);
355
356 # ifdef HAVE_SNPRINTF
357 # ifdef HAVE_GETPID
358 i=snprintf(buffer, sizeof(buffer)-1,
359 "%d:%04d/%02d/%02d %02d-%02d-%02d:%s(%d):", priority,
360 t->tm_year+1900, t->tm_mon+1, t->tm_mday,
361 t->tm_hour, t->tm_min, t->tm_sec,
362 lg->logIdent, (int)getpid());
363 # else
364 i=snprintf(buffer, sizeof(buffer)-1,
365 "%d:%04d/%02d/%02d %02d-%02d-%02d:%s:", priority,
366 t->tm_year+1900, t->tm_mon+1, t->tm_mday,
367 t->tm_hour, t->tm_min, t->tm_sec,
368 lg->logIdent);
369 # endif /* HAVE_GETPID */
370 if (i>=sizeof(buffer)) {
371 fprintf(stderr, " LOGGER: Logbuffer too small (2).\n");
372 return 1;
373 }
374 # else /* HAVE_SNPRINTF */
375 # ifdef HAVE_GETPID
376 sprintf(buffer, "%d:%04d/%02d/%02d %02d-%02d-%02d:%s(%d):", priority,
377 t->tm_year+1900, t->tm_mon+1, t->tm_mday,
378 t->tm_hour, t->tm_min, t->tm_sec,
379 lg->logIdent, (int)getpid());
380 # else
381 sprintf(buffer, "%d:%04d/%02d/%02d %02d-%02d-%02d:%s:", priority,
382 t->tm_year+1900, t->tm_mon+1, t->tm_mday,
383 t->tm_hour, t->tm_min, t->tm_sec,
384 lg->logIdent);
385 # endif /* HAVE_GETPID */
386 # endif /* HAVE_SNPRINTF */
387 #else /* HAVE_TIME_H */
388 # ifdef HAVE_SNPRINTF
389 buffer[sizeof(buffer)-1]=0;
390 i=snprintf(buffer, sizeof(buffer)-1,
391 "%d:%s:", priority,
392 lg->logIdent);
393 if (i>=sizeof(buffer)) {
394 fprintf(stderr, " LOGGER: Logbuffer too small (3).\n");
395 return 1;
396 }
397 # else /* HAVE_SNPRINTF */
398 sprintf(buffer, "%d:%s:", priority,
399 lg->logIdent);
400 # endif /* HAVE_SNPRINTF */
401 #endif /* HAVE_TIME_H */
402 GWEN_Buffer_AppendString(mbuf, buffer);
403 GWEN_Buffer_AppendString(mbuf, s);
404 GWEN_Buffer_AppendByte(mbuf, '\n');
405 return 0;
406 }
407
408
409
GWEN_Logger_CreateLogMessage(const char * logDomain,GWEN_LOGGER_LEVEL priority,const char * s,GWEN_BUFFER * mbuf)410 int GWEN_Logger_CreateLogMessage(const char *logDomain,
411 GWEN_LOGGER_LEVEL priority, const char *s,
412 GWEN_BUFFER *mbuf)
413 {
414 GWEN_LOGGER *lg;
415
416 lg=GWEN_LoggerDomain_GetLogger(logDomain);
417 assert(lg);
418
419 return GWEN_Logger__CreateMessage(lg, priority, s, mbuf);
420 }
421
422
423
GWEN_Logger__Log(GWEN_LOGGER * lg,GWEN_LOGGER_LEVEL priority,const char * s)424 int GWEN_Logger__Log(GWEN_LOGGER *lg,
425 GWEN_LOGGER_LEVEL priority, const char *s)
426 {
427 while (lg) {
428 FILE *f;
429 #ifdef HAVE_SYSLOG_H
430 int pri;
431 #endif /* HAVE_SYSLOG_H */
432 GWEN_BUFFER *mbuf;
433 int rv;
434
435 assert(lg);
436 if (priority>lg->logLevel)
437 /* priority too low, don't log */
438 return 0;
439
440 mbuf=GWEN_Buffer_new(0, 256, 0, 1);
441 switch (lg->logType) {
442 case GWEN_LoggerType_File:
443 rv=GWEN_Logger__CreateMessage(lg, priority, s, mbuf);
444 if (rv) {
445 GWEN_Buffer_free(mbuf);
446 return rv;
447 }
448
449 f=fopen(lg->logFile, "a+");
450 if (f==0) {
451 fprintf(stderr,
452 "LOGGER: Unable to open file \"%s\" (%s)\n",
453 lg->logFile,
454 strerror(errno));
455 lg->logType=GWEN_LoggerType_Console;
456 GWEN_Buffer_free(mbuf);
457 return 1;
458 }
459
460 if (fwrite(GWEN_Buffer_GetStart(mbuf),
461 GWEN_Buffer_GetUsedBytes(mbuf), 1, f)!=1) {
462 fprintf(stderr,
463 "LOGGER: Unable to write to file \"%s\" (%s)\n",
464 lg->logFile,
465 strerror(errno));
466 fclose(f);
467 lg->logType=GWEN_LoggerType_Console;
468 GWEN_Buffer_free(mbuf);
469 return 1;
470 }
471 if (fclose(f)) {
472 fprintf(stderr,
473 "LOGGER: Unable to close file \"%s\" (%s)\n",
474 lg->logFile,
475 strerror(errno));
476 lg->logType=GWEN_LoggerType_Console;
477 GWEN_Buffer_free(mbuf);
478 return 1;
479 }
480 break;
481
482 #ifdef HAVE_SYSLOG_H
483 case GWEN_LoggerType_Syslog:
484 switch (priority) {
485 case GWEN_LoggerLevel_Emergency:
486 pri=LOG_EMERG;
487 break;
488 case GWEN_LoggerLevel_Alert:
489 pri=LOG_ALERT;
490 break;
491 case GWEN_LoggerLevel_Critical:
492 pri=LOG_CRIT;
493 break;
494 case GWEN_LoggerLevel_Error:
495 pri=LOG_ERR;
496 break;
497 case GWEN_LoggerLevel_Warning:
498 pri=LOG_WARNING;
499 break;
500 case GWEN_LoggerLevel_Notice:
501 pri=LOG_NOTICE;
502 break;
503 case GWEN_LoggerLevel_Info:
504 pri=LOG_NOTICE;
505 break;
506
507 case GWEN_LoggerLevel_Debug:
508 case GWEN_LoggerLevel_Verbous:
509 case GWEN_LoggerLevel_Unknown:
510 default:
511 pri=LOG_DEBUG;
512 break;
513 } /* switch */
514 syslog(pri, "%s", s);
515 break;
516 #endif /* HAVE_SYSLOG_H */
517
518 case GWEN_LoggerType_Function:
519 if (lg->logFunction==0) {
520 fprintf(stderr,
521 "LOGGER: Logtype is \"Function\", but no function is set.\n");
522 GWEN_Buffer_free(mbuf);
523 return 1;
524 }
525 rv=GWEN_Logger__CreateMessage(lg, priority, s, mbuf);
526 if (rv) {
527 GWEN_Buffer_free(mbuf);
528 return rv;
529 }
530 (lg->logFunction)(GWEN_Buffer_GetStart(mbuf));
531 break;
532
533 case GWEN_LoggerType_Console:
534 case GWEN_LoggerType_Unknown:
535 default:
536 rv=GWEN_Logger__CreateMessage(lg, priority, s, mbuf);
537 if (rv) {
538 GWEN_Buffer_free(mbuf);
539 return rv;
540 }
541
542 fprintf(stderr, "%s", GWEN_Buffer_GetStart(mbuf));
543 break;
544 } /* switch */
545 lg=lg->next;
546 GWEN_Buffer_free(mbuf);
547 } /* while lg */
548 return 0;
549 }
550
551
552
GWEN_Logger_Log(const char * logDomain,GWEN_LOGGER_LEVEL priority,const char * s)553 void GWEN_Logger_Log(const char *logDomain,
554 GWEN_LOGGER_LEVEL priority, const char *s)
555 {
556 if (!GWEN_Gui_LogHook(logDomain, priority, s)) {
557 const char *p;
558 /*int rv;*/
559 unsigned int i;
560 GWEN_BUFFER *mbuf;
561 GWEN_LOGGER *lg;
562
563 lg=GWEN_LoggerDomain_GetLogger(logDomain);
564 assert(lg);
565
566 if (!lg->enabled)
567 return /*1*/;
568
569 if (priority>lg->logLevel)
570 /* priority too low, don't log */
571 return /*0*/;
572
573 /* temporarily disable logging to avoid endless loops */
574 lg->enabled=0;
575 /* copy buffer, exchange all newlines by 0 */
576 mbuf=GWEN_Buffer_new(0, strlen(s)+1, 0, 1);
577 for (i=0; i<strlen(s)+1; i++) {
578 if (s[i]=='\n') {
579 GWEN_Buffer_AppendByte(mbuf, 0);
580 }
581 else
582 GWEN_Buffer_AppendByte(mbuf, s[i]);
583 }
584
585 /* now log each line */
586 /*rv=0;*/
587 p=GWEN_Buffer_GetStart(mbuf);
588 while (*p) {
589 GWEN_Logger__Log(lg, priority, p);
590 while (*p)
591 p++;
592 p++;
593 }
594 GWEN_Buffer_free(mbuf);
595 /* reenable logging */
596 lg->enabled=1;
597 return /*rv*/;
598 }
599 else
600 return /*0*/;
601 }
602
603
604
GWEN_Logger_Enable(const char * logDomain,int f)605 void GWEN_Logger_Enable(const char *logDomain, int f)
606 {
607 GWEN_LOGGER *lg;
608
609 lg=GWEN_LoggerDomain_GetLogger(logDomain);
610 assert(lg);
611 lg->enabled=f;
612 }
613
614
615
GWEN_Logger_IsEnabled(const char * logDomain)616 int GWEN_Logger_IsEnabled(const char *logDomain)
617 {
618 GWEN_LOGGER *lg;
619
620 lg=GWEN_LoggerDomain_GetLogger(logDomain);
621 assert(lg);
622 return lg->enabled;
623 }
624
625
626
GWEN_Logger_SetLevel(const char * logDomain,GWEN_LOGGER_LEVEL l)627 void GWEN_Logger_SetLevel(const char *logDomain, GWEN_LOGGER_LEVEL l)
628 {
629 GWEN_LOGGER *lg;
630
631 lg=GWEN_LoggerDomain_GetLogger(logDomain);
632 assert(lg);
633 lg->logLevel=l;
634 }
635
636
637
GWEN_Logger_GetLevel(const char * logDomain)638 int GWEN_Logger_GetLevel(const char *logDomain)
639 {
640 GWEN_LOGGER *lg;
641
642 lg=GWEN_LoggerDomain_GetLogger(logDomain);
643 assert(lg);
644
645 return lg->logLevel;
646 }
647
648
649
GWEN_Logger_SetIdent(const char * logDomain,const char * id)650 void GWEN_Logger_SetIdent(const char *logDomain, const char *id)
651 {
652 GWEN_LOGGER *lg;
653
654 lg=GWEN_LoggerDomain_GetLogger(logDomain);
655 assert(lg);
656
657 free(lg->logIdent);
658 if (id)
659 lg->logIdent=strdup(id);
660 else
661 lg->logIdent=strdup("No ident, please adjust your program");
662 }
663
664
665
GWEN_Logger_SetFilename(const char * logDomain,const char * name)666 void GWEN_Logger_SetFilename(const char *logDomain, const char *name)
667 {
668 GWEN_LOGGER *lg;
669
670 lg=GWEN_LoggerDomain_GetLogger(logDomain);
671 assert(lg);
672
673 free(lg->logFile);
674 if (name)
675 lg->logFile=strdup(name);
676 else
677 lg->logFile=strdup("");
678 }
679
680
681
GWEN_Logger_SetLogFunction(const char * logDomain,GWEN_LOGGERFUNCTIONLOG fn)682 GWEN_LOGGERFUNCTIONLOG GWEN_Logger_SetLogFunction(const char *logDomain,
683 GWEN_LOGGERFUNCTIONLOG fn)
684 {
685 GWEN_LOGGER *lg;
686 GWEN_LOGGERFUNCTIONLOG oldFn;
687
688 lg=GWEN_LoggerDomain_GetLogger(logDomain);
689 assert(lg);
690 oldFn=lg->logFunction;
691 lg->logFunction=fn;
692 return oldFn;
693 }
694
695
696
GWEN_Logger_Name2Level(const char * name)697 GWEN_LOGGER_LEVEL GWEN_Logger_Name2Level(const char *name)
698 {
699 if (strcasecmp(name, "emergency")==0)
700 return GWEN_LoggerLevel_Emergency;
701 else if (strcasecmp(name, "alert")==0)
702 return GWEN_LoggerLevel_Alert;
703 else if (strcasecmp(name, "critical")==0)
704 return GWEN_LoggerLevel_Critical;
705 else if (strcasecmp(name, "error")==0)
706 return GWEN_LoggerLevel_Error;
707 else if (strcasecmp(name, "warning")==0)
708 return GWEN_LoggerLevel_Warning;
709 else if (strcasecmp(name, "notice")==0)
710 return GWEN_LoggerLevel_Notice;
711 else if (strcasecmp(name, "info")==0)
712 return GWEN_LoggerLevel_Info;
713 else if (strcasecmp(name, "debug")==0)
714 return GWEN_LoggerLevel_Debug;
715 else if (strcasecmp(name, "verbous")==0)
716 return GWEN_LoggerLevel_Verbous;
717 else {
718 return GWEN_LoggerLevel_Unknown;
719 }
720 }
721
722
723
GWEN_Logger_Level2Name(GWEN_LOGGER_LEVEL level)724 const char *GWEN_Logger_Level2Name(GWEN_LOGGER_LEVEL level)
725 {
726 const char *s;
727
728 switch (level) {
729 case GWEN_LoggerLevel_Emergency:
730 s="emergency";
731 break;
732 case GWEN_LoggerLevel_Alert:
733 s="alert";
734 break;
735 case GWEN_LoggerLevel_Critical:
736 s="critical";
737 break;
738 case GWEN_LoggerLevel_Error:
739 s="error";
740 break;
741 case GWEN_LoggerLevel_Warning:
742 s="warning";
743 break;
744 case GWEN_LoggerLevel_Notice:
745 s="notice";
746 break;
747 case GWEN_LoggerLevel_Info:
748 s="info";
749 break;
750 case GWEN_LoggerLevel_Debug:
751 s="debug";
752 break;
753 case GWEN_LoggerLevel_Verbous:
754 s="verbous";
755 break;
756 case GWEN_LoggerLevel_Unknown:
757 default:
758 s="unknown";
759 break;
760 } /* switch */
761 return s;
762 }
763
764
765
GWEN_Logger_Name2Logtype(const char * name)766 GWEN_LOGGER_LOGTYPE GWEN_Logger_Name2Logtype(const char *name)
767 {
768 if (strcasecmp(name, "console")==0)
769 return GWEN_LoggerType_Console;
770 else if (strcasecmp(name, "file")==0)
771 return GWEN_LoggerType_File;
772 else if (strcasecmp(name, "syslog")==0)
773 return GWEN_LoggerType_Syslog;
774 else if (strcasecmp(name, "function")==0)
775 return GWEN_LoggerType_Function;
776 else {
777 return GWEN_LoggerType_Unknown;
778 }
779 }
780
781
782
GWEN_Logger_Logtype2Name(GWEN_LOGGER_LOGTYPE lt)783 const char *GWEN_Logger_Logtype2Name(GWEN_LOGGER_LOGTYPE lt)
784 {
785 const char *s;
786
787 switch (lt) {
788 case GWEN_LoggerType_Console:
789 s="console";
790 break;
791 case GWEN_LoggerType_File:
792 s="file";
793 break;
794 case GWEN_LoggerType_Syslog:
795 s="syslog";
796 break;
797 case GWEN_LoggerType_Function:
798 s="function";
799 break;
800 case GWEN_LoggerType_Unknown:
801 default:
802 s="unknown";
803 break;
804 } /* switch */
805 return s;
806 }
807
808
809
GWEN_Logger_Exists(const char * logDomain)810 int GWEN_Logger_Exists(const char *logDomain)
811 {
812 assert(logDomain);
813 return (GWEN_LoggerDomain_Find(logDomain)!=0);
814 }
815
816
817
818
819
820
821
822
823