Updated from latest NewPG project
[gnupg.git] / util / logger.c
index 9c1b86b..6990473 100644 (file)
@@ -1,14 +1,14 @@
 /* logger.c  - log functions
- *     Copyright (c) 1997 by Werner Koch (dd9jn)
+ *     Copyright (C) 1998, 1999 Free Software Foundation, Inc.
  *
- * This file is part of G10.
+ * This file is part of GnuPG.
  *
- * G10 is free software; you can redistribute it and/or modify
+ * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
- * G10 is distributed in the hope that it will be useful,
+ * GnuPG 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.
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
+#include <string.h>
+#include <errno.h>
 
 #include "util.h"
+#include "i18n.h"
 
 static char pidstring[15];
+static char *pgm_name;
+static int errorcount;
+static int strict;
+static FILE *logfp;
+
+/****************
+ * Set the logfile to use (not yet implemneted) or, if logfile is NULL,
+ * the Fd where logoutputs should go.
+ */
+void
+log_set_logfile( const char *name, int fd )
+{
+    if( name )
+       BUG();
+
+    if( logfp && logfp != stderr && logfp != stdout )
+       fclose( logfp );
+    if( fd == 1 )
+       logfp = stdout;
+    else if( fd == 2 )
+       logfp = stderr;
+    else
+       logfp = fdopen( fd, "a" );
+    if( !logfp ) {
+       logfp = stderr;
+       log_fatal("can't open fd %d for logging: %s\n", fd, strerror(errno));
+    }
+}
+
+FILE *
+log_stream()
+{
+    if( !logfp )
+       logfp = stderr;
+    return logfp;
+}
 
 
 void
-set_log_pid( int pid )
+log_set_name( const char *name )
+{
+    m_free(pgm_name);
+    if( name )
+       pgm_name = m_strdup(name);
+    else
+       pgm_name = NULL;
+}
+
+const char *
+log_get_name(void)
+{
+    return pgm_name? pgm_name : "";
+}
+
+
+void
+log_set_pid( int pid )
 {
     if( pid )
        sprintf(pidstring,"[%u]", (unsigned)pid );
@@ -37,116 +93,242 @@ set_log_pid( int pid )
        *pidstring = 0;
 }
 
+int
+log_get_errorcount( int clear)
+{
+    int n = errorcount;
+    if( clear )
+       errorcount = 0;
+    return n;
+}
+
+void
+log_inc_errorcount()
+{
+    errorcount++;
+}
+
+int
+log_set_strict(int val)
+{
+  int old=strict;
+  strict=val;
+  return old;
+}
 
-/****************
- * General interface for printing a line
- * level 0 := print to /dev/null
- *      1 := print to stdout
- *      2 := print as info to stderr
- *      3 := ditto but as error
- */
 void
-printstr( int level, const char *fmt, ... )
+g10_log_print_prefix(const char *text)
+{
+    if( !logfp )
+       logfp = stderr;
+    if( pgm_name )
+       fprintf(logfp, "%s%s: %s", pgm_name, pidstring, text );
+    else
+       fprintf(logfp, "?%s: %s", pidstring, text );
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
+}
+
+static void
+print_prefix_f(const char *text, const char *fname)
+{
+    if( !logfp )
+       logfp = stderr;
+    if( pgm_name )
+       fprintf(logfp, "%s%s:%s: %s", pgm_name, pidstring, fname, text );
+    else
+       fprintf(logfp, "?%s:%s: %s", pidstring, fname, text );
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
+}
+
+void
+g10_log_info( const char *fmt, ... )
 {
     va_list arg_ptr ;
 
-    if( !level )
-       return;
+    g10_log_print_prefix("");
+    va_start( arg_ptr, fmt ) ;
+    vfprintf(logfp,fmt,arg_ptr) ;
+    va_end(arg_ptr);
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
+}
 
-    if( !fmt ) {
-       putc('\n', level? stderr: stdout);
-       return;
-    }
+void
+g10_log_info_f( const char *fname, const char *fmt, ... )
+{
+    va_list arg_ptr ;
 
+    print_prefix_f("", fname);
     va_start( arg_ptr, fmt ) ;
-    if( level < 2 ) {
-       vfprintf(stdout,fmt,arg_ptr) ;
-    }
-    else {
-       fprintf(stderr, level==2? "%s: ": "%s: error: ", strusage(13) ) ;
-       vfprintf(stderr,fmt,arg_ptr) ;
-    }
+    vfprintf(logfp,fmt,arg_ptr) ;
     va_end(arg_ptr);
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
+}
+
+void
+g10_log_warning( const char *fmt, ... )
+{
+    va_list arg_ptr ;
+
+    if(strict)
+      {
+       errorcount++;
+       g10_log_print_prefix(_("ERROR: "));
+      }
+    else
+      g10_log_print_prefix(_("WARNING: "));
+
+    va_start( arg_ptr, fmt ) ;
+    vfprintf(logfp,fmt,arg_ptr) ;
+    va_end(arg_ptr);
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
 }
 
 
 void
-log_info( const char *fmt, ... )
+g10_log_error( const char *fmt, ... )
 {
     va_list arg_ptr ;
 
-    fprintf(stderr, "info%s: ", pidstring ) ;
+    g10_log_print_prefix("");
     va_start( arg_ptr, fmt ) ;
-    vfprintf(stderr,fmt,arg_ptr) ;
+    vfprintf(logfp,fmt,arg_ptr) ;
     va_end(arg_ptr);
+    errorcount++;
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
 }
 
 void
-log_error( const char *fmt, ... )
+g10_log_error_f( const char *fname, const char *fmt, ... )
 {
     va_list arg_ptr ;
 
-    fprintf(stderr, "error%s: ", pidstring  ) ;
+    print_prefix_f("", fname);
     va_start( arg_ptr, fmt ) ;
-    vfprintf(stderr,fmt,arg_ptr) ;
+    vfprintf(logfp,fmt,arg_ptr) ;
     va_end(arg_ptr);
+    errorcount++;
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
 }
 
 void
-log_fatal( const char *fmt, ... )
+g10_log_fatal( const char *fmt, ... )
 {
     va_list arg_ptr ;
 
-    fprintf(stderr, "Fatal%s: ", pidstring  ) ;
+    g10_log_print_prefix("fatal: ");
     va_start( arg_ptr, fmt ) ;
-    vfprintf(stderr,fmt,arg_ptr) ;
+    vfprintf(logfp,fmt,arg_ptr) ;
     va_end(arg_ptr);
+    secmem_dump_stats();
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
     exit(2);
 }
 
 void
-log_bug( const char *fmt, ... )
+g10_log_fatal_f( const char *fname, const char *fmt, ... )
 {
     va_list arg_ptr ;
 
-    fprintf(stderr, "\nInternal Error%s: ", pidstring  ) ;
+    print_prefix_f("fatal: ", fname);
+    va_start( arg_ptr, fmt ) ;
+    vfprintf(logfp,fmt,arg_ptr) ;
+    va_end(arg_ptr);
+    secmem_dump_stats();
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
+    exit(2);
+}
+
+void
+g10_log_bug( const char *fmt, ... )
+{
+    va_list arg_ptr ;
+
+    putc('\n', stderr );
+    g10_log_print_prefix("Ohhhh jeeee: ");
     va_start( arg_ptr, fmt ) ;
     vfprintf(stderr,fmt,arg_ptr) ;
     va_end(arg_ptr);
     fflush(stderr);
+    secmem_dump_stats();
     abort();
 }
 
+#if defined (__riscos__) \
+    || ( __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
+void
+g10_log_bug0( const char *file, int line, const char *func )
+{
+    log_bug(_("... this is a bug (%s:%d:%s)\n"), file, line, func );
+}
+#else
 void
-log_debug( const char *fmt, ... )
+g10_log_bug0( const char *file, int line )
+{
+    log_bug(_("you found a bug ... (%s:%d)\n"), file, line);
+}
+#endif
+
+void
+g10_log_debug( const char *fmt, ... )
 {
     va_list arg_ptr ;
 
-    fprintf(stderr, "DBG%s: ", pidstring  ) ;
+    g10_log_print_prefix("DBG: ");
     va_start( arg_ptr, fmt ) ;
-    vfprintf(stderr,fmt,arg_ptr) ;
+    vfprintf(logfp,fmt,arg_ptr) ;
     va_end(arg_ptr);
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
+}
+
+void
+g10_log_debug_f( const char *fname, const char *fmt, ... )
+{
+    va_list arg_ptr ;
+
+    print_prefix_f("DBG: ", fname);
+    va_start( arg_ptr, fmt ) ;
+    vfprintf(logfp,fmt,arg_ptr) ;
+    va_end(arg_ptr);
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
 }
 
 
 
 void
-log_hexdump( const char *text, char *buf, size_t len )
+g10_log_hexdump( const char *text, const char *buf, size_t len )
 {
     int i;
 
-    fprintf(stderr, "DBG%s: %s", pidstring,  text );
+    g10_log_print_prefix(text);
     for(i=0; i < len; i++ )
-       fprintf(stderr, " %02X", ((byte*)buf)[i] );
-    fputc('\n', stderr);
+       fprintf(logfp, " %02X", ((const byte*)buf)[i] );
+    fputc('\n', logfp);
+#ifdef __riscos__
+    fflush( logfp );
+#endif /* __riscos__ */
 }
 
 
-void
-log_mpidump( const char *text, MPI a )
-{
-    fprintf(stderr, "DBG%s: %s", pidstring, text );
-    mpi_print(stderr, a, 1 );
-    fputc('\n', stderr);
-}