[libimdb-commit] CVS: libimdb/libjlog Makefile,NONE,1.1 jlog.c,NONE,1.1 jlog2File.c,NONE,1.1 jlogTra
Status: Pre-Alpha
Brought to you by:
jveldhuis
|
From: Jerry V. <jve...@us...> - 2003-06-16 04:18:48
|
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);
}
|