Return to HTMemLog.c CVS log

Up to [Public] / libwww / Library / src

Annotation of libwww/Library/src/HTMemLog.c, revision 1.1.2.2

1.1.2.1   eric        1: /*                                                                  HTMemLog.c
                      2: **     MEMORY BUFFERED DATA LOGGING UTILITIES
                      3: **
                      4: **     (c) COPYRIGHT MIT 1996.
                      5: **     Please first read the full copyright statement in the file COPYRIGH.
1.1.2.2 ! eric        6: **     @(#) $Id: HTMemLog.c,v 1.1.2.1 1996/11/26 23:22:18 eric Exp $
1.1.2.1   eric        7: **
                      8: **      26 Nov 96 (EGP)        started
                      9: */
                     10: 
                     11: /* Library include files */
                     12: #include "sysdep.h"
                     13: #include "HTUtils.h"
                     14: #include "HTMemLog.h"
                     15: 
                     16: PRIVATE size_t LogBuffSize = 1024; /* default size is 1k */
                     17: PRIVATE int LogFile = 2;
                     18: PRIVATE const char * LogFileName = NULL;
                     19: PRIVATE char * LogBuff  = NULL;
                     20: PRIVATE size_t LogLen = 0;
                     21: 
                     22: PUBLIC int HTMemLog_open (const char *ident, const size_t size)
                     23: {
                     24: #ifdef USE_SYSLOG
                     25:     openlog(ident, LOG_NDELAY, LOG_USER);
                     26: #else /* USE_SYSLOG */
                     27:     LogFileName = ident;
                     28: #if 0
                     29:     if ((LogFile = open(ident, O_CREAT|O_TRUNC)) == -1)
                     30:        return HT_ERROR;
                     31:     close(LogFile);
                     32: #endif
                     33:     LogBuffSize = size;
                     34:     if ((LogBuff = (char *) HT_MALLOC(size)) == NULL)
                     35:        HT_OUTOFMEM("HTMemLog_open");
                     36:     LogLen = 0;
                     37: #endif /* !USE_SYSLOG */
                     38:     return HT_OK;
                     39: }
                     40: 
                     41: PRIVATE int HTMemLog_flush(void)
                     42: {
1.1.2.2 ! eric       43:     if ((LogFile = open(LogFileName, O_CREAT|O_APPEND)) == -1)
1.1.2.1   eric       44:        return HT_ERROR;
1.1.2.2 ! eric       45:     if (write(LogFile, LogBuff, LogLen) == -1) {
        !            46:        switch (errno) {
        !            47:        case EBADF: printf("EBADF\n"); break;
        !            48:        case EINVAL: printf("EINVAL\n"); break;
        !            49:        case EFAULT: printf("EFAULT\n"); break;
        !            50:        case EPIPE: printf("EPIPE\n"); break;
        !            51:        case EAGAIN: printf("EAGAIN\n"); break;
        !            52:        case EINTR: printf("EINTR\n"); break;
        !            53:        case ENOSPC: printf("ENOSPC\n"); break;
        !            54:        default: printf("default\n"); break;
        !            55:        }
        !            56:     }
1.1.2.1   eric       57:     LogLen = 0;
                     58:     close(LogFile);
                     59:     return HT_OK;
                     60: }
                     61: 
                     62: PUBLIC int HTMemLog_add(const char * buf, const size_t len)
                     63: {
                     64:     /*
                     65:     ** Dump everything that won't fit in buffer
                     66:     */
                     67:     while (len + LogLen > LogBuffSize) {
                     68:        size_t toWrite = LogBuffSize-LogLen;
                     69:        memcpy(LogBuff+LogLen, buf, toWrite);
                     70:        HTMemLog_flush();
                     71:        buf += toWrite;
                     72:        len -= toWrite;
                     73:     }
                     74:     memcpy(LogBuff+LogLen, buf, len);
                     75:     LogLen += len;
                     76:     return HT_OK;
                     77: }
                     78: 
                     79: PRIVATE int HTMemLog_adjustGMT(long theTime)
                     80: {
                     81:     static long adjustment = -1;
                     82:     if (adjustment == -1) {
                     83:         tzset();
                     84:         adjustment = timezone;
                     85:     }
                     86:     return theTime-adjustment;
                     87: }
                     88: 
                     89: PRIVATE int HTMemLog_addTime(void)
                     90: {
                     91:     char buff[20];
                     92:     int len;
                     93:     struct timeval tp;
                     94:     struct timezone tz = {300, DST_USA};
                     95: 
                     96:     gettimeofday(&tp, &tz);
                     97:     tp.tv_sec = HTMemLog_adjustGMT(tp.tv_sec)%(24*60*60);
                     98:     len = sprintf(buff, "%02d:%02d:%02d.%d ", tp.tv_sec/3600, (tp.tv_sec%3600)/60, tp.tv_sec%60, tp.tv_usec);
                     99:     HTMemLog_add(buff, len);
                    100:     return tp.tv_sec;
                    101: }
                    102: 
                    103: PUBLIC void HTMemLog_close (void)
                    104: {
                    105: #ifdef USE_SYSLOG
                    106:     closelog();
                    107: #else /* USE_SYSLOG */
                    108:     if (LogLen)
                    109:        HTMemLog_flush();
                    110:     if (LogFile > 2)
                    111:        close(LogFile);
                    112:     if (LogBuff != NULL)
                    113:        HT_FREE(LogBuff);
                    114: #endif /* !USE_SYSLOG */
                    115: }
                    116: 
                    117: PUBLIC int HTMemLog_callback (const char * data, const size_t len, const char * fmt, va_list pArgs)
                    118: {
                    119:     char buff[8200];
                    120:     int ret;
                    121:     ret = vsprintf(buff, fmt, pArgs);
                    122: #ifdef USE_SYSLOG
                    123:     syslog(LOG_DEBUG, "%s\n", buff);
                    124:     if (len > 8192)
                    125:        len = 8192;
                    126:     strncpy(buff, data, len);
                    127:     buff[len] = 0;
                    128:     syslog(LOG_DEBUG, "%s\n", buff);
                    129: #else /* USE_SYSLOG */
                    130:     /*
                    131:     time(&now);
                    132:     tptr = ctime(&now);
                    133:     HTMemLog_add(tptr, strlen(tptr));
                    134:     */
                    135:     HTMemLog_addTime();
                    136:     HTMemLog_add(buff, ret);
                    137:     HTMemLog_add("\n", 1);
                    138:     HTMemLog_add(data, len);
                    139: #endif /* !USE_SYSLOG */
                    140:     return ret;
                    141: }
                    142: