---

logging.c

Go to the documentation of this file.

/*! \file logging.c
          This file implements the logging facility.
 */

#include "logging.h"

/*! \brief Maximum number of characters for a date.
 */

#define MAX_TIME_SIZE   512

/*! \brief Maximum size (in bytes) fir the log file.
    \remark 2147381248 bytes = 2Go - 100ko
 */

#define MAXLOGFILESIZE  2147381248

/*! \brief Maximum number of characters (including the final zero) for a MAC address written
           with ':' separators.
           Example: "00:11:22:33:44:55".
 */

#define MAC_ADDRESS_DOTED_SIZE 18

/*! \brief Maximum number of characters (including the final zero) for the gateway IP address.
 */

#define GATEWAY_IP_MAX_SIZE 16

/*! \brief Maximum number of characters (including the final zero) for a node ID.
 */

#define NODE_ID_MAX_SIZE 20

/*! \brief Current MAC address.
 */

static char current_mac_address[MAC_ADDRESS_DOTED_SIZE];

/*! \brief Current gateway.
 */

static char gateway[GATEWAY_IP_MAX_SIZE];

/*! \brief Current node ID.
 */

static char node_id[NODE_ID_MAX_SIZE];

/*! \brief Current shelf number.
 */

static unsigned long int shelf = 0;

/*! \brief Current slot number.
 */

static unsigned long int slot = 0;

/*! \brief Current port number.
 */

static unsigned long int port = 0;

/*! \brief Current VCI.
 */

unsigned short int vci = 0;

/*! \brief Current VLAN id.
 */

unsigned short int vlan_id = 0;

/*! \brief Numerical value of the current tag.
 */

static unsigned int current_tag = 0;

/*! \brief This flag defines if the server should manage the size of the log file.
 */

static int logsize = 0;

/*! \brief Activate the log size management.
 */

void activate_log_size_management() { logsize = 1; }

/*! \brief Maximum number of characters for the error message.
 */

#define ERROR_SIZE   2048

/*! \brief Last error for this module.
 */

static char last_error[ERROR_SIZE];

/*! \brief Return the last error message.
    \return The function returns a pointer to a statically alocated string of characters
            that represents the last error.
 */

char* logger_last_error() { return last_error; }

/*! \brief Set the last error message.
    \param error Pointer to a string that represents the last error message.
 */

static void logger_set_last_error (const char * fmt,...)
{
  va_list   list;

  memset ((void*)last_error, 0, ERROR_SIZE);
  va_start (list, fmt);
  vsnprintf (last_error, ERROR_SIZE - 1, fmt, list);
  va_end (list);
}

/*! \brief Clear the last error (set all zeros).
 */

static void clear_last_error()
{ memset ((void*)last_error, 0, ERROR_SIZE); }

/*! \brief Increment the value of the current tag.
    \author Denis BEURIVE
 */

void logging_new_tag()
{
  current_tag++;
  memset ((void*)current_mac_address, 0, MAC_ADDRESS_DOTED_SIZE);
  memset ((void*)node_id,             0, NODE_ID_MAX_SIZE);
  memset ((void*)gateway,             0, GATEWAY_IP_MAX_SIZE);

  snprintf (current_mac_address, MAC_ADDRESS_DOTED_SIZE, "--:--:--:--:--:--");
  snprintf (node_id,             NODE_ID_MAX_SIZE,       "--");
  snprintf (gateway,             GATEWAY_IP_MAX_SIZE,    "-.-.-.-");
  shelf   = 0;
  slot    = 0;
  port    = 0;
  vci     = 0;
  vlan_id = 0;
}

/*! \brief Initialize the client's identifier.
    \author Denis BEURIVE
    \param mac pointer to a zero terminated string of characters that represents the current MAC
           address.
    \param vnode_id Current node ID.
    \param vshelf Current shelf.
    \param vslot Current slot.
    \param vport Current port.
    \param vvci Current VCI.
    \param vvlan_id Current vlan_id.
 */

void init_client_ids (char*               mac,
                      char*               vnode_id,
                      unsigned long int   vshelf,
                      unsigned long int   vslot,
                      unsigned long int   vport,
                      unsigned short int  vvci,
                      unsigned short int  vvlan_id)
{
  strncpy (current_mac_address, mac,        MAC_ADDRESS_DOTED_SIZE-1);
  strncpy (node_id,             vnode_id,   NODE_ID_MAX_SIZE-1);
  strncpy (gateway,             "-.-.-.-",  GATEWAY_IP_MAX_SIZE-1);
  shelf   = vshelf;
  slot    = vslot;
  port    = vport;
  vci     = vvci;
  vlan_id = vvlan_id;
}

/*! \brief Initialize the logging system.
    \author Denis BEURIVE
 */

void init_syslogger()
{
  snprintf (current_mac_address, MAC_ADDRESS_DOTED_SIZE, "--:--:--:--:--:--");
  snprintf (node_id,             NODE_ID_MAX_SIZE,       "--");
  snprintf (gateway,             GATEWAY_IP_MAX_SIZE,    "-.-.-.-");
}

/*! \brief Return the current tag.
    \author Denis BEURIVE
    \return The function returns a pointer to a statically allocated,
            zero terminated string of characters that represents the current tag. 
 */

static char* log_tag()
{
  static char t[13];
  int         p;

  memset (t, 0, 13);
  snprintf (t, 13, "%12u", current_tag);
  for (p=0; p<13; p++) { if (t[p] == ' ') { t[p] = '0'; } }
  return t;
}

/*! \brief Return the current date as Apache's standard.
    \author Denis BEURIVE
    \return The function returns a pointer to a string of characters that contains the current date.
    \warning The string is returned in a statically allocated buffer, which subsequent calls
             will overwrite.
 */

char* dater()
{
  static char  strtime[MAX_TIME_SIZE];
  time_t       tt;

  tt = time(NULL);
  strftime (strtime, 256, "%Y-%m-%d %k:%M:%S", localtime(&tt));

  return strtime;
}

/*! \brief Return a timestamp usable for file name.
    \author Denis BEURIVE
    \return The function returns a timestamp that can be used for file names.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite.
 */

static char* filetimestamp()
{
  static char  strtime[MAX_TIME_SIZE];
  time_t       tt;

  tt = time(NULL);
  strftime (strtime, 256, "%Y%m%d-%k:%M:%S", localtime(&tt));

  return strtime;
}

/*! \brief Get the size of a given file (in bytes).
    \param file Path to the file.
    \return Upon successful completion, the function returns the size of the file (in bytes).
            The value 0 can mean that:
            <ul>
              <li>The file is empty.
              <li>The file does not exist.
            </ul>
            If an error occures, the function returns the value (unsigned long int)(-1).
 */

static unsigned long int get_file_size (const char *file)
{
  struct stat s;

  clear_last_error();

  if (stat(file, &s) == -1)
  {
    int e = errno;
    if (e == ENOENT) { return 0; }
    logger_set_last_error ("stat(%s) : %s (%s,%d)", file, strerror(e), __FILE__, __LINE__);
    return (unsigned long int)(-1);
  }

  return (unsigned long int)(s.st_size);
}

/*! \brief Log one line in a given log file.
    \author Denis BEURIVE
    \param file Pointer to a zero terminated string of characters that represents the path to the log file.
    \param ftm Pointer to a zero terminated string of characters that defines the output formats (same as printf()).
    \return Upon successful completion, the function returns the value 0. Otherwize, the function returns the value 1.
    \remark This function behaves just like the function printf().
 */

int my_syslog (const char *file, const char * fmt,...)
{
        va_list            list;
        static char        mbuf[4097];
        FILE               *fd;
        unsigned long int  filesize;
        int                ifd;

        memset ((void*)mbuf, 0, 4097);
        clear_last_error();

        va_start (list, fmt);
        vsnprintf (mbuf, (sizeof mbuf) - 1, fmt, list);
        va_end (list);

        /* ---------------------------------- */
        /* Check the size of the file         */
        /* Rename it if necessary             */
        /* ---------------------------------- */

        if (logsize)
        {
          filesize = get_file_size (file);
          if (filesize != (unsigned long int)(-1))
          {
            if (filesize > MAXLOGFILESIZE)
            {
              char newpath[256];
              memset((void*)newpath, 0, 256);
              snprintf (newpath, 256, "%s.%s", file, filetimestamp());
              if (rename (file, newpath) == -1)
              {
                int e = errno;
                logger_set_last_error ("rename(%s,%s) : %s (%s,%d)",
                                       file, newpath ,strerror(e), __FILE__, __LINE__);
                return 1;
              }
            }
          }
          else { return 1; }
        }

        ifd = open (file, O_CREAT | O_WRONLY | O_APPEND | O_LARGEFILE, S_IRWXU | S_IRWXG | S_IRWXO);
        if (ifd == -1)
        {
          int e = errno;
          logger_set_last_error ("open(%s) : %s (%s,%d)", file, strerror(e), __FILE__, __LINE__);
          return 1;
        }

        fd = fdopen (ifd, "a");
        if (fd == NULL)
        {
          int e = errno;
          logger_set_last_error ("fdopen(%d) : %s (%s,%d)", ifd, strerror(e), __FILE__, __LINE__);
          return 1;
        }

        fprintf (fd, "[%s] [%s] [%s/%lu/%lu/%lu/%d/%d/%s] %s %s\n",
                     log_tag(),
                     current_mac_address,
                     node_id,
                     shelf,
                     slot,
                     port,
                     vci,
                     vlan_id,
                     gateway,
                     dater(),
                     mbuf);

        fclose (fd);
        return 0;
}

/*! \brief Set the gateway for tag.
    \param g Pointer to a zero terminated string of characters that represents the gateway.
 */

void logger_set_gateway (const char *g)
{
  memset ((void*)gateway, 0, GATEWAY_IP_MAX_SIZE);
  strncpy (gateway, g, GATEWAY_IP_MAX_SIZE);
}

/*! \brief Log 2 empty lines in a given log file.
    \author Denis BEURIVE
    \param file Pointer to a zero terminated string of characters that represents the path to the log file.
    \return Upon successful completion, the function returns the value 0. Otherwize, the function returns the value 1.
 */

int my_syslog_skip_line (const char *file)
{
  FILE  *fd;
  int   ifd;

  clear_last_error(); 

  ifd = open (file, O_CREAT | O_WRONLY | O_APPEND | O_LARGEFILE, S_IRWXU | S_IRWXG | S_IRWXO);
  if (ifd == -1)
  {
     int e = errno;
     logger_set_last_error ("open(%s) : %s (%s,%d)", file, strerror(e), __FILE__, __LINE__);
     return 1;
  }

  fd = fdopen (ifd, "a");
  if (fd == NULL)
  {
     int e = errno;
     logger_set_last_error ("fdopen(%s) : %s (%s,%d)", file, strerror(e), __FILE__, __LINE__);
     return 1;
  }
 
  fprintf (fd, "\n\n");
  fclose (fd);
  return 0;
}

---