--- a/src/request.c	Tue Dec 24 09:08:59 2002 +0000
+++ b/src/request.c	Fri Dec 27 21:48:25 2002 +0000
@@ -3,7 +3,7 @@
 
   Collection of articles that are marked for download.
 
-  $Id: request.c 381 2002-05-14 14:25:45Z mirkol $
+  $Id: request.c 413 2002-12-27 21:48:25Z bears $
 */
 
 #if HAVE_CONFIG_H
@@ -34,19 +34,19 @@
 typedef struct Reqserv Reqserv;
 
 struct Reqserv {
-  char*    serv;                /* Server the messages are to be requested
-                                   from */
-  char**   reql;                /* List of message IDs of requested
-                                   messages. Some entries (that have been
-                                   deleted) may be NULL */
-  int      reql_length;         /* Number of string pointers in reql,
-                                   including NULL entries */
-  int      reql_capacity;       /* maximum number of string pointers reql
-                                   can hold */
-  Bool     dirty;               /* whether the request list needs to be
-                                   rewritten to disk */
-  Reqserv* next;                /* next Reqserv in list */
-  time_t   mtime;               /* last modification time of request file */ 
+    char*    serv;                /* Server the messages are to be requested
+				     from */
+    char**   reql;                /* List of message IDs of requested
+				     messages. Some entries (that have been
+				     deleted) may be NULL */
+    int      reql_length;         /* Number of string pointers in reql,
+				     including NULL entries */
+    int      reql_capacity;       /* maximum number of string pointers reql
+				     can hold */
+    Bool     dirty;               /* whether the request list needs to be
+				     rewritten to disk */
+    Reqserv* next;                /* next Reqserv in list */
+    time_t   mtime;               /* last modification time of request file */ 
 };
 
 /* List of servers */
@@ -61,39 +61,46 @@
 
 
 /* local functions */
-static Reqserv* newReqserv      (const char* serv);
-static Bool     getReqserv      (const char* serv, Reqserv** rsz);
-static void     fileRequest     (Str file, const char *serv);
-static char**   searchMsgId     (const Reqserv * rs, const char *msgId);
-static Bool     storeMsgId      (Reqserv* rs, const char* msgId);
-static Bool     readRequestfile (const char* serv, Reqserv** rsz);
-static time_t   get_mtime       (const char* serv);
+static Reqserv* newReqserv      ( const char* serv );
+static Bool     getReqserv      ( const char* serv, Reqserv** rsz );
+static void     fileRequest     ( Str file, const char *serv );
+static char**   searchMsgId     ( const Reqserv * rs, const char *msgId );
+static Bool     storeMsgId      ( Reqserv* rs, const char* msgId );
+static Bool     readRequestfile ( const char* serv, Reqserv** rsz );
+static time_t   get_mtime       ( const char* serv );
 
 /* read modification time of request file */
-static time_t get_mtime(const char* serv)
+static time_t
+get_mtime( const char* serv )
 {
-  Str filename;
-  struct stat stat1;
+    Str filename;
+    struct stat stat1;
 
-  fileRequest(filename, serv);
-  stat(filename, &stat1);
-  return stat1.st_mtime;
+    fileRequest( filename, serv );
+    stat( filename, &stat1 );
+    return stat1.st_mtime;
 }
 
 
 /* create new Reqserv and queue it */
-static Reqserv* newReqserv(const char* serv)
+static Reqserv*
+newReqserv( const char* serv )
 {
-  Reqserv* rs = malloc(sizeof(Reqserv));
-  rs->serv = strcpy(malloc(strlen(serv)+1), serv);
-  rs->reql = 0;
-  rs->reql_length = 0;
-  rs->reql_capacity = 0;
-  rs->next = reqserv;
-  rs->dirty = FALSE;
-  rs->mtime = 0;
-  reqserv = rs;
-  return rs;
+    Reqserv *rs;
+
+    rs = malloc( sizeof( Reqserv ) );
+    if ( rs == NULL )
+	Log_fatal( "Malloc of Reqserv failed." );
+
+    Utl_allocAndCpy( &(rs->serv), serv );
+    rs->reql = 0;
+    rs->reql_length = 0;
+    rs->reql_capacity = 0;
+    rs->next = reqserv;
+    rs->dirty = FALSE;
+    rs->mtime = 0;
+    reqserv = rs;
+    return rs;
 }
 
 
@@ -101,15 +108,18 @@
    necessary. Return TRUE on success. Otherwise log errors and return
    FALSE. (details in errno)
 */
-static Bool getReqserv(const char* serv, Reqserv** rsz)
+static Bool
+getReqserv( const char* serv, Reqserv** rsz )
 {
-  Reqserv* rs;
-  for (rs = reqserv; rs; rs = rs->next)
-    if (!strcmp(serv, rs->serv)) {
-      *rsz = rs;
-      return TRUE;
-    }
-  return readRequestfile(serv, rsz);
+    Reqserv* rs;
+    
+    for ( rs = reqserv; rs; rs = rs->next )
+	if ( !strcmp( serv, rs->serv ) )
+	{
+	    *rsz = rs;
+	    return TRUE;
+	}
+    return readRequestfile( serv, rsz );
 }
 
 
@@ -117,94 +127,96 @@
 static void
 cleanupReqserv( void )
 {
-  Reqserv *rs, *prev, *next;
+    Reqserv *rs, *prev, *next;
 
-  rs = reqserv;
-  prev = NULL;
-  while ( rs != NULL )
-  {      
-      ASSERT( ! rs->dirty );
-      next = rs->next;
-      if ( get_mtime( rs->serv ) != rs->mtime )
-      {
-          if ( prev != NULL )
-              prev->next = next;
-          else
-              reqserv = next;
-          free( rs->serv );
-          rs->serv = NULL;
-          free( rs->reql );
-          rs->reql = NULL;
-          free( rs );
-      }
-      prev = rs;
-      rs = next;
-  }
+    rs = reqserv;
+    prev = NULL;
+    while ( rs != NULL )
+    {      
+	ASSERT( ! rs->dirty );
+	next = rs->next;
+	if ( get_mtime( rs->serv ) != rs->mtime )
+	{
+	    if ( prev != NULL )
+		prev->next = next;
+	    else
+		reqserv = next;
+	    free( rs->serv );
+	    rs->serv = NULL;
+	    free( rs->reql );
+	    rs->reql = NULL;
+	    free( rs );
+	}
+	prev = rs;
+	rs = next;
+    }
 }
 
 /* Save name of file storing requests from server "serv" in "file" */
-static void fileRequest( Str file, const char *serv)
+static void
+fileRequest( Str file, const char *serv )
 {
-  snprintf( file, MAXCHAR, "%s/requested/%s", Cfg_spoolDir(), serv);
+    snprintf( file, MAXCHAR, "%s/requested/%s", Cfg_spoolDir(), serv);
 }
 
 
 /* Search for msgid in Reqserv. Return pointer to list entry. Return 0 if
    list does not contain msgid. */
-static char** searchMsgId(const Reqserv * rs, const char *msgId )
+static char**
+searchMsgId( const Reqserv * rs, const char *msgId )
 {
-  char** rz;
-  ASSERT(rs != 0);
+    char** rz;
+    ASSERT( rs != 0 );
 
-  if (!rs->reql)
+    if ( !rs->reql )
+	return 0;
+
+    for ( rz = rs->reql; rz < rs->reql + rs->reql_length; rz++ )
+	if ( *rz && !strcmp( *rz, msgId ) )
+	    return rz;
+
     return 0;
-
-  for (rz = rs->reql; rz < rs->reql + rs->reql_length; rz++)
-    if (*rz && !strcmp(*rz, msgId))
-      return rz;
-
-  return 0;
 }
 
 
 Bool
-Req_contains(const char *serv, const char *msgId)
+Req_contains( const char *serv, const char *msgId )
 {
-  Reqserv* rs;
-  ASSERT( is_open );
-  if (getReqserv(serv, &rs) == FALSE) 
-    return FALSE;
-  return searchMsgId(rs, msgId) ? TRUE : FALSE;
+    Reqserv *rs;
+    ASSERT( is_open );
+    if (getReqserv( serv, &rs ) == FALSE) 
+	return FALSE;
+    return ( searchMsgId( rs, msgId ) != NULL );
 }
 
 
-static Bool storeMsgId(Reqserv* rs, const char* msgId)
+static Bool
+storeMsgId( Reqserv* rs, const char* msgId )
 {
-  char* msgid;
+    char *msgid;
 
-  if (searchMsgId(rs, msgId))
-    /* already recorded */
-    return FALSE;
+    if ( searchMsgId( rs, msgId ) )
+	/* already recorded */
+	return FALSE;
 
-  msgid = strcpy(malloc(strlen(msgId)+1), msgId);
+    Utl_allocAndCpy( &msgid, msgId );
 
-  if (rs->reql_length >= rs->reql_capacity) {
-    int c1 = rs->reql_capacity*2 + 10;
-    if ( ! ( rs->reql = (char**) realloc(rs->reql, c1*sizeof(char*) ) ) )
+    if ( rs->reql_length >= rs->reql_capacity )
     {
-               Log_err( "Could not realloc requests." );
-                exit( EXIT_FAILURE );
+	int c1 = rs->reql_capacity * 2 + 10;
+	rs->reql = ( char ** ) realloc( rs->reql, c1 * sizeof( char * ) );
+	if ( rs->reql == NULL )
+	    Log_fatal( "Could not realloc requests." );
+	rs->reql_capacity = c1;
     }
-    rs->reql_capacity = c1;
-  }
 
-  *(rs->reql + rs->reql_length++) = msgid;
-  rs->dirty = TRUE;
-  return TRUE;
+    *( rs->reql + rs->reql_length++ ) = msgid;
+    rs->dirty = TRUE;
+    return TRUE;
 }
 
 static Bool
-appRequest (Reqserv* rs, const char *msgId)
+appRequest( Reqserv* rs, const char *msgId )
 {
     Str filename;
     FILE*  file;
@@ -213,19 +225,19 @@
     Log_dbg( LOG_DBG_REQUESTS, "appending to request file %s", filename );
 
     if (Log_check((file = fopen(filename, "a")) != 0,
-            "could not open %s for appending: %s", 
-            filename, strerror(errno)))
-      return FALSE;
+		  "could not open %s for appending: %s", 
+		  filename, strerror(errno)))
+	return FALSE;
     
     if (Log_check(    fputs(msgId, file) != EOF
-                  &&  fputs("\n", file) != EOF,
-                  "write error: %s", strerror(errno)))
-      return FALSE;
+		      &&  fputs("\n", file) != EOF,
+		      "write error: %s", strerror(errno)))
+	return FALSE;
 
     if (Log_check(fclose(file) != EOF, 
-                "could not close %s properly: %s\n", 
-                filename, strerror(errno)))
-      return FALSE;
+		  "could not close %s properly: %s\n", 
+		  filename, strerror(errno)))
+	return FALSE;
 
     return TRUE;
 }
@@ -234,16 +246,17 @@
 /* Add request for message "msgIg" from server "serv". Return TRUE iff
    successful. 
 */
-Bool Req_add(const char *serv, const char *msgId)
+Bool
+Req_add( const char *serv, const char *msgId )
 {
     Reqserv* rs;
     ASSERT( is_open );
     Log_dbg( LOG_DBG_REQUESTS, "Marking %s on %s for download", msgId, serv );
 
-    if (getReqserv(serv, &rs) == FALSE) 
-      return FALSE;
-    if (storeMsgId(rs, msgId) == FALSE) /* already recorded */
-    return TRUE;
+    if ( ! getReqserv( serv, &rs ) ) 
+	return FALSE;
+    if ( ! storeMsgId(rs, msgId) ) /* already recorded */
+	return TRUE;
     return appRequest(rs, msgId);
 }
 
@@ -264,81 +277,86 @@
    "rsz" and return TRUE on success. Returns FALSE on failure, see errno.
    If the file doesn't exist, an empty Reqserv is returned.
 */
-static Bool readRequestfile(const char* serv, Reqserv** rsz)
+static Bool
+readRequestfile( const char* serv, Reqserv** rsz )
 {
-  Str           filename;
-  Str           line;
-  FILE*         file;
-  Reqserv*      rs;
+    Str           filename;
+    Str           line;
+    FILE*         file;
+    Reqserv*      rs;
+
+    fileRequest( filename, serv );
+    Log_dbg( LOG_DBG_REQUESTS, "reading request file %s", filename );
 
-  fileRequest(filename, serv);
-  Log_dbg( LOG_DBG_REQUESTS, "reading request file %s", filename );
+    file = fopen( filename, "r" );
+    if ( !file && ( errno == ENOENT ) )
+    {
+	*rsz = newReqserv( serv );
+	(*rsz)->mtime = get_mtime( serv );
+	return TRUE;
+    }
+    if ( Log_check( file != 0,
+		    "could not open %s for reading: %s", 
+		    filename, strerror( errno ) ) )
+	return FALSE;
+
+    rs = *rsz = newReqserv( serv );
 
-  file = fopen(filename, "r");
-  if (!file && (errno == ENOENT)) {
-    *rsz = newReqserv(serv);
-    (*rsz)->mtime = get_mtime(serv);
+    while( readLn( line, file ) )
+    {
+	char *line1 = Utl_stripWhiteSpace( line );
+	if ( *line1 )
+	    storeMsgId( rs, line1 );
+    }
+
+    rs->dirty = FALSE;
+
+    if ( Log_check( fclose( file ) != EOF, 
+		    "could not close %s properly: %s\n", 
+		    filename, strerror( errno ) ) )
+	return FALSE;
+
     return TRUE;
-  }
-  if (Log_check(file != 0,
-            "could not open %s for reading: %s", 
-            filename, strerror(errno)))
-    return FALSE;
-
-  rs = *rsz = newReqserv(serv);
-
-  while( readLn(line, file) == TRUE) {
-    char* line1 = Utl_stripWhiteSpace(line);
-    if (*line1)
-      storeMsgId(rs, line1);
-  }
-
-  rs->dirty = FALSE;
-
-  if (Log_check(fclose(file) != EOF, 
-            "could not close %s properly: %s\n", 
-            filename, strerror(errno)))
-    return FALSE;
-
-  return TRUE;
 }
 
 
 /* Write out request file for given Reqserv. Return TRUE on success. If an
    I/O error occurs, it is logged, and FALSE is returned.
 */
-static Bool writeRequestfile(Reqserv* rs)
+static Bool
+writeRequestfile( Reqserv* rs )
 {
-  Str    filename;
-  FILE*  file;
-  char** z;
+    Str    filename;
+    FILE*  file;
+    char** z;
 
-  fileRequest(filename, rs->serv);
-  Log_dbg( LOG_DBG_REQUESTS, "writing request file %s", filename );
+    fileRequest( filename, rs->serv );
+    Log_dbg( LOG_DBG_REQUESTS, "writing request file %s", filename );
 
-  if (Log_check((file = fopen(filename, "w")) != 0,
-            "could not open %s for writing: %s", 
-            filename, strerror(errno)))
-    return FALSE;
+    if ( Log_check( ( file = fopen( filename, "w" ) ) != 0,
+		   "could not open %s for writing: %s", 
+		   filename, strerror( errno ) ) )
+	return FALSE;
 
-  if (rs->reql)
-    for (z = rs->reql; z < rs->reql+rs->reql_length; z++)
-      if (*z) {
-        if (Log_check(   fputs(*z, file) != EOF
-                      && fputs("\n", file) != EOF,
-                  "write error: %s", strerror(errno)))
-          return FALSE;
-      }
+    if ( rs->reql )
+	for ( z = rs->reql; z < rs->reql+rs->reql_length; z++ )
+	    if ( *z )
+	    {
+		if ( Log_check( fputs( *z, file ) != EOF
+				&& fputs( "\n", file ) != EOF,
+				"write error: %s", strerror( errno ) ) )
+		    return FALSE;
+	    }
   
-  if (Log_check(fclose(file) != EOF, 
-                "could not close %s properly: %s\n", 
-                filename, strerror(errno)))
-    return FALSE;
+    if ( Log_check( fclose( file ) != EOF, 
+		    "could not close %s properly: %s\n", 
+		     filename, strerror( errno ) ) )
+	return FALSE;
             
-  rs->dirty = FALSE;
-  rs->mtime = get_mtime(rs->serv);
+    rs->dirty = FALSE;
+    rs->mtime = get_mtime( rs->serv );
 
-  return TRUE;
+    return TRUE;
 }
 
 
@@ -351,14 +369,14 @@
     ASSERT( is_open );
     Log_dbg( LOG_DBG_REQUESTS, "Req_remove(\"%s\", \"%s\")", serv, msgId );
     
-    if (getReqserv(serv, &rs) == FALSE) 
+    if ( !getReqserv(serv, &rs) ) 
         return;
     
-    z = searchMsgId(rs, msgId);
+    z = searchMsgId( rs, msgId );
     if ( ! z )
         return;
     
-    free(*z);
+    free( *z );
     *z = 0;
     rs->dirty = TRUE;
 }
@@ -367,45 +385,47 @@
 Bool
 Req_first( const char *serv, Str msgId )
 {
-  Reqserv* rs;
+    Reqserv* rs;
 
-  ASSERT( is_open );
-  ASSERT( !iterator && !iterator_end );
+    ASSERT( is_open );
+    ASSERT( !iterator && !iterator_end );
 
-  if (getReqserv(serv, &rs) == FALSE)
-    return FALSE;
+    if ( !getReqserv( serv, &rs ) )
+	return FALSE;
 
-  if (!rs->reql) 
-    return FALSE;
+    if ( !rs->reql ) 
+	return FALSE;
 
-  iterator = rs->reql - 1;
-  iterator_end = rs->reql + rs->reql_length;
+    iterator = rs->reql - 1;
+    iterator_end = rs->reql + rs->reql_length;
 
-  return Req_next(msgId);
+    return Req_next( msgId );
 }
 
 
 Bool
 Req_next( Str msgId )
 {
-  ASSERT( is_open );
-  ASSERT(iterator && iterator_end);
+    ASSERT( is_open );
+    ASSERT( iterator && iterator_end );
 
-  if (iterator >= iterator_end)
-      return FALSE;
-  iterator++;
+    if ( iterator >= iterator_end )
+	return FALSE;
+    iterator++;
 
-  while (iterator < iterator_end) {
-    if (!*iterator)
-      iterator++;
-    else {
-      Utl_cpyStr(msgId, *iterator);
-      return TRUE;
+    while ( iterator < iterator_end )
+    {
+	if ( !*iterator )
+	    iterator++;
+	else
+	{
+	    Utl_cpyStr( msgId, *iterator );
+	    return TRUE;
+	}
     }
-  }
 
-  iterator = iterator_end = 0;
-  return FALSE;
+    iterator = iterator_end = 0;
+    return FALSE;
 }
 
 
@@ -414,32 +434,36 @@
    changed recently, from cache. These files will be reread on demand.
 */
 Bool
-Req_open(void)
+Req_open( void )
 {
-  Log_dbg( LOG_DBG_REQUESTS, "opening request database" );
-  ASSERT(is_open == FALSE);
-  cleanupReqserv();
-  is_open = TRUE;
-  return TRUE;
+    Log_dbg( LOG_DBG_REQUESTS, "opening request database" );
+    ASSERT( !is_open );
+    
+    cleanupReqserv();
+    is_open = TRUE;
+    return TRUE;
 }
 
 
 /* Do not occupy the request files any longer. Write any changes to disk.
    Return TRUE on success, FALSE if an IO error occurs. */
-void Req_close(void) 
+void
+Req_close(void) 
 {
-  Bool ret = TRUE;
-  Reqserv* rs;
-  Log_dbg( LOG_DBG_REQUESTS,
-	   "closing request database, writing changes to disk" );
-  ASSERT(is_open == TRUE);
+    Bool ret = TRUE;
+    Reqserv* rs;
+    Log_dbg( LOG_DBG_REQUESTS,
+	     "closing request database, writing changes to disk" );
+    ASSERT( is_open );
 
-  for (rs = reqserv; rs; rs = rs->next) {
-    if (rs->dirty == TRUE) {
-      if (!writeRequestfile(rs))
-        ret = FALSE;
+    for ( rs = reqserv; rs; rs = rs->next )
+    {
+	if ( rs->dirty )
+	{
+	    if ( !writeRequestfile( rs ) )
+		ret = FALSE;
+	}
     }
-  }
 
-  is_open = FALSE;
+    is_open = FALSE;
 }