lcas_log.c

Go to the documentation of this file.

/*                                                                                                            
 * Copyright (c) Members of the EGEE Collaboration. 2004.
 * See http://eu-egee.org/partners/ for details on the copyright holders.
 * For license conditions see the license file or
 * http://eu-egee.org/license.html
 */

/*                                                                                                            
 * Copyright (c) 2001 EU DataGrid.                                                                             
 * For license conditions see http://www.eu-datagrid.org/license.html                                          
 *
 * Copyright (c) 2001, 2002 by 
 *     Martijn Steenbakkers <martijn@nikhef.nl>,
 *     David Groep <davidg@nikhef.nl>,
 *     NIKHEF Amsterdam, the Netherlands
 */

/*****************************************************************************
                            Include header files
******************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>
#include <syslog.h>
#include <time.h>
#include <ctype.h>
#include "_lcas_log.h"

/******************************************************************************
                          Module specific prototypes
******************************************************************************/
#ifndef DEBUG_LEVEL
#define DEBUG_LEVEL 0 
#endif /* DEBUG_LEVEL */

/******************************************************************************
                       Define module specific variables
******************************************************************************/
static FILE *  lcas_logfp=NULL; 
static int     logging_usrlog=0; 
static int     logging_syslog=0; 
static int     debug_level=0; 
static char *  extra_logstr = NULL; 
static int     should_close_lcas_logfp = 0; 
/******************************************************************************
Function:       lcas_log_open()
Description:    Start logging
Parameters:
                path:    path of logfile
                fp:      file pointer to already opened file (or NULL)
                logtype: DO_USRLOG, DO_SYSLOG
Returns:        0 succes
                1 failure
******************************************************************************/
int
lcas_log_open(char * path, FILE * fp, unsigned short logtype )
{
    char * debug_env = NULL;
    char * logstr_env = NULL;

    if ((logtype & DO_SYSLOG) == DO_SYSLOG)
    {
//        fprintf(stderr,"lcas_log_open() error: attempt to do syslogging,");
//        fprintf(stderr," not supported yet\n");
        logging_syslog=1;
#if 0
        /* Not yet applicable, wait for LCAS to become daemon */
        openlog("EDG LCAS", LOG_PID, LOG_DAEMON);
#endif
    }
    if ((logtype & DO_USRLOG) == DO_USRLOG)
    {
        logging_usrlog=1;
        if (fp != NULL)
        {
            /* File already opened */
            lcas_logfp=fp;
            should_close_lcas_logfp = 0;
        }
        else if (path != NULL)
        {
            /* Try to append to file */
            if ((lcas_logfp = fopen(path, "a")) == NULL)
            {
                fprintf(stderr, "lcas_log_open(): Cannot open logfile %s: %s\n",
                        path, sys_errlist[errno]);
                if (logging_syslog)
                {
                    syslog(LOG_ERR, "lcas_log_open(): Cannot open logfile %s\n", path);
                }
                return 1;
            }
        }
        else
        {
            fprintf(stderr, "lcas_log_open(): Please specify either (open) file descriptor");
            fprintf(stderr, " or name of logfile\n");
            return 1;
        }
    }
    /*
     * Set the debugging level:
     *    1. Try if DEBUG_LEVEL > 0
     *    2. Try if LCAS_DEBUG_LEVEL is set and if it is an integer
     *    3. set debug_level = 0;
     */
    if ( (int)(DEBUG_LEVEL) > 0 )
    {
        debug_level = (int)(DEBUG_LEVEL);
    }
    else if ( (debug_env = getenv("LCAS_DEBUG_LEVEL")) )
    {
        /* convert into integer */
        int j = 0;

        for (j = 0; j < strlen(debug_env); j++)
        {
            if (!isdigit((debug_env)[j]))
            {
                fprintf(stderr,"lcas_log_open(): found non-digit in environment variable in \"LCAS_DEBUG_LEVEL\" = %s\n", debug_env);
                return 1;
            }
        }
        debug_level = atoi(debug_env);
        if (debug_level < 0)
        {
            fprintf(stderr,"lcas_log_open(): environment variable in \"LCAS_DEBUG_LEVEL\" should be >= 0\n");
            return 1;
        }
    }
    else
    {
        debug_level = 0;
    }

    if (debug_level > 0)
    {
        lcas_log(0,"lcas_log_open(): setting debugging level to %d\n", debug_level);
    }

    /*
     * Check if there is an extra log string
     * These environment variables are checked: JOB_REPOSITORY_ID and GATEKEEPER_JM_ID
     */
    if ( (logstr_env = getenv("LCAS_LOG_STRING")) != NULL )
    {
        extra_logstr = strdup(logstr_env);
    }
    else if ( (logstr_env = getenv("JOB_REPOSITORY_ID")) != NULL )
    {
        extra_logstr = strdup(logstr_env);
    }
    else if ( (logstr_env = getenv("GATEKEEPER_JM_ID")) != NULL )
    {
        extra_logstr = strdup(logstr_env);
    }

    return 0;
}

/******************************************************************************
Function:       lcas_log()
Description:    Log information to file and or syslog
Parameters:
                prty:    syslog priority (if 0 don't syslog)
                fmt:     string format
Returns:        0 succes
                1 failure
******************************************************************************/
int
lcas_log(int prty, char * fmt, ...)
{
    va_list pvar;
    char    buf[MAX_LOG_BUFFER_SIZE];
    int     res;

    va_start(pvar, fmt);
    res=vsnprintf(buf,MAX_LOG_BUFFER_SIZE,fmt,pvar);
    va_end(pvar);
    if ( (res >= MAX_LOG_BUFFER_SIZE) || (res < 0) )
    {
        fprintf(stderr,"lcas_log(): log string too long (> %d)\n",
                MAX_LOG_BUFFER_SIZE);
    }
    if (logging_usrlog)
    {
        if (lcas_logfp == NULL)
        {
            fprintf(stderr,"lcas_log() error: cannot open file descriptor\n");
            return 1;
        }
        if (extra_logstr == NULL)
        {
            fprintf(lcas_logfp,"LCAS   %d: %s", prty, buf);
        }
        else
        {
            fprintf(lcas_logfp,"LCAS   %d: %s : %s", prty, extra_logstr, buf);
        }
        fflush(lcas_logfp);
    }
    if (logging_syslog && prty)
    {
        syslog(prty, buf);
    }

    return 0;
}

/******************************************************************************
Function:       lcas_log_a_string()
Description:    Log a string according to the passed format to file and or syslog
Parameters:
                prty:       syslog priority (if 0 don't syslog)
                fmt:        string format
                the_string: the string
Returns:        0 succes
                1 failure
******************************************************************************/
int
lcas_log_a_string(int prty, char * fmt, char * the_string)
{
    char    buf[MAX_LOG_BUFFER_SIZE];
    int     res;

    res = snprintf(buf, MAX_LOG_BUFFER_SIZE, fmt, the_string);
    if ( (res >= MAX_LOG_BUFFER_SIZE) || (res < 0) )
    {
        fprintf(stderr,"lcas_log_a_string(): log string too long (> %d)\n",
                MAX_LOG_BUFFER_SIZE);
    }
    if (logging_usrlog)
    {
        if (lcas_logfp == NULL)
        {
            fprintf(stderr,"lcas_log() error: cannot open file descriptor\n");
            return 1;
        }
        if (extra_logstr == NULL)
        {
            fprintf(lcas_logfp,"LCAS %d: %s", prty, buf);
        }
        else
        {
            fprintf(lcas_logfp,"LCAS %d: %s : %s", prty, extra_logstr, buf);
        }
        fflush(lcas_logfp);
    }
    if (logging_syslog && prty)
    {
        syslog(prty, buf);
    }

    return 0;
}

/******************************************************************************
Function:       lcas_log_debug()
Description:    Print debugging information
Parameters:
                debug_lvl: debugging level
                fmt:       string format
Returns:        0 succes
                1 failure
******************************************************************************/
int
lcas_log_debug(int debug_lvl, char * fmt, ...)
{
    va_list pvar;
    char    buf[MAX_LOG_BUFFER_SIZE];
    int     res;

    va_start(pvar, fmt);
    res=vsnprintf(buf,MAX_LOG_BUFFER_SIZE,fmt,pvar);
    va_end(pvar);
    if ( (res >= MAX_LOG_BUFFER_SIZE) || (res < 0) )
    {
        fprintf(stderr,"lcas_log(): log string too long (> %d)\n",
                MAX_LOG_BUFFER_SIZE);
    }
    if (debug_lvl <= debug_level)
    {
        lcas_log(0,buf);
        return 0;
    }
    return 1;
}

/******************************************************************************
Function:       lcas_log_a_string_debug()
Description:    Print debugging information
Parameters:
                debug_lvl:  debugging level
                fmt:        string format
                the_string: the string
Returns:        0 succes
                1 failure
******************************************************************************/
int
lcas_log_a_string_debug(int debug_lvl, char * fmt, char * the_string)
{
    if (debug_lvl <= debug_level)
    {
        lcas_log_a_string(0, fmt, the_string);
        return 0;
    }
    return 1;
}

/******************************************************************************
Function:       lcas_log_close()
Description:    Stop logging
Parameters:
Returns:        0 succes
                1 failure
******************************************************************************/
int
lcas_log_close()
{
    if (extra_logstr != NULL)
    {
        free(extra_logstr);
        extra_logstr = NULL;
    }

    if (should_close_lcas_logfp)
    {
        fclose(lcas_logfp);
        lcas_logfp=NULL;
    }

    return 0;
}

/******************************************************************************
Function:       lcas_log_time()
Description:    Log information to file and or syslog with a timestamp
Parameters:
                prty:    syslog priority (if 0 don't syslog)
                fmt:     string format
Returns:        0 succes
                1 failure
******************************************************************************/
int
lcas_log_time(int prty, char * fmt, ...)
{
    va_list     pvar;
    char        buf[MAX_LOG_BUFFER_SIZE];
    char *      datetime = NULL;
    char *      tmpbuf = NULL;
    int         res;
    time_t      clock;
    struct tm * tmp = NULL;


    va_start(pvar, fmt);
    res=vsnprintf(buf,MAX_LOG_BUFFER_SIZE,fmt,pvar);
    va_end(pvar);
    if ( (res >= MAX_LOG_BUFFER_SIZE) || (res < 0) )
    {
        fprintf(stderr,"lcas_log_time(): log string too long (> %d)\n",
                MAX_LOG_BUFFER_SIZE);
    }

    if (extra_logstr == NULL)
    {
        time(&clock);
        tmp = localtime(&clock);

        datetime = malloc(sizeof(char) * 20);

        res=snprintf(datetime, 20, "%04d-%02d-%02d.%02d:%02d:%02d",
               tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
               tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
        if ( (res >= 20) || (res < 0) )
        {
            fprintf(stderr,"lcas_log_time(): date string too long (> %d)\n",
                    20);
        }

        tmpbuf = (char *) malloc ((strlen(datetime) + strlen(buf) + strlen(" : ")) * sizeof(char) + 1);
        strcpy(tmpbuf, datetime);
        strcat(tmpbuf, " : ");
        strcat(tmpbuf, buf);
    }
    else
    {
        tmpbuf = (char *) malloc ((strlen(extra_logstr) + strlen(buf) + strlen(" : ")) * sizeof(char) + 1);
        strcpy(tmpbuf, extra_logstr);
        strcat(tmpbuf, " : ");
        strcat(tmpbuf, buf);
    }


    if (logging_usrlog)
    {
        if (lcas_logfp == NULL)
        {
            fprintf(stderr,"lcas_log_time() error: cannot open file descriptor\n");
            return 1;
        }
        fprintf(lcas_logfp,"LCAS   %d: %s",prty,tmpbuf);
        fflush(lcas_logfp);
    }
    if (logging_syslog && prty)
    {
        syslog(prty, tmpbuf);
    }

    if (datetime != NULL) free(datetime);
    if (tmpbuf != NULL) free(tmpbuf);

    return 0;
}


/******************************************************************************
Function:       lcas_get_debug_level()
Description:    Retrieve the debug_level
Parameters:
Returns:        the debug_level
******************************************************************************/
int
lcas_get_debug_level()
{
    return debug_level;
}

/******************************************************************************
CVS Information:
    $Source: /cvs/jra1mw/org.glite.security.lcas/src/lcas_log.c,v $
    $Date: 2005/04/04 15:23:57 $
    $Revision: 2.13 $
    $Author: msteenba $
******************************************************************************/

---