logging.c

Go to the documentation of this file.

/* **************************************************************
Copyright (C) 2010, 2011, 2012 Hewlett-Packard Development Company, L.P.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
************************************************************** */
/* local includes */
#include <event.h>
#include <logging.h>
#include <scheduler.h>

/* std library includes */
#define _GNU_SOURCE
#include <stdio.h>
#include <time.h>

/* unix includes */
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

/* glib includes */
#include <glib.h>

log_t* main_log = NULL;

/* ************************************************************************** */
/* **** local functions ***************************************************** */
/* ************************************************************************** */

typedef struct
{
    log_t* log;   
    gchar* msg;   
} log_event_args;

static void log_event(scheduler_t* scheduler, log_event_args* pass)
{
  lprintf(pass->log, "%s", pass->msg);
  g_free(pass->msg);
  g_free(pass);
}

/* ************************************************************************** */
/* **** logging functions *************************************************** */
/* ************************************************************************** */

log_t* log_new(gchar* log_name, gchar* pro_name, pid_t pro_pid)
{
  struct stat stats;
  log_t* ret = g_new0(log_t, 1);

  /* set the process name */
  if(pro_name == NULL)
    ret->pro_name = g_strdup(SCHE_PRONAME);
  else
    ret->pro_name = g_strdup(pro_name);
  ret->pro_pid = pro_pid;

  /* set the logs name */
  if(strcmp(log_name, "stderr") != 0 && strcmp(log_name, "stdout") != 0 &&
      (stat(log_name, &stats) == 0) && S_ISDIR(stats.st_mode))
    ret->log_name = g_strdup_printf("%s/fossology.log", log_name);
  else
    ret->log_name = g_strdup(log_name);

  /* open the log file */
  if     (strcmp(ret->log_name, "stderr") == 0) { ret->log_file = stderr; }
  else if(strcmp(ret->log_name, "stdout") == 0) { ret->log_file = stdout; }
  else { ret->log_file = fopen(ret->log_name, "a"); }

  /* make sure that everything is valid */
  if(ret->log_file == NULL)
  {
    ERROR("could not open log file \"%s\"", ret->log_name);
    g_free(ret->pro_name);
    g_free(ret->log_name);
    return NULL;
  }

  return ret;
}

log_t* log_new_FILE(FILE* log_file, gchar* log_name, gchar* pro_name, pid_t pro_pid)
{
  log_t* ret = g_new0(log_t, 1);

  if(pro_name == NULL)
    ret->pro_name = g_strdup(SCHE_PRONAME);
  else
    ret->pro_name = g_strdup(pro_name);
  ret->pro_pid = pro_pid;

  ret->log_name = g_strdup(log_name);
  ret->log_file = log_file;

  V_JOB("NEW_LOG: log_name: \"%s\", pro_name: \"%s\", pro_pid: %d, log_file: %p\n",
      ret->log_name, ret->pro_name, ret->pro_pid, ret->log_file);

  return ret;
}

void log_destroy(log_t* log)
{
  if(log->pro_name) g_free(log->pro_name);
  if(log->log_name) g_free(log->log_name);

  if(log->log_file && log->log_file != stdout && log->log_file != stderr)
    fclose(log->log_file);

  log->pro_name = NULL;
  log->log_name = NULL;

  if(log->log_file != stdout && log->log_file != stderr)
    log->log_file = NULL;

  g_free(log);
}

int lprintf(log_t* log, const char* fmt, ...)
{
  va_list args;
  int rc;

  if(!fmt) return 0;

  va_start(args, fmt);
  if(log == NULL || log->log_file == NULL)
  {
    rc = vlprintf(main_log, fmt, args);
  }
  else
  {
    rc = vlprintf(log, fmt, args);
  }
  va_end(args);

  return rc;
}

int vlprintf(log_t* log, const char* fmt, va_list args)
{
  /* static used to determine if a '\n' needs to be printed */
  static int n_line = 1;

  /* locals */
  time_t t = time(NULL);
  char* tmp, * curr;
  char time_buf[64];
  int e_line;

  if(!fmt) return 0;
  if(!log) return 0;

  strftime(time_buf, sizeof(time_buf),"%F %T",localtime(&t));

  tmp = g_strdup_vprintf(fmt, args);
  e_line = tmp[strlen(tmp) - 1] == '\n';
  curr = strtok(tmp, "\n");
  while(curr != NULL)
  {
    if(n_line && fprintf(log->log_file, "%s %s [%d] :: ", time_buf,
        log->pro_name, log->pro_pid) == 0)
      return 0;

    if(fprintf(log->log_file, "%s", curr) == 0)
      return 0;

    n_line = ((curr = strtok(NULL, "\n")) != NULL);
    if(n_line && fprintf(log->log_file, "\n") == 0)
        return 0;
  }

  if(e_line)
  {
    n_line = 1;
    if(fprintf(log->log_file, "\n") == 0)
      return 0;
  }

  fflush(log->log_file);
  g_free(tmp);
  return 1;
}

int clprintf(log_t* log, char* s_name, uint16_t s_line, const char* fmt, ...)
{
  va_list args;
  int ret = 1;
  log_event_args* pass;

  if(!fmt) return 0;
  if(!log) return 0;

  va_start(args, fmt);
  if(g_thread_self() != main_thread)
  {
    pass = g_new0(log_event_args, 1);
    pass->log = log;
    pass->msg = g_strdup_vprintf(fmt, args);
    event_signal_ext(log_event, pass, "log_event", s_name, s_line);
  }
  else
  {
    ret = vlprintf(log, fmt, args);
  }
  va_end(args);

  return ret;
}