Add --logger-fd alias.
[gnupg.git] / jnlib / logging.c
index 7397ddd..37ae207 100644 (file)
@@ -1,30 +1,24 @@
-/* logging.c - useful logging functions
+/* logging.c - Useful logging functions
  * Copyright (C) 1998, 1999, 2000, 2001, 2003,
- *               2004 Free Software Foundation, Inc.
+ *               2004, 2005, 2006 Free Software Foundation, Inc.
  *
- * This file is part of GnuPG.
+ * This file is part of JNLIB.
  *
- * 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.
+ * JNLIB is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 3 of
+ * the License, or (at your option) any later version.
  *
- * 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.
+ * JNLIB 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
+ * Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 
-/* This file should replace logger.c in the future - for now it is not
- * used by GnuPG but by GPA.
- * It is a quite simple implemenation but sufficient for most purposes.
- */
-
 #include <config.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>
 #include <time.h>
 #include <sys/types.h>
+#include <sys/stat.h>
+#ifndef HAVE_W32_SYSTEM
 #include <sys/socket.h>
 #include <sys/un.h>
+#endif /*!HAVE_W32_SYSTEM*/
 #include <unistd.h>
-#ifdef __MINGW32__
-#  include <io.h>
-#endif
+#include <fcntl.h>
+#include <assert.h>
+
 
 #define JNLIB_NEED_LOG_LOGV 1
 #include "libjnlib-config.h"
 #include "logging.h"
 
+#if defined (HAVE_FOPENCOOKIE) ||  defined (HAVE_FUNOPEN)
+#define USE_FUNWRITER 1
+#endif
+
+#ifdef HAVE_FOPENCOOKIE
+typedef ssize_t my_funopen_hook_ret_t;
+#else
+typedef int     my_funopen_hook_ret_t;
+#endif
+
 
 static FILE *logstream;
 static int log_socket = -1;
@@ -58,23 +65,6 @@ static int force_prefixes;
 static int missing_lf;
 static int errorcount;
 
-#if 0
-static void
-write2stderr( const char *s )
-{
-    write( 2, s, strlen(s) );
-}
-
-
-static void
-do_die(int rc, const char *text )
-{
-    write2stderr("\nFatal error: ");
-    write2stderr(text);
-    write2stderr("\n");
-    abort();
-}
-#endif
 
 int
 log_get_errorcount (int clear)
@@ -94,17 +84,20 @@ log_inc_errorcount (void)
 
 /* The follwing 3 functions are used by funopen to write logs to a
    socket. */
-#if defined (HAVE_FOPENCOOKIE) || defined (HAVE_FUNOPEN)
+#ifdef USE_FUNWRITER
 struct fun_cookie_s {
   int fd;
   int quiet;
+  int want_socket;
+  int is_socket;
   char name[1];
 };
 
-/* Write NBYTES of BUF to file descriptor FD. */
+/* Write NBYTES of BUFFER to file descriptor FD. */
 static int
-writen (int fd, const unsigned char *buf, size_t nbytes)
+writen (int fd, const void *buffer, size_t nbytes)
 {
+  const char *buf = buffer;
   size_t nleft = nbytes;
   int nwritten;
   
@@ -123,76 +116,97 @@ writen (int fd, const unsigned char *buf, size_t nbytes)
 }
 
 
-static in
+static my_funopen_hook_ret_
 fun_writer (void *cookie_arg, const char *buffer, size_t size)
 {
   struct fun_cookie_s *cookie = cookie_arg;
 
   /* Note that we always try to reconnect to the socket but print
-     error messages only the first time an error occured.  IF
+     error messages only the first time an error occured.  If
      RUNNING_DETACHED is set we don't fall back to stderr and even do
-     not print any error messages.  This is needed becuase detached
-     processes often close stderr and my printing to fiel descriptor 2
+     not print any error messages.  This is needed because detached
+     processes often close stderr and by writing to file descriptor 2
      we might send the log message to a file not intended for logging
      (e.g. a pipe or network connection). */
-  if (cookie->fd == -1)
+  if (cookie->want_socket && cookie->fd == -1)
     {
-      /* Note yet open or meanwhile closed due to an error. */
-      struct sockaddr_un addr;
-      size_t addrlen;
-
+      /* Not yet open or meanwhile closed due to an error. */
+      cookie->is_socket = 0;
       cookie->fd = socket (PF_LOCAL, SOCK_STREAM, 0);
       if (cookie->fd == -1)
         {
-          if (!cookie->quiet && !running_detached)
+          if (!cookie->quiet && !running_detached
+              && isatty (fileno (stderr)))
             fprintf (stderr, "failed to create socket for logging: %s\n",
                      strerror(errno));
-          goto failure;
         }
-      log_socket = cookie->fd;
+      else
+        {
+          struct sockaddr_un addr;
+          size_t addrlen;
+          
+          memset (&addr, 0, sizeof addr);
+          addr.sun_family = PF_LOCAL;
+          strncpy (addr.sun_path, cookie->name, sizeof (addr.sun_path)-1);
+          addr.sun_path[sizeof (addr.sun_path)-1] = 0;
+          addrlen = (offsetof (struct sockaddr_un, sun_path)
+                     + strlen (addr.sun_path) + 1);
       
-      memset (&addr, 0, sizeof addr);
-      addr.sun_family = PF_LOCAL;
-      strncpy (addr.sun_path, cookie->name, sizeof (addr.sun_path)-1);
-      addr.sun_path[sizeof (addr.sun_path)-1] = 0;
-      addrlen = (offsetof (struct sockaddr_un, sun_path)
-                 + strlen (addr.sun_path) + 1);
+          if (connect (cookie->fd, (struct sockaddr *) &addr, addrlen) == -1)
+            {
+              if (!cookie->quiet && !running_detached
+                  && isatty (fileno (stderr)))
+                fprintf (stderr, "can't connect to `%s': %s\n",
+                         cookie->name, strerror(errno));
+              close (cookie->fd);
+              cookie->fd = -1;
+            }
+        }
       
-      if (connect (cookie->fd, (struct sockaddr *) &addr, addrlen) == -1)
+      if (cookie->fd == -1)
+        {
+          if (!running_detached)
+            {
+              /* Due to all the problems with apps not running
+                 detahced but beeing caled with stderr closed or
+                 used for a different purposes, it does not make
+                 sense to switch to stderr.  We tehrefore disable it. */
+              if (!cookie->quiet)
+                {
+                  /* fputs ("switching logging to stderr\n", stderr);*/
+                  cookie->quiet = 1;
+                }
+              cookie->fd = -1; /*fileno (stderr);*/
+            }
+        }
+      else /* Connection has been established. */
         {
-          log_socket = -1;
-          if (!cookie->quiet && !running_detached)
-            fprintf (stderr, "can't connect to `%s': %s\n",
-                     cookie->name, strerror(errno));
-          close (cookie->fd);
-          cookie->fd = -1;
-          goto failure;
+          cookie->quiet = 0;
+          cookie->is_socket = 1;
         }
-      /* Connection established. */
-      cookie->quiet = 0;
     }
-  
-  if (!writen (cookie->fd, buffer, size))
+
+  log_socket = cookie->fd;
+  if (cookie->fd != -1 && !writen (cookie->fd, buffer, size))
     return size; /* Okay. */ 
 
-  log_socket = -1;
-  if (!running_detached)
-    fprintf (stderr, "error writing to `%s': %s\n",
-             cookie->name, strerror(errno));
-  close (cookie->fd);
-  cookie->fd = -1;
-
- failure: 
-  if (!running_detached)
+  if (!running_detached && cookie->fd != -1
+      && isatty (fileno (stderr)))
     {
-      if (!cookie->quiet)
-        {
-          fputs ("switching logging to stderr\n", stderr);
-          cookie->quiet = 1;
-        }
-      
-      fwrite (buffer, size, 1, stderr);
+      if (*cookie->name)
+        fprintf (stderr, "error writing to `%s': %s\n",
+                 cookie->name, strerror(errno));
+      else
+        fprintf (stderr, "error writing to file descriptor %d: %s\n",
+                 cookie->fd, strerror(errno));
     }
+  if (cookie->is_socket && cookie->fd != -1)
+    {
+      close (cookie->fd);
+      cookie->fd = -1;
+      log_socket = -1;
+    }
+
   return size;
 }
 
@@ -204,109 +218,148 @@ fun_closer (void *cookie_arg)
   if (cookie->fd != -1)
     close (cookie->fd);
   jnlib_free (cookie);
+  log_socket = -1;
   return 0;
 }
-#endif /* HAVE_FOPENCOOKIE || HAVE_FUNOPEN */
-
+#endif /*USE_FUNWRITER*/
 
 
 
-/* Set the file to write log to.  The special names NULL and "-" may
-   be used to select stderr and names formatted like
-   "socket:///home/foo/mylogs" may be used to write the logging to the
-   socket "/home/foo/mylogs".  If the connection to the socket fails
-   or a write error is detected, the function writes to stderr and
-   tries the next time again to connect the socket.
-  */
-void
-log_set_file (const char *name) 
+/* Common function to either set the logging to a file or a file
+   descriptor. */
+static void
+set_file_fd (const char *name, int fd) 
 {
   FILE *fp;
+  int want_socket;
+#ifdef USE_FUNWRITER
+  struct fun_cookie_s *cookie;
+#endif
 
-  force_prefixes = 0;
-  if (name && !strncmp (name, "socket://", 9) && name[9])
+  if (name && !strcmp (name, "-"))
     {
-#if defined (HAVE_FOPENCOOKIE)||  defined (HAVE_FUNOPEN)
-      struct fun_cookie_s *cookie;
+      name = NULL;
+      fd = fileno (stderr);
+    }
 
-      cookie = jnlib_xmalloc (sizeof *cookie + strlen (name+9));
-      cookie->fd = -1;
-      cookie->quiet = 0;
-      strcpy (cookie->name, name+9);
+  if (name)
+    {
+      want_socket = (!strncmp (name, "socket://", 9) && name[9]);
+      if (want_socket)
+        name += 9;
+    }
+  else
+    {
+      want_socket = 0;
+    }
 
-#ifdef HAVE_FOPENCOOKIE
-      {
-        cookie_io_functions_t io = { NULL };
-        io.write = fun_writer;
-        io.close = fun_closer;
+#ifdef USE_FUNWRITER
+  cookie = jnlib_xmalloc (sizeof *cookie + (name? strlen (name):0));
+  strcpy (cookie->name, name? name:"");
+  cookie->quiet = 0;
+  cookie->is_socket = 0;
+  cookie->want_socket = want_socket;
+  if (!name)
+    cookie->fd = fd;
+  else if (want_socket)
+    cookie->fd = -1;
+  else
+    {
+      do
+        cookie->fd = open (name, O_WRONLY|O_APPEND|O_CREAT,
+                           (S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR|S_IWGRP|S_IWOTH));
+      while (cookie->fd == -1 && errno == EINTR);
+    }
+  log_socket = cookie->fd;
 
-        fp = fopencookie (cookie, "w", io);
-      }
+#ifdef HAVE_FOPENCOOKIE
+  {
+    cookie_io_functions_t io = { NULL };
+    io.write = fun_writer;
+    io.close = fun_closer;
+    
+    fp = fopencookie (cookie, "w", io);
+  }
 #else /*!HAVE_FOPENCOOKIE*/
-      {
-        fp = funopen (cookie, NULL, fun_writer, NULL, fun_closer);
-      }
+  fp = funopen (cookie, NULL, fun_writer, NULL, fun_closer);
 #endif /*!HAVE_FOPENCOOKIE*/
-#else /* Neither fopencookie nor funopen. */
-      {
-        fprintf (stderr, "system does not support logging to a socket - "
-                 "using stderr\n");
-        fp = stderr;
-      }
-#endif /* Neither fopencookie nor funopen. */
-
-      /* We always need to print the prefix and the pid, so that the
-         server reading the socket can do something meanigful. */
-      force_prefixes = 1;
-      /* On success close the old logstream right now, so that we are
-         really sure it has been closed. */
-      if (fp)
-        {
-          fclose (logstream);
-          logstream = NULL;
-        }
+
+#else /*!USE_FUNWRITER*/
+
+  /* The system does not feature custom streams.  Thus fallback to
+     plain stdio. */
+  if (want_socket)
+    {
+      fprintf (stderr, "system does not support logging to a socket - "
+               "using stderr\n");
+      fp = stderr;
     }
+  else if (name)
+    fp = fopen (name, "a");
+  else if (fd == 1)
+    fp = stdout;
+  else if (fd == 2)
+    fp = stderr;
   else
-    fp = (name && strcmp(name,"-"))? fopen (name, "a") : stderr;
+    fp = fdopen (fd, "a");
+
+  log_socket = -1; 
+
+#endif /*!USE_FUNWRITER*/
+
+  /* On success close the old logstream right now, so that we are
+     really sure it has been closed. */
+  if (fp && logstream)
+    {
+      if (logstream != stderr && logstream != stdout)
+        fclose (logstream);
+      logstream = NULL;
+    }
+      
   if (!fp)
     {
-      fprintf (stderr, "failed to open log file `%s': %s\n",
-               name? name:"[stderr]", strerror(errno));
-      return;
+      if (name)
+        fprintf (stderr, "failed to open log file `%s': %s\n",
+                 name, strerror(errno));
+      else
+        fprintf (stderr, "failed to fdopen file descriptor %d: %s\n",
+                 fd, strerror(errno));
+      /* We need to make sure that there is a log stream.  We use stderr. */
+      fp = stderr;
     }
-  setvbuf (fp, NULL, _IOLBF, 0);
+  else
+    setvbuf (fp, NULL, _IOLBF, 0);
   
   if (logstream && logstream != stderr && logstream != stdout)
     fclose (logstream);
   logstream = fp;
+
+  /* We always need to print the prefix and the pid for socket mode,
+     so that the server reading the socket can do something
+     meaningful. */
+  force_prefixes = want_socket;
+
   missing_lf = 0;
 }
 
 
+/* Set the file to write log to.  The special names NULL and "-" may
+   be used to select stderr and names formatted like
+   "socket:///home/foo/mylogs" may be used to write the logging to the
+   socket "/home/foo/mylogs".  If the connection to the socket fails
+   or a write error is detected, the function writes to stderr and
+   tries the next time again to connect the socket.
+  */
 void
-log_set_fd (int fd)
+log_set_file (const char *name) 
 {
-  FILE *fp;
+  set_file_fd (name? name: "-", -1);
+}
 
-  force_prefixes = 0;
-  if (fd == 1)
-    fp = stdout;
-  else if (fd == 2)
-    fp = stderr;
-  else
-    fp = fdopen (fd, "a");
-  if (!fp)
-    {
-      fprintf (stderr, "failed to fdopen log fd %d: %s\n",
-               fd, strerror(errno));
-      return;
-    }
-  setvbuf (fp, NULL, _IOLBF, 0);
-  
-  if (logstream && logstream != stderr && logstream != stdout)
-    fclose( logstream);
-  logstream = fp;
-  missing_lf = 0;
+void
+log_set_fd (int fd)
+{
+  set_file_fd (NULL, fd);
 }
 
 
@@ -350,9 +403,13 @@ log_get_prefix (unsigned int *flags)
 int
 log_test_fd (int fd)
 {
-  if (fileno (logstream?logstream:stderr) == fd)
-    return 1;
-  if (log_socket == fd)
+  if (logstream)
+    {
+      int tmp = fileno (logstream);
+      if ( tmp != -1 && tmp == fd)
+        return 1;
+    }
+  if (log_socket != -1 && log_socket == fd)
     return 1;
   return 0;
 }
@@ -366,15 +423,20 @@ log_get_fd ()
 FILE *
 log_get_stream ()
 {
+  /* FIXME: We should not return stderr here but initialize the log
+     stream properly.  This might break more things than using stderr,
+     though */
   return logstream?logstream:stderr;
 }
 
-
 static void
 do_logv (int level, const char *fmt, va_list arg_ptr)
 {
   if (!logstream)
-    logstream = stderr;
+    {
+      log_set_file (NULL); /* Make sure a log stream has been set.  */
+      assert (logstream);
+    }
 
   if (missing_lf && level != JNLIB_LOG_CONT)
     putc('\n', logstream );
@@ -429,9 +491,17 @@ do_logv (int level, const char *fmt, va_list arg_ptr)
     }
 
   if (level == JNLIB_LOG_FATAL)
-    exit(2);
+    {
+      if (missing_lf)
+        putc('\n', logstream );
+      exit(2);
+    }
   if (level == JNLIB_LOG_BUG)
-    abort();
+    {
+      if (missing_lf)
+        putc('\n', logstream );
+      abort();
+    }
 }
 
 static void