00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifdef HAVE_CONFIG_H
00027 # include <config.h>
00028 #endif
00029
00030 #include <gwenhywfar/gwenhywfarapi.h>
00031 #include <gwenhywfar/misc.h>
00032 #include <gwenhywfar/buffer.h>
00033 #include <gwenhywfar/gui.h>
00034
00035 #include "logger_p.h"
00036
00037 #include <stdlib.h>
00038 #include <stdio.h>
00039 #include <errno.h>
00040 #ifdef HAVE_SYSLOG_H
00041 # include <syslog.h>
00042 #endif
00043 #include <string.h>
00044 #ifdef HAVE_STRINGS_H
00045 # include <strings.h>
00046 #endif
00047 #ifdef HAVE_TIME_H
00048 # include <time.h>
00049 #endif
00050 #ifdef HAVE_UNISTD_H
00051 # include <unistd.h>
00052 #endif
00053
00054
00055 static GWEN_LOGGER_DOMAIN *gwen_loggerdomains=0;
00056
00057
00058
00059 int GWEN_Logger_ModuleInit(void){
00060 const char *s;
00061 GWEN_LOGGER_LEVEL ll=GWEN_LoggerLevel_Warning;
00062
00063 GWEN_Logger_Open(GWEN_LOGDOMAIN,
00064 "gwen",
00065 0,
00066 GWEN_LoggerType_Console,
00067 GWEN_LoggerFacility_User);
00068 s=getenv("GWEN_LOGLEVEL");
00069 if (s) {
00070 ll=GWEN_Logger_Name2Level(s);
00071 if (ll==GWEN_LoggerLevel_Unknown)
00072 ll=GWEN_LoggerLevel_Warning;
00073 }
00074 GWEN_Logger_SetLevel(GWEN_LOGDOMAIN, ll);
00075 return 0;
00076 }
00077
00078
00079
00080 int GWEN_Logger_ModuleFini(void){
00081 GWEN_LOGGER_DOMAIN *ld;
00082
00083 while((ld=gwen_loggerdomains)) {
00084 GWEN_LoggerDomain_Del(ld);
00085 GWEN_LoggerDomain_free(ld);
00086 }
00087 return 0;
00088 }
00089
00090
00091
00092 GWEN_LOGGER_DOMAIN *GWEN_LoggerDomain_new(const char *name){
00093 GWEN_LOGGER_DOMAIN *ld;
00094
00095 assert(name);
00096 GWEN_NEW_OBJECT(GWEN_LOGGER_DOMAIN, ld);
00097 ld->name=strdup(name);
00098 return ld;
00099 }
00100
00101
00102
00103 void GWEN_LoggerDomain_free(GWEN_LOGGER_DOMAIN *ld){
00104 if (ld) {
00105 free(ld->name);
00106 GWEN_Logger_free(ld->logger);
00107 GWEN_FREE_OBJECT(ld);
00108 }
00109 }
00110
00111
00112 GWEN_LOGGER_DOMAIN *GWEN_LoggerDomain_Find(const char *name) {
00113 GWEN_LOGGER_DOMAIN *ld;
00114
00115 assert(name);
00116 ld=gwen_loggerdomains;
00117 while(ld) {
00118 if (strcasecmp(ld->name, name)==0)
00119 break;
00120 ld=ld->next;
00121 }
00122
00123 return ld;
00124 }
00125
00126
00127
00128 void GWEN_LoggerDomain_Add(GWEN_LOGGER_DOMAIN *ld){
00129 assert(ld);
00130 GWEN_LIST_INSERT(GWEN_LOGGER_DOMAIN, ld, &gwen_loggerdomains);
00131 }
00132
00133
00134
00135 void GWEN_LoggerDomain_Del(GWEN_LOGGER_DOMAIN *ld){
00136 assert(ld);
00137 GWEN_LIST_DEL(GWEN_LOGGER_DOMAIN, ld, &gwen_loggerdomains);
00138 }
00139
00140
00141
00142 GWEN_LOGGER *GWEN_LoggerDomain_GetLogger(const char *name) {
00143 GWEN_LOGGER_DOMAIN *ld;
00144
00145 if (!name)
00146 name="default";
00147
00148 ld=GWEN_LoggerDomain_Find(name);
00149 if (ld) {
00150 return ld->logger;
00151 }
00152 ld=GWEN_LoggerDomain_new(name);
00153 ld->logger=GWEN_Logger_new(ld);
00154
00155 GWEN_LoggerDomain_Add(ld);
00156 return ld->logger;
00157 }
00158
00159
00160
00161 GWEN_LOGGER *GWEN_Logger_new(GWEN_LOGGER_DOMAIN *domain){
00162 GWEN_LOGGER *lg;
00163
00164 GWEN_NEW_OBJECT(GWEN_LOGGER, lg);
00165 lg->usage=1;
00166 lg->enabled=1;
00167 lg->logType=GWEN_LoggerType_Console;
00168 lg->logLevel=GWEN_LoggerLevel_Error;
00169 lg->domain=domain;
00170 return lg;
00171 }
00172
00173
00174
00175 void GWEN_Logger_free(GWEN_LOGGER *lg){
00176 if (lg) {
00177 assert(lg->usage);
00178 if (--(lg->usage)==0) {
00179 free(lg->logFile);
00180 free(lg->logIdent);
00181 GWEN_FREE_OBJECT(lg);
00182 }
00183 }
00184 }
00185
00186
00187
00188 void GWEN_Logger_Attach(GWEN_LOGGER *lg){
00189 assert(lg);
00190 lg->usage++;
00191 }
00192
00193
00194
00195 void GWEN_Logger_AddLogger(GWEN_LOGGER *oldLogger, GWEN_LOGGER *newLogger){
00196 assert(newLogger);
00197
00198 assert(oldLogger);
00199 GWEN_LIST_ADD(GWEN_LOGGER, newLogger, &(oldLogger->next));
00200 }
00201
00202
00203
00204 void GWEN_Logger_SetDefaultLogger(GWEN_UNUSED GWEN_LOGGER *lg){
00205 fprintf(stderr, "GWEN_Logger_SetDefaultLogger: Deprecated function\n");
00206 }
00207
00208
00209
00210 int GWEN_Logger_Open(const char *logDomain,
00211 const char *ident,
00212 const char *file,
00213 GWEN_LOGGER_LOGTYPE logtype,
00214 GWEN_LOGGER_FACILITY facility){
00215 GWEN_LOGGER *lg;
00216
00217 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00218 assert(lg);
00219 lg->logType=logtype;
00220
00221 GWEN_Logger_SetIdent(logDomain, ident);
00222 GWEN_Logger_SetFilename(logDomain, file);
00223
00224 if (logtype==GWEN_LoggerType_File) {
00225
00226 if (file==0) {
00227 lg->logType=GWEN_LoggerType_Console;
00228 lg->enabled=1;
00229 fprintf(stderr,"LOGGER: No filename given, will log to console.\n");
00230 }
00231 else {
00232 lg->logType=GWEN_LoggerType_File;
00233 lg->enabled=1;
00234 }
00235 }
00236 #ifdef HAVE_SYSLOG_H
00237 else if (logtype==GWEN_LoggerType_Syslog) {
00238
00239 int fac;
00240
00241 switch(facility) {
00242 case GWEN_LoggerFacility_Auth:
00243 fac=LOG_AUTH;
00244 break;
00245 case GWEN_LoggerFacility_Daemon:
00246 fac=LOG_DAEMON;
00247 break;
00248 case GWEN_LoggerFacility_Mail:
00249 fac=LOG_MAIL;
00250 break;
00251 case GWEN_LoggerFacility_News:
00252 fac=LOG_NEWS;
00253 break;
00254 case GWEN_LoggerFacility_User:
00255 case GWEN_LoggerFacility_Unknown:
00256 default:
00257 fac=LOG_USER;
00258 break;
00259 }
00260
00261 openlog(ident,
00262 LOG_CONS |
00263 LOG_PID,
00264 fac);
00265 lg->enabled=1;
00266 }
00267 #endif
00268
00269 else {
00270
00271 lg->enabled=1;
00272 }
00273
00274 lg->open=1;
00275
00276 return GWEN_Logger_Log(logDomain, GWEN_LoggerLevel_Debug, "started");
00277 }
00278
00279
00280
00281 void GWEN_Logger_Close(const char *logDomain){
00282 GWEN_LOGGER *lg;
00283
00284 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00285 assert(lg);
00286 GWEN_Logger_Log(logDomain, GWEN_LoggerLevel_Debug, "stopped");
00287 lg->logType=GWEN_LoggerType_Console;
00288 lg->enabled=0;
00289 #ifdef HAVE_SYSLOG_H
00290 closelog();
00291 #endif
00292 lg->open=0;
00293
00294 GWEN_LoggerDomain_Del(lg->domain);
00295 GWEN_LoggerDomain_free(lg->domain);
00296 }
00297
00298
00299
00300 int GWEN_Logger_IsOpen(const char *logDomain){
00301 GWEN_LOGGER_DOMAIN *ld;
00302
00303 if (!logDomain)
00304 logDomain="default";
00305 ld=GWEN_LoggerDomain_Find(logDomain);
00306 if (ld)
00307 return ld->logger->open;
00308 return 0;
00309 }
00310
00311
00312 int GWEN_Logger__CreateMessage(GWEN_LOGGER *lg,
00313 GWEN_LOGGER_LEVEL priority, const char *s,
00314 GWEN_BUFFER *mbuf) {
00315 #ifdef HAVE_SNPRINTF
00316 unsigned int i;
00317 #endif
00318 #ifdef HAVE_TIME_H
00319 struct tm *t;
00320 time_t tt;
00321 #endif
00322 char buffer[256];
00323
00324 assert(lg);
00325 if (lg->logIdent) {
00326 if (strlen(lg->logIdent)+32>=sizeof(buffer)) {
00327 fprintf(stderr," LOGGER: Logbuffer too small (1).\n");
00328 return 1;
00329 }
00330 }
00331
00332 #ifdef HAVE_TIME_H
00333 tt=time(0);
00334 t=localtime(&tt);
00335
00336 # ifdef HAVE_SNPRINTF
00337 # ifdef HAVE_GETPID
00338 i=snprintf(buffer, sizeof(buffer)-1,
00339 "%d:%04d/%02d/%02d %02d-%02d-%02d:%s(%d):",priority,
00340 t->tm_year+1900, t->tm_mon+1, t->tm_mday,
00341 t->tm_hour, t->tm_min, t->tm_sec,
00342 lg->logIdent, (int)getpid());
00343 # else
00344 i=snprintf(buffer, sizeof(buffer)-1,
00345 "%d:%04d/%02d/%02d %02d-%02d-%02d:%s:",priority,
00346 t->tm_year+1900, t->tm_mon+1, t->tm_mday,
00347 t->tm_hour, t->tm_min, t->tm_sec,
00348 lg->logIdent);
00349 # endif
00350 if (i>=sizeof(buffer)) {
00351 fprintf(stderr," LOGGER: Logbuffer too small (2).\n");
00352 return 1;
00353 }
00354 # else
00355 # ifdef HAVE_GETPID
00356 sprintf(buffer,"%d:%04d/%02d/%02d %02d-%02d-%02d:%s(%d):",priority,
00357 t->tm_year+1900, t->tm_mon+1, t->tm_mday,
00358 t->tm_hour, t->tm_min, t->tm_sec,
00359 lg->logIdent, (int)getpid());
00360 # else
00361 sprintf(buffer,"%d:%04d/%02d/%02d %02d-%02d-%02d:%s:",priority,
00362 t->tm_year+1900, t->tm_mon+1, t->tm_mday,
00363 t->tm_hour, t->tm_min, t->tm_sec,
00364 lg->logIdent);
00365 # endif
00366 # endif
00367 #else
00368 # ifdef HAVE_SNPRINTF
00369 buffer[sizeof(buffer)-1]=0;
00370 i=snprintf(buffer, sizeof(buffer)-1,
00371 "%d:%s:",priority,
00372 lg->logIdent);
00373 if (i>=sizeof(buffer)) {
00374 fprintf(stderr," LOGGER: Logbuffer too small (3).\n");
00375 return 1;
00376 }
00377 # else
00378 sprintf(buffer,"%d:%s:",priority,
00379 lg->logIdent);
00380 # endif
00381 #endif
00382 GWEN_Buffer_AppendString(mbuf, buffer);
00383 GWEN_Buffer_AppendString(mbuf, s);
00384 GWEN_Buffer_AppendByte(mbuf, '\n');
00385 return 0;
00386 }
00387
00388
00389
00390 int GWEN_Logger_CreateLogMessage(const char *logDomain,
00391 GWEN_LOGGER_LEVEL priority, const char *s,
00392 GWEN_BUFFER *mbuf){
00393 GWEN_LOGGER *lg;
00394
00395 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00396 assert(lg);
00397
00398 return GWEN_Logger__CreateMessage(lg, priority, s, mbuf);
00399 }
00400
00401
00402
00403 int GWEN_Logger__Log(GWEN_LOGGER *lg,
00404 GWEN_LOGGER_LEVEL priority, const char *s){
00405 while(lg) {
00406 FILE *f;
00407 #ifdef HAVE_SYSLOG_H
00408 int pri;
00409 #endif
00410 GWEN_BUFFER *mbuf;
00411 int rv;
00412
00413 assert(lg);
00414 if (priority>lg->logLevel)
00415
00416 return 0;
00417
00418 mbuf=GWEN_Buffer_new(0, 256, 0, 1);
00419 switch(lg->logType) {
00420 case GWEN_LoggerType_File:
00421 rv=GWEN_Logger__CreateMessage(lg, priority, s, mbuf);
00422 if (rv) {
00423 GWEN_Buffer_free(mbuf);
00424 return rv;
00425 }
00426
00427 f=fopen(lg->logFile,"a+");
00428 if (f==0) {
00429 fprintf(stderr,
00430 "LOGGER: Unable to open file \"%s\" (%s)\n",
00431 lg->logFile,
00432 strerror(errno));
00433 lg->logType=GWEN_LoggerType_Console;
00434 GWEN_Buffer_free(mbuf);
00435 return 1;
00436 }
00437
00438 if (fwrite(GWEN_Buffer_GetStart(mbuf),
00439 GWEN_Buffer_GetUsedBytes(mbuf), 1, f)!=1) {
00440 fprintf(stderr,
00441 "LOGGER: Unable to write to file \"%s\" (%s)\n",
00442 lg->logFile,
00443 strerror(errno));
00444 fclose(f);
00445 lg->logType=GWEN_LoggerType_Console;
00446 GWEN_Buffer_free(mbuf);
00447 return 1;
00448 }
00449 if (fclose(f)) {
00450 fprintf(stderr,
00451 "LOGGER: Unable to close file \"%s\" (%s)\n",
00452 lg->logFile,
00453 strerror(errno));
00454 lg->logType=GWEN_LoggerType_Console;
00455 GWEN_Buffer_free(mbuf);
00456 return 1;
00457 }
00458 break;
00459
00460 #ifdef HAVE_SYSLOG_H
00461 case GWEN_LoggerType_Syslog:
00462 switch(priority) {
00463 case GWEN_LoggerLevel_Emergency:
00464 pri=LOG_EMERG;
00465 break;
00466 case GWEN_LoggerLevel_Alert:
00467 pri=LOG_ALERT;
00468 break;
00469 case GWEN_LoggerLevel_Critical:
00470 pri=LOG_CRIT;
00471 break;
00472 case GWEN_LoggerLevel_Error:
00473 pri=LOG_ERR;
00474 break;
00475 case GWEN_LoggerLevel_Warning:
00476 pri=LOG_WARNING;
00477 break;
00478 case GWEN_LoggerLevel_Notice:
00479 pri=LOG_NOTICE;
00480 break;
00481 case GWEN_LoggerLevel_Info:
00482 pri=LOG_NOTICE;
00483 break;
00484
00485 case GWEN_LoggerLevel_Debug:
00486 case GWEN_LoggerLevel_Verbous:
00487 case GWEN_LoggerLevel_Unknown:
00488 default:
00489 pri=LOG_DEBUG;
00490 break;
00491 }
00492 syslog(pri,"%s",s);
00493 break;
00494 #endif
00495
00496 case GWEN_LoggerType_Function:
00497 if (lg->logFunction==0) {
00498 fprintf(stderr,
00499 "LOGGER: Logtype is \"Function\", but no function is set.\n");
00500 GWEN_Buffer_free(mbuf);
00501 return 1;
00502 }
00503 rv=GWEN_Logger__CreateMessage(lg, priority, s, mbuf);
00504 if (rv) {
00505 GWEN_Buffer_free(mbuf);
00506 return rv;
00507 }
00508 (lg->logFunction)(GWEN_Buffer_GetStart(mbuf));
00509 break;
00510
00511 case GWEN_LoggerType_Console:
00512 case GWEN_LoggerType_Unknown:
00513 default:
00514 rv=GWEN_Logger__CreateMessage(lg, priority, s, mbuf);
00515 if (rv) {
00516 GWEN_Buffer_free(mbuf);
00517 return rv;
00518 }
00519
00520 fprintf(stderr, "%s", GWEN_Buffer_GetStart(mbuf));
00521 break;
00522 }
00523 lg=lg->next;
00524 GWEN_Buffer_free(mbuf);
00525 }
00526 return 0;
00527 }
00528
00529
00530
00531 int GWEN_Logger_Log(const char *logDomain,
00532 GWEN_LOGGER_LEVEL priority, const char *s){
00533 if (!GWEN_Gui_LogHook(logDomain, priority, s)) {
00534 const char *p;
00535 int rv;
00536 unsigned int i;
00537 GWEN_BUFFER *mbuf;
00538 GWEN_LOGGER *lg;
00539
00540 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00541 assert(lg);
00542
00543 if (!lg->enabled)
00544 return 1;
00545
00546 if (priority>lg->logLevel)
00547
00548 return 0;
00549
00550
00551 lg->enabled=0;
00552
00553 mbuf=GWEN_Buffer_new(0, strlen(s)+1, 0, 1);
00554 for (i=0; i<strlen(s)+1; i++) {
00555 if (s[i]=='\n') {
00556 GWEN_Buffer_AppendByte(mbuf, 0);
00557 }
00558 else
00559 GWEN_Buffer_AppendByte(mbuf, s[i]);
00560 }
00561
00562
00563 rv=0;
00564 p=GWEN_Buffer_GetStart(mbuf);
00565 while (*p) {
00566 rv|=GWEN_Logger__Log(lg, priority, p);
00567 while(*p)
00568 p++;
00569 p++;
00570 }
00571 GWEN_Buffer_free(mbuf);
00572
00573 lg->enabled=1;
00574 return rv;
00575 }
00576 else
00577 return 0;
00578 }
00579
00580
00581
00582 void GWEN_Logger_Enable(const char *logDomain, int f){
00583 GWEN_LOGGER *lg;
00584
00585 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00586 assert(lg);
00587 lg->enabled=f;
00588 }
00589
00590
00591
00592 int GWEN_Logger_IsEnabled(const char *logDomain){
00593 GWEN_LOGGER *lg;
00594
00595 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00596 assert(lg);
00597 return lg->enabled;
00598 }
00599
00600
00601
00602 void GWEN_Logger_SetLevel(const char *logDomain, GWEN_LOGGER_LEVEL l){
00603 GWEN_LOGGER *lg;
00604
00605 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00606 assert(lg);
00607 lg->logLevel=l;
00608 }
00609
00610
00611
00612 int GWEN_Logger_GetLevel(const char *logDomain) {
00613 GWEN_LOGGER *lg;
00614
00615 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00616 assert(lg);
00617
00618 return lg->logLevel;
00619 }
00620
00621
00622
00623 void GWEN_Logger_SetIdent(const char *logDomain, const char *id){
00624 GWEN_LOGGER *lg;
00625
00626 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00627 assert(lg);
00628
00629 free(lg->logIdent);
00630 if (id)
00631 lg->logIdent=strdup(id);
00632 else
00633 lg->logIdent=strdup("No ident, please adjust your program");
00634 }
00635
00636
00637
00638 void GWEN_Logger_SetFilename(const char *logDomain, const char *name){
00639 GWEN_LOGGER *lg;
00640
00641 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00642 assert(lg);
00643
00644 free(lg->logFile);
00645 if (name)
00646 lg->logFile=strdup(name);
00647 else
00648 lg->logFile=strdup("");
00649 }
00650
00651
00652
00653 GWEN_LOGGERFUNCTIONLOG GWEN_Logger_SetLogFunction(const char *logDomain,
00654 GWEN_LOGGERFUNCTIONLOG fn){
00655 GWEN_LOGGER *lg;
00656 GWEN_LOGGERFUNCTIONLOG oldFn;
00657
00658 lg=GWEN_LoggerDomain_GetLogger(logDomain);
00659 assert(lg);
00660 oldFn=lg->logFunction;
00661 lg->logFunction=fn;
00662 return oldFn;
00663 }
00664
00665
00666
00667 GWEN_LOGGER_LEVEL GWEN_Logger_Name2Level(const char *name) {
00668 if (strcasecmp(name, "emergency")==0)
00669 return GWEN_LoggerLevel_Emergency;
00670 else if (strcasecmp(name, "alert")==0)
00671 return GWEN_LoggerLevel_Alert;
00672 else if (strcasecmp(name, "critical")==0)
00673 return GWEN_LoggerLevel_Critical;
00674 else if (strcasecmp(name, "error")==0)
00675 return GWEN_LoggerLevel_Error;
00676 else if (strcasecmp(name, "warning")==0)
00677 return GWEN_LoggerLevel_Warning;
00678 else if (strcasecmp(name, "notice")==0)
00679 return GWEN_LoggerLevel_Notice;
00680 else if (strcasecmp(name, "info")==0)
00681 return GWEN_LoggerLevel_Info;
00682 else if (strcasecmp(name, "debug")==0)
00683 return GWEN_LoggerLevel_Debug;
00684 else if (strcasecmp(name, "verbous")==0)
00685 return GWEN_LoggerLevel_Verbous;
00686 else {
00687 return GWEN_LoggerLevel_Unknown;
00688 }
00689 }
00690
00691
00692
00693 const char *GWEN_Logger_Level2Name(GWEN_LOGGER_LEVEL level) {
00694 const char *s;
00695
00696 switch(level) {
00697 case GWEN_LoggerLevel_Emergency:
00698 s="emergency"; break;
00699 case GWEN_LoggerLevel_Alert:
00700 s="alert"; break;
00701 case GWEN_LoggerLevel_Critical:
00702 s="critical"; break;
00703 case GWEN_LoggerLevel_Error:
00704 s="error"; break;
00705 case GWEN_LoggerLevel_Warning:
00706 s="warning"; break;
00707 case GWEN_LoggerLevel_Notice:
00708 s="notice"; break;
00709 case GWEN_LoggerLevel_Info:
00710 s="info"; break;
00711 case GWEN_LoggerLevel_Debug:
00712 s="debug"; break;
00713 case GWEN_LoggerLevel_Verbous:
00714 s="verbous"; break;
00715 case GWEN_LoggerLevel_Unknown:
00716 default:
00717 s="unknown"; break;
00718 }
00719 return s;
00720 }
00721
00722
00723
00724 GWEN_LOGGER_LOGTYPE GWEN_Logger_Name2Logtype(const char *name) {
00725 if (strcasecmp(name, "console")==0)
00726 return GWEN_LoggerType_Console;
00727 else if (strcasecmp(name, "file")==0)
00728 return GWEN_LoggerType_File;
00729 else if (strcasecmp(name, "syslog")==0)
00730 return GWEN_LoggerType_Syslog;
00731 else if (strcasecmp(name, "function")==0)
00732 return GWEN_LoggerType_Function;
00733 else {
00734 return GWEN_LoggerType_Unknown;
00735 }
00736 }
00737
00738
00739
00740 const char *GWEN_Logger_Logtype2Name(GWEN_LOGGER_LOGTYPE lt) {
00741 const char *s;
00742
00743 switch(lt) {
00744 case GWEN_LoggerType_Console:
00745 s="console"; break;
00746 case GWEN_LoggerType_File:
00747 s="file"; break;
00748 case GWEN_LoggerType_Syslog:
00749 s="syslog"; break;
00750 case GWEN_LoggerType_Function:
00751 s="function"; break;
00752 case GWEN_LoggerType_Unknown:
00753 default:
00754 s="unknown"; break;
00755 }
00756 return s;
00757 }
00758
00759
00760
00761 int GWEN_Logger_Exists(const char *logDomain){
00762 assert(logDomain);
00763 return (GWEN_LoggerDomain_Find(logDomain)!=0);
00764 }
00765
00766
00767
00768
00769
00770
00771
00772