gwenhywfar
4.3.3
|
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(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 /* 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