Return to HTMemLog.c CVS log

Up to [Public] / libwww / Library / src

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

2.1       frystyk     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.
2.5     ! eric        6: **     @(#) $Id: HTMemLog.c,v 2.4 1996/12/05 23:20:06 eric Exp $
2.1       frystyk     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: 
2.2       eric       16: PRIVATE size_t         LogBuffSize = 1024; /* default size is 1k */
                     17: PRIVATE int            LogFd = 2;
                     18: PRIVATE const char *   LogName = NULL;
                     19: PRIVATE char *         LogBuff  = NULL;
                     20: PRIVATE size_t         LogLen = 0;
                     21: PRIVATE BOOL           KeepOpen = YES;
2.1       frystyk    22: 
2.2       eric       23: PUBLIC int HTMemLog_open (const char * logName, const size_t size, BOOL keepOpen)
2.1       frystyk    24: {
                     25: #ifdef USE_SYSLOG
2.2       eric       26:     openlog(LogName, LOG_NDELAY, LOG_USER);
2.1       frystyk    27: #else /* USE_SYSLOG */
2.2       eric       28:     LogName = logName;
                     29:     KeepOpen = keepOpen;
                     30:     if ((LogFd = open(LogName, O_WRONLY|O_CREAT|O_TRUNC, 0666)) == -1)
2.1       frystyk    31:        return HT_ERROR;
2.2       eric       32:     if (!KeepOpen)
                     33:        close(LogFd);
2.1       frystyk    34:     LogBuffSize = size;
                     35:     if ((LogBuff = (char *) HT_MALLOC(size)) == NULL)
                     36:        HT_OUTOFMEM("HTMemLog_open");
                     37:     LogLen = 0;
                     38: #endif /* !USE_SYSLOG */
                     39:     return HT_OK;
                     40: }
                     41: 
2.4       eric       42: PUBLIC int HTMemLog_flush(void)
2.1       frystyk    43: {
2.4       eric       44:     if (LogLen) {
                     45:        if (!KeepOpen)
                     46:            if ((LogFd = open(LogName, O_WRONLY|O_CREAT|O_TRUNC, 0666)) == -1)
                     47:                return HT_ERROR;
                     48:        write(LogFd, LogBuff, LogLen);
                     49:        LogLen = 0;
                     50:     }
2.2       eric       51:     if (!KeepOpen)
                     52:        close(LogFd);
2.1       frystyk    53:     return HT_OK;
                     54: }
                     55: 
2.5     ! eric       56: PUBLIC int HTMemLog_add(char * buf, size_t len)
2.1       frystyk    57: {
2.3       frystyk    58:     if (LogBuff) {
                     59:        /*
                     60:        **      Dump everything that won't fit in buffer
                     61:        */
                     62:        while (len + LogLen > LogBuffSize) {
                     63:            size_t toWrite = LogBuffSize-LogLen;
                     64:            memcpy(LogBuff+LogLen, buf, toWrite);
                     65:            LogLen = LogBuffSize;       /* same as += toWrite */
                     66:            HTMemLog_flush();
                     67:            buf += toWrite;
                     68:            len -= toWrite;
                     69:        }
                     70:        memcpy(LogBuff+LogLen, buf, len);
                     71:        LogLen += len;
                     72:        return HT_OK;
2.1       frystyk    73:     }
2.3       frystyk    74:     return HT_ERROR;
2.1       frystyk    75: }
                     76: 
                     77: PRIVATE int HTMemLog_adjustGMT(long theTime)
                     78: {
                     79:     static long adjustment = -1;
                     80:     if (adjustment == -1) {
                     81:         tzset();
                     82:         adjustment = timezone;
                     83:     }
                     84:     return theTime-adjustment;
                     85: }
                     86: 
                     87: PRIVATE int HTMemLog_addTime(void)
                     88: {
                     89:     char buff[20];
                     90:     int len;
                     91:     struct timeval tp;
2.5     ! eric       92: #ifdef WWW_MSWINDOWS
        !            93:     return GetTickCount();
        !            94: #else /* WWW_MSWINDOWS */
2.1       frystyk    95:     struct timezone tz = {300, DST_USA};
                     96: 
                     97:     gettimeofday(&tp, &tz);
                     98:     tp.tv_sec = HTMemLog_adjustGMT(tp.tv_sec)%(24*60*60);
2.2       eric       99:     len = sprintf(buff, "%02d:%02d:%02d.%d", tp.tv_sec/3600, (tp.tv_sec%3600)/60, tp.tv_sec%60, tp.tv_usec);
2.1       frystyk   100:     HTMemLog_add(buff, len);
                    101:     return tp.tv_sec;
2.5     ! eric      102: #endif /* !WWW_MSWINDOWS */
2.1       frystyk   103: }
                    104: 
                    105: PUBLIC void HTMemLog_close (void)
                    106: {
                    107: #ifdef USE_SYSLOG
                    108:     closelog();
                    109: #else /* USE_SYSLOG */
2.4       eric      110:     HTMemLog_flush();
2.2       eric      111:     if (LogFd > 2)
                    112:        close(LogFd);
2.1       frystyk   113:     if (LogBuff != NULL)
                    114:        HT_FREE(LogBuff);
                    115: #endif /* !USE_SYSLOG */
                    116: }
                    117: 
2.2       eric      118: #ifdef USE_SYSLOG
                    119: #define PRINT_BUFF_SIZE        8200
                    120: #else /* USE_SYSLOG */
                    121: #define PRINT_BUFF_SIZE        200
                    122: #endif /* !USE_SYSLOG */
                    123: 
2.1       frystyk   124: PUBLIC int HTMemLog_callback (const char * data, const size_t len, const char * fmt, va_list pArgs)
                    125: {
2.2       eric      126:     char buff[PRINT_BUFF_SIZE];
2.1       frystyk   127:     int ret;
2.2       eric      128: #ifdef USE_SYSLOG
2.1       frystyk   129:     ret = vsprintf(buff, fmt, pArgs);
                    130:     syslog(LOG_DEBUG, "%s\n", buff);
                    131:     if (len > 8192)
                    132:        len = 8192;
                    133:     strncpy(buff, data, len);
                    134:     buff[len] = 0;
                    135:     syslog(LOG_DEBUG, "%s\n", buff);
                    136: #else /* USE_SYSLOG */
                    137:     HTMemLog_addTime();
2.2       eric      138: 
                    139:     ret = sprintf(buff, " %d ", len);
2.1       frystyk   140:     HTMemLog_add(buff, ret);
2.2       eric      141: 
                    142:     if (fmt) {
                    143:       ret = vsprintf(buff, fmt, pArgs);
                    144:       HTMemLog_add(buff, ret);
                    145:     }
2.1       frystyk   146:     HTMemLog_add("\n", 1);
2.2       eric      147: 
2.1       frystyk   148:     HTMemLog_add(data, len);
2.2       eric      149:     HTMemLog_add("\n", 1);
2.1       frystyk   150: #endif /* !USE_SYSLOG */
                    151:     return ret;
                    152: }
                    153: