shiplog.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */

 
#include "shiplog.h"
#include <inttypes.h>
 
/*Hold a single log entry - a double linked list*/
typedef struct {
   int     id;
   ntime_t time;
   char   *msg;
   void   *next;
   void   *prev;
} ShipLogEntry;
 
/* Holding global information about the log. */
typedef struct {
   int          *idList;
   char        **typeList;
   char        **nameList;
   ntime_t      *removeAfter;
   char        **idstrList;
   int          *maxLen;
   int           nlogs;
   ShipLogEntry *head; 
   ShipLogEntry *tail; 
} ShipLog;
 
static ShipLog shipLog; 
 
/*
 * Prototypes.
 */
static ShipLogEntry *shiplog_removeEntry( ShipLogEntry *e );

int shiplog_create( const char *idstr, const char *logname, const char *type,
                    int overwrite, int maxLen )
{
   ShipLogEntry *e;
   int           i, id, indx;
   indx = shipLog.nlogs;
 
   id = LOG_ID_INVALID;
   if (overwrite == 1) {
      /* check to see whether this idstr or logname and type has been created
       * before, and if so, remove all entries of that logid */
      if (idstr != NULL) {
         /* find the matching logid for this idstr */
         for (i = 0; i < shipLog.nlogs; i++) {
            if (( shipLog.idstrList[i] != NULL ) &&
                ( strcmp( shipLog.idstrList[i], idstr ) == 0 )) {
               /* matching idstr found. */
               id   = shipLog.idList[i];
               indx = i;
               break;
            }
         }
      } else {
         for (i = 0; i < shipLog.nlogs; i++) {
            if (( strcmp( type, shipLog.typeList[i] ) == 0 ) &&
                ( strcmp( logname, shipLog.nameList[i] ) == 0 )) {
               id   = shipLog.idList[i];
               indx = i;
               break;
            }
         }
      }
      if (i < shipLog.nlogs) { /* prev id found - so remove all log entries of
                                  this type. */
         e = shipLog.head;
         while (e != NULL) {
            if (e->id == id) {
               /* remove this entry */
               e = shiplog_removeEntry( e );
            } else {
               e = (ShipLogEntry *)e->next;
            }
         }
         shipLog.maxLen[i] = maxLen;
      }
   } else if (overwrite == 2) {
      /* check to see whether this type has been created before, and if so,
       * remove all entries. */
      int found = 0;
      id        = LOG_ID_INVALID;
      for (i = 0; i < shipLog.nlogs; i++) {
         if (( ( idstr != NULL ) && ( shipLog.idstrList[i] != NULL ) &&
               ( strcmp( idstr, shipLog.idstrList[i] ) == 0 ) ) ||
             ( ( idstr == NULL ) &&
               ( strcmp( type, shipLog.typeList[i] ) == 0 ) )) {
            e = shipLog.head;
            while (e != NULL) {
               if (e->id == shipLog.idList[i])
                  e = shiplog_removeEntry( e );
               else
                  e = e->next;
            }
            if (found == 0) { /* This is the first entry of this type */
               found = 1;
               id    = shipLog.idList[i];
               indx  = i;
               free( shipLog.nameList[i] );
               shipLog.nameList[i] = strdup( logname );
               shipLog.maxLen[i]   = maxLen;
            } else { /* a previous entry of this type as been found, so just
                        invalidate this logid. */
               shipLog.idList[i] = LOG_ID_INVALID;
               free( shipLog.idstrList[i] );
               shipLog.idstrList[i] = NULL;
            }
         }
      }
   }
 
   if (( indx == shipLog.nlogs ) && ( idstr != NULL )) {
      /* see if existing log with this idstr exists, if so, append to it */
      for (i = 0; i < shipLog.nlogs; i++) {
         if (( shipLog.idstrList[i] != NULL ) &&
             ( strcmp( idstr, shipLog.idstrList[i] ) == 0 )) {
            id                = shipLog.idList[i];
            indx              = i;
            shipLog.maxLen[i] = maxLen;
            break;
         }
      }
   }
   if (indx == shipLog.nlogs) {
      /* create a new id for this log */
      id = -1;
      for (i = 0; i < shipLog.nlogs; i++) { /* get maximum id */
         if (shipLog.idList[i] > id)
            id = shipLog.idList[i];
      }
      id++;
      shipLog.nlogs++;
      shipLog.idList = realloc( shipLog.idList, sizeof( int ) * shipLog.nlogs );
      shipLog.nameList =
         realloc( shipLog.nameList, sizeof( char * ) * shipLog.nlogs );
      shipLog.typeList =
         realloc( shipLog.typeList, sizeof( char * ) * shipLog.nlogs );
      shipLog.removeAfter =
         realloc( shipLog.removeAfter, sizeof( ntime_t ) * shipLog.nlogs );
      shipLog.idstrList =
         realloc( shipLog.idstrList, sizeof( char * ) * shipLog.nlogs );
      shipLog.maxLen = realloc( shipLog.maxLen, sizeof( int ) * shipLog.nlogs );
      shipLog.removeAfter[indx] = 0;
      shipLog.idList[indx]      = id;
      shipLog.nameList[indx]    = strdup( logname );
      shipLog.typeList[indx]    = strdup( type );
      shipLog.maxLen[indx]      = maxLen;
      shipLog.idstrList[indx]   = ( idstr == NULL ) ? NULL : strdup( idstr );
   }
   return id;
}

int shiplog_append( const char *idstr, const char *msg )
{
   int i, id;
   for (i = 0; i < shipLog.nlogs; i++) {
      if (( ( idstr == NULL ) && ( shipLog.idstrList[i] == NULL ) ) ||
          ( ( idstr != NULL ) && ( shipLog.idstrList[i] != NULL ) &&
            ( strcmp( idstr, shipLog.idstrList[i] ) == 0 ) )) {
         break;
      }
   }
   if (i == shipLog.nlogs) {
      WARN( _( "Warning - log not found: creating it" ) );
      id = shiplog_create(
         idstr, _( "Please report this log as an error to github.com/naev" ),
         idstr != NULL ? idstr : "", 0, 0 );
   } else {
      id = shipLog.idList[i];
   }
   return shiplog_appendByID( id, msg );
}

int shiplog_appendByID( int logid, const char *msg )
{
   ShipLogEntry *e;
   ntime_t       now = ntime_get();
   int           i, maxLen = 0;
 
   if (logid < 0)
      return -1;
 
   /* Check that the log hasn't already been added (e.g. if reloading) */
   e = shipLog.head;
   /* check for identical logs */
   while (e != NULL) {
      if (e->time != now) { /* logs are created in chronological order */
         break;
      }
      if (( logid == e->id ) && ( strcmp( e->msg, msg ) == 0 )) {
         /* Identical log already exists */
         return 0;
      }
      e = e->next;
   }
   if (( e = calloc( 1, sizeof( ShipLogEntry ) ) ) == NULL) {
      WARN( _( "Error creating new log entry - crash imminent!\n" ) );
      return -1;
   }
   e->next      = shipLog.head;
   shipLog.head = e;
   if (shipLog.tail == NULL) /* first entry - point to both head and tail.*/
      shipLog.tail = e;
   if (e->next != NULL)
      ( (ShipLogEntry *)e->next )->prev = (void *)e;
   e->id   = logid;
   e->msg  = strdup( msg );
   e->time = now;
   for (i = 0; i < shipLog.nlogs; i++) {
      if (shipLog.idList[i] == logid) {
         maxLen = shipLog.maxLen[i];
         break;
      }
   }
   if (maxLen > 0) {
      /* prune log entries if necessary */
      i = 0;
      e = shipLog.head;
      while (e != NULL) {
         if (e->id == logid) {
            i++;
            if (i > maxLen)
               e = shiplog_removeEntry( e );
            else
               e = (ShipLogEntry *)e->next;
         } else {
            e = (ShipLogEntry *)e->next;
         }
      }
   }
   return 0;
}

void shiplog_delete( int logid )
{
   ShipLogEntry *e, *tmp;
   int           i;
 
   if (( logid < 0 ) && ( logid != LOG_ID_ALL ))
      return;
 
   e = shipLog.head;
   while (e != NULL) {
      if (logid == LOG_ID_ALL || logid == e->id) {
         if (e->prev != NULL)
            ( (ShipLogEntry *)e->prev )->next = e->next;
         if (e->next != NULL)
            ( (ShipLogEntry *)e->next )->prev = e->prev;
         free( e->msg );
         if (e == shipLog.head)
            shipLog.head = e->next;
         if (e == shipLog.tail)
            shipLog.tail = e->prev;
         tmp = e;
         e   = (ShipLogEntry *)e->next;
         free( tmp );
      } else {
         e = (ShipLogEntry *)e->next;
      }
   }
 
   for (i = 0; i < shipLog.nlogs; i++) {
      if (logid == LOG_ID_ALL || logid == shipLog.idList[i]) {
         shipLog.idList[i] = LOG_ID_INVALID;
         free( shipLog.nameList[i] );
         shipLog.nameList[i] = NULL;
         free( shipLog.typeList[i] );
         shipLog.typeList[i] = NULL;
         free( shipLog.idstrList[i] );
         shipLog.idstrList[i]   = NULL;
         shipLog.maxLen[i]      = 0;
         shipLog.removeAfter[i] = 0;
      }
   }
}

void shiplog_setRemove( int logid, ntime_t when )
{
   int i;
   if (when == 0)
      when = ntime_get();
   else if (when < 0) /* add this to ntime */
      when = ntime_get() - when;
 
   for (i = 0; i < shipLog.nlogs; i++) {
      if (shipLog.idList[i] == logid) {
         shipLog.removeAfter[i] = when;
         break;
      }
   }
}

void shiplog_deleteType( const char *type )
{
   int i;
   if (type == NULL)
      return;
   for (i = 0; i < shipLog.nlogs; i++) {
      if (( shipLog.idList[i] >= 0 ) &&
          ( strcmp( type, shipLog.typeList[i] ) == 0 )) {
         shiplog_delete( shipLog.idList[i] );
      }
   }
}

void shiplog_clear( void )
{
   shiplog_delete( LOG_ID_ALL );
   free( shipLog.idList );
   free( shipLog.nameList );
   free( shipLog.typeList );
   free( shipLog.idstrList );
   free( shipLog.maxLen );
   free( shipLog.removeAfter );
   memset( &shipLog, 0, sizeof( ShipLog ) );
}

void shiplog_new( void )
{
   shiplog_clear();
}
 
/*
 * @brief Saves the logfiile
 */
int shiplog_save( xmlTextWriterPtr writer )
{
   int           i;
   ShipLogEntry *e;
   ntime_t       t = ntime_get();
   xmlw_startElem( writer, "shiplog" );
 
   for (i = 0; i < shipLog.nlogs; i++) {
      if (shipLog.removeAfter[i] > 0 && shipLog.removeAfter[i] < t)
         shiplog_delete( shipLog.idList[i] );
      if (shipLog.idList[i] >= 0) {
         xmlw_startElem( writer, "entry" );
         xmlw_attr( writer, "id", "%d", shipLog.idList[i] );
         xmlw_attr( writer, "t", "%s", shipLog.typeList[i] );
         if (shipLog.removeAfter[i] != 0)
            xmlw_attr( writer, "r", "%" PRIu64, shipLog.removeAfter[i] );
         if (shipLog.idstrList[i] != NULL)
            xmlw_attr( writer, "s", "%s", shipLog.idstrList[i] );
         if (shipLog.maxLen[i] != 0)
            xmlw_attr( writer, "m", "%d", shipLog.maxLen[i] );
         xmlw_str( writer, "%s", shipLog.nameList[i] );
         xmlw_endElem( writer ); /* entry */
      }
   }
   e = shipLog.head;
   while (e != NULL) {
      if (e->id >= 0) {
         xmlw_startElem( writer, "log" );
         xmlw_attr( writer, "id", "%d", e->id );
         xmlw_attr( writer, "t", "%" PRIu64, e->time );
         xmlw_str( writer, "%s", e->msg );
         xmlw_endElem( writer ); /* log */
      }
      e = (ShipLogEntry *)e->next;
   }
   xmlw_endElem( writer ); /* economy */
   return 0;
}

int shiplog_load( xmlNodePtr parent )
{
   xmlNodePtr    node, cur;
   ShipLogEntry *e;
   int           id, i;
   shiplog_clear();
 
   node = parent->xmlChildrenNode;
   do {
      if (xml_isNode( node, "shiplog" )) {
         cur = node->xmlChildrenNode;
         do {
            if (xml_isNode( cur, "entry" )) {
               xmlr_attr_int( cur, "id", id );
               /* check this ID isn't already present */
               for (i = 0; i < shipLog.nlogs; i++) {
                  if (shipLog.idList[i] == id)
                     break;
               }
               if (i == shipLog.nlogs) { /* a new ID */
                  shipLog.nlogs++;
                  shipLog.idList =
                     realloc( shipLog.idList, sizeof( int ) * shipLog.nlogs );
                  shipLog.nameList = realloc(
                     shipLog.nameList, sizeof( char * ) * shipLog.nlogs );
                  shipLog.typeList = realloc(
                     shipLog.typeList, sizeof( char * ) * shipLog.nlogs );
                  shipLog.removeAfter = realloc(
                     shipLog.removeAfter, sizeof( ntime_t ) * shipLog.nlogs );
                  shipLog.idstrList = realloc(
                     shipLog.idstrList, sizeof( char * ) * shipLog.nlogs );
                  shipLog.maxLen =
                     realloc( shipLog.maxLen, sizeof( int ) * shipLog.nlogs );
                  shipLog.idList[shipLog.nlogs - 1] = id;
                  xmlr_attr_strd( cur, "t",
                                  shipLog.typeList[shipLog.nlogs - 1] );
                  xmlr_attr_long( cur, "r",
                                  shipLog.removeAfter[shipLog.nlogs - 1] );
                  xmlr_attr_strd( cur, "s",
                                  shipLog.idstrList[shipLog.nlogs - 1] );
                  xmlr_attr_int( cur, "m", shipLog.maxLen[shipLog.nlogs - 1] );
                  if (shipLog.typeList[shipLog.nlogs - 1] == NULL) {
                     shipLog.typeList[shipLog.nlogs - 1] = strdup( "No type" );
                     WARN( _( "No ID in shipLog entry" ) );
                  }
                  shipLog.nameList[shipLog.nlogs - 1] =
                     strdup( xml_raw( cur ) );
               }
            } else if (xml_isNode( cur, "log" )) {
               e = calloc( 1, sizeof( ShipLogEntry ) );
               /* put this one at the end */
               e->prev = shipLog.tail;
               if (shipLog.tail == NULL)
                  shipLog.head = e;
               else
                  shipLog.tail->next = e;
               shipLog.tail = e;
 
               xmlr_attr_int( cur, "id", e->id );
               xmlr_attr_long( cur, "t", e->time );
               e->msg = strdup( xml_raw( cur ) );
            }
         } while (xml_nextNode( cur ));
      }
   } while (xml_nextNode( node ));
   return 0;
}
 
void shiplog_listTypes( int *ntypes, char ***logTypes, int includeAll )
{
   int     i, j, n = 0;
   char  **types = NULL;
   ntime_t t     = ntime_get();
 
   if (includeAll) {
      types    = malloc( sizeof( char * ) );
      n        = 1;
      types[0] = strdup( _( "All" ) );
   }
   for (i = 0; i < shipLog.nlogs; i++) {
      if (shipLog.removeAfter[i] > 0 && shipLog.removeAfter[i] < t) {
         /* log expired, so remove (which sets id to LOG_ID_INVALID) */
         shiplog_delete( shipLog.idList[i] );
      }
      if (shipLog.idList[i] >= 0) {
         /* log valid */
         for (j = 0; j < n; j++) {
            if (strcmp( shipLog.typeList[i], types[j] ) == 0)
               break;
         }
         if (j == n) { /*This log type not found, so add.*/
            n++;
            types        = realloc( types, sizeof( char * ) * n );
            types[n - 1] = strdup( shipLog.typeList[i] );
         }
      }
   }
   *ntypes   = n;
   *logTypes = types;
}

void shiplog_listLogsOfType( const char *type, int *nlogs, char ***logsOut,
                             int **logIDs, int includeAll )
{
   int     i, n;
   char  **logs;
   int    *logid;
   ntime_t t = ntime_get();
 
   n     = !!includeAll;
   logs  = realloc( *logsOut, sizeof( char * ) * n );
   logid = realloc( *logIDs, sizeof( int ) * n );
   if (includeAll) {
      logs[0]  = strdup( _( "All" ) );
      logid[0] = LOG_ID_ALL;
   }
   if (shipLog.nlogs > 0) {
      for (i = shipLog.nlogs - 1; i >= 0; i--) {
         if (shipLog.removeAfter[i] > 0 && shipLog.removeAfter[i] < t) {
            /* log expired, so remove (which sets id to LOG_ID_INVALID) */
            shiplog_delete( shipLog.idList[i] );
         }
         if (( shipLog.idList[i] >= 0 ) &&
             ( ( type == NULL ) ||
               ( strcmp( type, shipLog.typeList[i] ) == 0 ) )) {
            n++;
            logs         = realloc( logs, sizeof( char * ) * n );
            logs[n - 1]  = strdup( shipLog.nameList[i] );
            logid        = realloc( logid, sizeof( int ) * n );
            logid[n - 1] = shipLog.idList[i];
         }
      }
   }
   *nlogs   = n;
   *logsOut = logs;
   *logIDs  = logid;
}
 
int shiplog_getIdOfLogOfType( const char *type, int selectedLog )
{
   int     i, n = 0;
   ntime_t t = ntime_get();
 
   for (i = shipLog.nlogs - 1; i >= 0; i--) {
      if (( shipLog.removeAfter[i] > 0 ) && ( shipLog.removeAfter[i] < t )) {
         /* log expired, so remove (which sets id to -1) */
         shiplog_delete( shipLog.idList[i] );
      }
      if (( shipLog.idList[i] >= 0 ) &&
          ( ( type == NULL ) ||
            ( strcmp( type, shipLog.typeList[i] ) == 0 ) )) {
         if (n == selectedLog)
            break;
         n++;
      }
   }
   if (i >= 0)
      i = shipLog.idList[i];
   return i; /* -1 if not found */
}

static ShipLogEntry *shiplog_removeEntry( ShipLogEntry *e )
{
   ShipLogEntry *tmp;
   /* remove this entry */
   if (e->prev != NULL)
      ( (ShipLogEntry *)e->prev )->next = e->next;
   if (e->next != NULL)
      ( (ShipLogEntry *)e->next )->prev = e->prev;
   if (shipLog.head == e)
      shipLog.head = e->next;
   if (shipLog.tail == e)
      shipLog.tail = e->prev;
   free( e->msg );
   tmp = e;
   e   = (ShipLogEntry *)e->next;
   free( tmp );
   return e;
}

void shiplog_listLog( int logid, const char *type, int *nentries,
                      char ***logentries, int incempty )
{
   int           i, n = 0, all = 0;
   char        **entries = NULL;
   ShipLogEntry *e, *use;
   char          buf[5000];
   int           pos;
   e = shipLog.head;
   if (logid == LOG_ID_ALL) {
      all = 1;
   }
   while (e != NULL) {
      use = NULL;
      if (logid == LOG_ID_ALL) {
         if (all) { /* add the log */
            if (e->id >= 0)
               use = e;
         } else { /* see if this log is of type */
            for (i = 0; i < shipLog.nlogs; i++) {
               if (( shipLog.idList[i] >= 0 ) &&
                   ( e->id == shipLog.idList[i] ) &&
                   ( strcmp( shipLog.typeList[i], type ) == 0 )) {
                  /* the type matches current messages */
                  use = e;
                  break; /* there should only be 1 log of this type and id. */
               }
            }
         }
      } else { /* just this particular log*/
         if (e->id == logid) {
            use = e;
         }
      }
      if (use != NULL) {
         n++;
         entries = realloc( entries, sizeof( char * ) * n );
         ntime_prettyBuf( buf, sizeof( buf ), use->time, 2 );
         pos = strlen( buf );
         pos += scnprintf( &buf[pos], sizeof( buf ) - pos, ":  %s", use->msg );
         entries[n - 1] = strdup( buf );
      }
 
      e = e->next;
   }
   (void)pos;
   if (( n == 0 ) && ( incempty != 0 )) {
      /*empty list, so add "Empty" */
      n          = 1;
      entries    = realloc( entries, sizeof( char * ) );
      entries[0] = strdup( _( "Empty" ) );
   }
   *logentries = entries;
   *nentries   = n;
}

int shiplog_getID( const char *idstr )
{
   int id = -1;
   int i;
   for (i = 0; i < shipLog.nlogs; i++) {
      if (( ( shipLog.idstrList[i] == NULL ) && ( idstr == NULL ) ) ||
          ( ( shipLog.idstrList[i] != NULL ) && ( idstr != NULL ) &&
            ( strcmp( idstr, shipLog.idstrList[i] ) == 0 ) )) {
         id = shipLog.idList[i];
         break;
      }
   }
   return id;
}