gwenhywfar 4.0.3

logger.c

Go to the documentation of this file.
00001 /***************************************************************************
00002     begin       : Sun Dec 05 2003
00003     copyright   : (C) 2003 by Martin Preuss
00004     email       : martin@libchipcard.de
00005 
00006  ***************************************************************************
00007  *                                                                         *
00008  *   This library is free software; you can redistribute it and/or         *
00009  *   modify it under the terms of the GNU Lesser General Public            *
00010  *   License as published by the Free Software Foundation; either          *
00011  *   version 2.1 of the License, or (at your option) any later version.    *
00012  *                                                                         *
00013  *   This library is distributed in the hope that it will be useful,       *
00014  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00015  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00016  *   Lesser General Public License for more details.                       *
00017  *                                                                         *
00018  *   You should have received a copy of the GNU Lesser General Public      *
00019  *   License along with this library; if not, write to the Free Software   *
00020  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00021  *   MA  02111-1307  USA                                                   *
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(){
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(){
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     /* logging to a file */
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     /* caller wants to log via syslog */
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   } /* if syslog */
00267 #endif /* ifdef HAVE_SYSLOG_H */
00268 
00269   else {
00270     /* console or function */
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   /* remove logdomain after it has been closed */
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 /* HAVE_SNPRINTF */
00318 #ifdef HAVE_TIME_H
00319   struct tm *t;
00320   time_t tt;
00321 #endif /* HAVE_TIME_H */
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 /* HAVE_GETPID */
00350   if (i>=sizeof(buffer)) {
00351     fprintf(stderr," LOGGER: Logbuffer too small (2).\n");
00352     return 1;
00353   }
00354 # else   /* HAVE_SNPRINTF */
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 /* HAVE_GETPID */
00366 # endif  /* HAVE_SNPRINTF */
00367 #else    /* HAVE_TIME_H */
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   /* HAVE_SNPRINTF */
00378   sprintf(buffer,"%d:%s:",priority,
00379           lg->logIdent);
00380 # endif  /* HAVE_SNPRINTF */
00381 #endif   /* HAVE_TIME_H */
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 /* HAVE_SYSLOG_H */
00410     GWEN_BUFFER *mbuf;
00411     int rv;
00412 
00413     assert(lg);
00414     if (priority>lg->logLevel)
00415       /* priority too low, don't log */
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       } /* switch */
00492       syslog(pri,"%s",s);
00493       break;
00494 #endif /* HAVE_SYSLOG_H */
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     } /* switch */
00523     lg=lg->next;
00524     GWEN_Buffer_free(mbuf);
00525   } /* while lg */
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       /* priority too low, don't log */
00548       return 0;
00549   
00550     /* temporarily disable logging to avoid endless loops */
00551     lg->enabled=0;
00552     /* copy buffer, exchange all newlines by 0 */
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     /* now log each line */
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     /* reenable logging */
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   } /* switch */
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   } /* switch */
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