Logo Search packages:      
Sourcecode: tcpreen version File versions  Download package

log.cpp

/*
 * log.cpp - log files handling functions
 * $Id: log.cpp,v 1.3 2004/06/05 15:15:17 rdenisc Exp $
 */

/***********************************************************************
 *  Copyright (C) 2002-2004 Remi Denis-Courmont.                       *
 *  This program is free software; you can redistribute and/or modify  *
 *  it under the terms of the GNU General Public License as published  *
 *  by the Free Software Foundation; version 2 of the license.         *
 *                                                                     *
 *  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, you can get it from:              *
 *  http://www.gnu.org/copyleft/gpl.html                               *
 ***********************************************************************/

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include "secstdio.h"
#include <string.h>

#include "log.h"


/*** DataLog class implementation ***/
DataLog::~DataLog (void)
{
      if ((out != NULL) && close_out)
            fclose (out);
}


void
DataLog::Connect (const char *, const char *,
                  const char *, const char *)
{
}


int
DataLog::WriteServerData (const void *, int length, int)
{
      return length;
}


int
DataLog::WriteClientData (const void *, int length, int)
{
      return length;
}


void
DataLog::ShutdownServer (void)
{
}


void
DataLog::ShutdownClient (void)
{
}


/*** DataLogList implementation ***/
int
DataLogList::AddLog (DataLog *log)
{
      if (log == NULL)
            return -1;
      
      struct listnode *node;

      try
      {
            node = new listnode;
      }
      catch (...)
      {
            return -1;
      }

      node->log = log;
      node->next = head;
      head = node;
      return 0;
}


DataLogList::~DataLogList (void)
{
      for (struct listnode *node = head; node != NULL; node = head)
      {
            head = node->next;
            delete node->log;
            delete node;
      }
}


int
DataLogList::WriteServerData (const void *data, int length, int oob)
{
      for (struct listnode *node = head; node != NULL; node = node->next)
            if (node->log->WriteServerData (data, length, oob) != length)
                  return -1;

      return length;
}


int
DataLogList::WriteClientData (const void *data, int length, int oob)
{
      for (struct listnode *node = head; node != NULL; node = node->next)
            if (node->log->WriteClientData (data, length, oob) != length)
                  return -1;

      return length;
}


void
DataLogList::ShutdownServer (void)
{
      for (struct listnode *node = head; node != NULL; node = node->next)
            node->log->ShutdownServer ();
}


void
DataLogList::ShutdownClient (void)
{
      for (struct listnode *node = head; node != NULL; node = node->next)
            node->log->ShutdownClient ();
}


void
DataLogList::Connect (const char *server, const char *service,
                  const char *client, const char *port)
{
      for (struct listnode *node = head; node != NULL; node = node->next)
            node->log->Connect (server, service, client, port);
}


/*** DataLogListMaker implementation ***/
int
DataLogListMaker::AddLogMaker (DataLog *(*maker) (void), FILE *stream)
{
      struct listnode *node;

      try
      {
            node = new struct listnode;
      }
      catch (...)
      {
            return -1;
      }

      node->maker = maker;
      node->next = head;
      node->basename = NULL;
      node->stream = stream;
      head = node;
      return 0;
}


int
DataLogListMaker::AddLogMaker (DataLog *(*maker) (void), const char *prefix)
{
      struct listnode *node;

      try
      {
            node = new struct listnode;
      }
      catch (...)
      {
            return -1;
      }

      node->maker = maker;
      node->next = head;

      node->basename = strdup (prefix);
      if (node->basename == NULL)
      {
            delete node;
            return -1;
      }

      node->stream = NULL;
      head = node;
      return 0;
}


DataLogListMaker::~DataLogListMaker (void)
{
      for (struct listnode *node = head; node != NULL; node = head)
      {
            head = node->next;
            if (node->basename != NULL)
                  delete node->basename;
            delete node;
      }
}


DataLogList *
DataLogListMaker::MakeLogList (const char *addr, const char *port) const
{
      DataLogList *list;

      try
      {
            list = new DataLogList;
      }
      catch (...)
      {
            return NULL;
      }

      // Creates a log for each maker in the list
      for (struct listnode *node = head; node != NULL; node = node->next)
      {
            DataLog *log;

            try
            {
                  log = node->maker ();
            }
            catch (...)
            {
                  delete list;
                  return NULL;
            }

            if (log != NULL)
            {
                  // Adds a log in the list
                  if (list->AddLog (log))
                  {
                        delete log;
                        delete list;
                        return NULL;
                  }

                  // Attaches a stream to the new log
                  if (node->stream != NULL)
                        log->SetStream (node->stream, 0);
                  else
                  {     // Do we need more abstraction?
                        const char *prefix = node->basename;
                        if (prefix == NULL)
                              prefix = "";
                        if (addr == NULL)
                              addr = "";
                        if (port == NULL)
                              port = "";

                        char *filename;

                        int len = strlen (prefix) + strlen (addr)
                                    + strlen (port) + 3;

                        try
                        {
                              filename = new char[len];
                        }
                        catch (...)
                        {
                              delete list;
                              return NULL;
                        }
                        snprintf (filename, len, "%s-%s-%s",
                                    prefix, addr, port);

                        FILE *stream = secure_fopen (filename, "a");
                        delete filename;

                        if (stream == NULL)
                        {
                              delete list;
                              return NULL;
                        }
                        log->SetStream (stream);
                  }
            }
      }

      return list;
}

Generated by  Doxygen 1.6.0   Back to index