[libimdb-commit] CVS: libimdb/libjlog Makefile,NONE,1.1 jlog.c,NONE,1.1 jlog2File.c,NONE,1.1 jlogTracker.c,NONE,1.1

[Jerry V. <jve...@us...>]

Update of /cvsroot/libimdb/libimdb/libjlog
In directory sc8-pr-cvs1:/tmp/cvs-serv11812/libjlog

Added Files:
	Makefile jlog.c jlog2File.c jlogTracker.c 
Log Message:
initial checkin

--- NEW FILE: Makefile ---
#
# $Id: Makefile,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $
#
include ../config.mk
include ../constants.mk

CPPFLAGS += -I../include

LIB_BASE    = jlog
LIB_VERSION  = 1.2

build:
	$(MAKE) $(MYLIBRARY) LIBRARY=$(MYLIBRARY)
	$(MAKE) $(MYDYNAMIC) DYNAMIC=$(MYDYNAMIC) 

install:; @true;

include ../rules.mk

--- NEW FILE: jlog.c ---
/**
 * @file
 *
 * @todo should create test code to validate snprintf, and friends usage
 */

static char rcs_id[] = "$Id: jlog.c,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $";

#define _USE_STDIO
#define _USE_STDLIB
#define _USE_ERRNO
#define _USE_IO
#define _USE_ASSERT
#define _USE_STDARG
#define _USE_STRINGS
#define _USE_TYPES
#define _USE_MALLOC
#define _USE_LIMITS
#define _USE_TIME
[...1033 lines suppressed...]
    }
    else {
	mylogh=logh;
    }

    if ( mylogh->h_appendEnterExit[module] == 0 &&
	 mylogh->h_appendEnterExit[MOD_ALL] == 0 ) {
	return(0);
    }
    else {
	va_list args;
	int ret;

	va_start(args, srcfunc); 
	ret=jlog_enterReturn(mylogh, jlogReportLevel, module, IS_FAILURE, srcfile, srcline, srcfunc, args);
	va_end(args);
	return(ret);
    }
}


--- NEW FILE: jlog2File.c ---
/**
 * @file
 */

static char rcs_id[] = "$Id: jlog2File.c,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $";

#define _USE_STDIO
#define _USE_STDLIB
#define _USE_ERRNO
#define _USE_IO
#define _USE_ASSERT
#define _USE_STDARG
#define _USE_STRINGS
#define _USE_TYPES
#define _USE_MALLOC
#define _USE_LIMITS
#define _USE_TIME

#include "sysincludes.h"
#include "jlog/jlog.h"
#include "jlog/jlog2File.h"

struct jlog2File_s {
    char filename[MAXPATHLEN];
   
    /* for private use */
    time_t tval_s;
    char tim[100];
    
    int detailLevel;
    int fd;
    jlogCallbackHandle_t *cb;
    void *cb_userdata;
};

static void
jlog_eventCallback(jlogHandle_t *logh, const char *srcfile, const char *srcfunc,
		   int srcline, jlogModule_e module, jlogReportLevel_e jlogReportLevel,
		   int messageNumber, const char *messageText, void *cb_userdata)
{
    jlog2File_t *lt=cb_userdata;
    char buf[MAXJLOGMSGLEN+1];
    int buflen;
    char errstr[100];

    /* is enabled ? */
    if ( lt->fd == -1 ) {
	return;
    }

    switch(jlogReportLevel) {
    case JLOGT_CRITICAL:
	sprintf(errstr, "CRITICAL-%03d", messageNumber);
	break;
    case JLOGT_ERROR:
	sprintf(errstr, "ERROR-%03d", messageNumber);
	break;
    case JLOGT_DEBUG:
	sprintf(errstr, "DEBUG-%03d", messageNumber);
	break;
    }
	
    if ( lt->detailLevel == 0 ) {
	if ( (buflen=snprintf(buf, MAXJLOGMSGLEN, "%03d-%s: %s\n", module, errstr, messageText)) < 0 ||
	     buflen == MAXJLOGMSGLEN ) {
	    buf[MAXJLOGMSGLEN-1]='\0';
	    buflen=MAXJLOGMSGLEN-1;
	}
    }
    else {
	time_t tval;
	
	tval = time(NULL);
	if ( tval != lt->tval_s ) {
	    struct tm *tms=localtime(&tval);
	    strftime(lt->tim, 100, "%Y%m%d %H%M%S", tms);
	    lt->tval_s=tval;
	}
	
	if ( srcfunc != NULL ) {
	    if ( (buflen=snprintf(buf, MAXJLOGMSGLEN, "%d %s %s:%s:%4d: %03d-%s: %s\n", 
				  getpid(), lt->tim, srcfile, srcfunc, srcline, module, errstr, messageText)) < 0 ||
		 buflen == MAXJLOGMSGLEN ) {
		buf[MAXJLOGMSGLEN-1]='\0';
		buflen=MAXJLOGMSGLEN-1;
	    }
	}
	else {
	    if ( (buflen=snprintf(buf, MAXJLOGMSGLEN, "%d %s:%s:%4d: %03d-%s: %s\n", 
				  getpid(), lt->tim, srcfile, srcline, module, errstr, messageText)) < 0 ||
		 buflen == MAXJLOGMSGLEN ) {
		buf[MAXJLOGMSGLEN-1]='\0';
		buflen=MAXJLOGMSGLEN-1;
	    }
	}
    }
    /* one atomic write - not sure if this matters... really */
    write(lt->fd, buf, buflen);
    return;
}

jlog2File_t *
jlog2File_create(char *filename)
{
    jlog2File_t *lt;
    
    lt=malloc(sizeof(struct jlog2File_s));
    if ( lt == NULL ) {
	return(NULL);
    }
    assert(strlen(filename) < MAXPATHLEN);
    strcpy(lt->filename, filename);
    lt->tval_s=0;
    lt->tim[0]='\0';
    
    lt->cb=jlogCallback_create(jlog_eventCallback,lt);
    lt->detailLevel=0;
    lt->fd=-1;

    if ( jlog2File_enable(lt) != 0 ) {
	free(lt);
	return(NULL);
    }

    return(lt);
}

int
jlog2File_destroy(jlog2File_t *lt)
{
    jlog2File_disable(lt);
    free(lt);
    return(0);
}

int
jlog2File_enable(jlog2File_t *lt)
{
    if ( lt->fd == -1 ) {
	if ( strcmp(lt->filename, "-") == 0 ) {
	    lt->fd=1;
	}
	else {
	    lt->fd=open(lt->filename, O_CREAT|O_RDWR|O_APPEND, 0660);
	    if ( lt->fd == 0 ) {
		lt->fd=-1;
		return(-1);
	    }
	}
    }
    return(0);
}

int
jlog2File_disable(jlog2File_t *lt)
{
    if ( lt->fd != -1 ) {
	if ( lt->fd == 0 ) {
	    lt->fd=-1;
	    return(0);
	}
	else if( close(lt->fd) != 0 ) {
	    lt->fd=-1;
	    return(-1);
	}
	lt->fd=-1;
    }
    return(0);
}

char *
jlog2File_getFilename(jlog2File_t *lt)
{
    return(lt->filename);
}

jlogCallbackHandle_t *
jlog2File_getJLogCallbackHandle(jlog2File_t *lt)
{
    return(lt->cb);
}

--- NEW FILE: jlogTracker.c ---
/**
 * @file
 */

static char rcs_id[] = "$Id: jlogTracker.c,v 1.1 2003/06/16 04:18:38 jveldhuis Exp $";

#define _USE_STDIO
#define _USE_STDLIB
#define _USE_ERRNO
#define _USE_IO
#define _USE_ASSERT
#define _USE_STDARG
#define _USE_STRINGS
#define _USE_TYPES
#define _USE_MALLOC
#define _USE_LIMITS
#define _USE_TIME

#include "sysincludes.h"
#include "jlog/jlog.h"
#include "jlog/jlogTracker.h"


struct jlogTracker_s {
    struct messHead_s *head;	/**< message stack */
    
    jlogCallbackHandle_t *cb;
};

struct messNode_s {
    char *srcfile;
    char *srcfunc;
    int srcline;
    jlogModule_e module;
    jlogReportLevel_e reportLevel;
    int messageNumber;
    char *messageText;
    struct messNode_s *next;
};

struct messHead_s {
    int count;
    struct messNode_s *first;
};

static void
messbuf_destroyNode(struct messNode_s *node)
{
    if ( node->srcfile != NULL ) free(node->srcfile);
    if ( node->srcfunc != NULL ) free(node->srcfunc);
    if ( node->messageText != NULL ) free(node->messageText);
    free(node);
}

static struct messNode_s *
messbuf_createNode(const char *srcfile, const char *srcfunc,
		   int srcline, jlogModule_e module,
		   jlogReportLevel_e reportLevel,
		   int messageNumber,
		   const char *messageText)
{
    struct messNode_s *node;

    node=malloc(sizeof(struct messNode_s));
    if ( node == NULL ) {
	return(NULL);
    }
    node->srcfile=strdup(srcfile);
    node->srcfunc=strdup(srcfunc);
    node->srcline=srcline;
    node->module=module;
    node->reportLevel=reportLevel;
    node->messageNumber=messageNumber;
    node->messageText=strdup(messageText);
    node->next=NULL;

    if ( node->srcfile == NULL ||
	 node->srcfunc == NULL ||
	 node->messageText == NULL ) {
	messbuf_destroyNode(node);
	return(NULL);
    }
    return(node);
}

static int
messbuf_append(struct messHead_s *head, const char *srcfile, const char *srcfunc,
	       int srcline, jlogModule_e module, jlogReportLevel_e logReportLevel,
	       int messageNumber, const char *messageText)
{
    struct messNode_s *node;
    struct messNode_s *last;

    node=messbuf_createNode(srcfile, srcfunc,
			    srcline, module, logReportLevel,
			    messageNumber,
			    messageText);
    if ( node == NULL ) {
	return(-1);
    }
    if ( head->first == NULL ) {
	head->first=node;
	head->count=1;
	return(0);
    }
    for (last=head->first; last->next!=NULL ; last=last->next) {
	/* empty, just find end */
    }
    last->next=node;
    node->next=NULL;
    head->count++;
    return(0);
}

static struct messNode_s *
messbuf_getNode(const struct messHead_s *head, int messageIndex)
{
    struct messNode_s *last;
    int count=0;

    if ( head->first == NULL ) {
	return(NULL);
    }
    for (last=head->first; last->next!=NULL ; last=last->next) {
	char str[300];
	sprintf(str, "found %d, want %d", count, messageIndex);

	if ( count++ == messageIndex ) {
	    return(last);
	}
    }
    if ( count == messageIndex ) {
	return(last);
    }
    return(NULL);
}

static void
jlog_eventCallback(jlogHandle_t *logh, const char *srcfile, const char *srcfunc,
		   int srcline, jlogModule_e module, jlogReportLevel_e jlogReportLevel,
		   int messageNumber, const char *messageText, void *cb_userdata)
{
    jlogTracker_t *lt=cb_userdata;

    messbuf_append(lt->head, srcfile, srcfunc, srcline, module, jlogReportLevel,
		   messageNumber, messageText);
}

jlogTracker_t *
jlogTracker_create(void)
{
    jlogTracker_t *lt;
    
    lt=malloc(sizeof(struct jlogTracker_s));
    if ( lt == NULL ) {
	return(NULL);
    }
    lt->head=malloc(sizeof(struct messHead_s));
    lt->head->count=0;
    lt->head->first=NULL;

    lt->cb=jlogCallback_create(jlog_eventCallback, lt);
    return(lt);
}

/**
 * message buffer structure that helps manages a message stack
 */
void
jlogTracker_reset(jlogTracker_t *lt)
{
    struct messNode_s *node, *nextNode;

    for (node=lt->head->first ; node != NULL ; node=nextNode ) {
	nextNode=node->next;
	messbuf_destroyNode(node);
    }
    lt->head->first=NULL;
    lt->head->count=0;
}

/** get the number of message buffered
 */
int
jlogTracker_getCount(jlogTracker_t *lt)
{
    return(lt->head->count);
}

/** get message details of message.
 * messageIndex must between 0 to (log_getMessagesCount()-1)
 * @returns -1 upon error (out of range)
 * @returns 0 upon success
 */
int
jlogTracker_getMessageDetails(jlogTracker_t *lt,
			      int messageIndex,
			      char **srcfile,
			      char **srcfunc,
			      int *srcline,
			      jlogModule_e *module,
			      jlogReportLevel_e *reportLevel,
			      int *messageNumber,
			      char **messageText)
{
    struct messNode_s *node;

    node=messbuf_getNode(lt->head, messageIndex);
    if ( node == NULL ) {
	*srcfile="";
	*srcfunc="";
	*srcline=0;
	*module=0;
	*reportLevel=0;
	*messageNumber=0;
	*messageText="";
	return(-1);
    }
    
    *srcfile=node->srcfile;
    *srcfunc=node->srcfunc;
    *srcline=node->srcline;
    *module=node->module;
    *reportLevel=node->reportLevel;
    *messageNumber=node->messageNumber;
    *messageText=node->messageText;
    return(0);
}

jlogCallbackHandle_t *
jlogTracker_getJLogCallbackHandle(jlogTracker_t *lt)
{
    return(lt->cb);
}