jnlib/ChangeLog:
authorMoritz Schulte <mo@g10code.com>
Sat, 22 Oct 2005 21:14:57 +0000 (21:14 +0000)
committerMoritz Schulte <mo@g10code.com>
Sat, 22 Oct 2005 21:14:57 +0000 (21:14 +0000)
2005-10-22  Moritz Schulte  <moritz@g10code.com>

Updated jnlib.

* logging.c: Include <syslog.h>.
(syslog_priorities): New static array.
(logging_to_syslog): New static variable.
(set_syslog): New function.
(log_set_syslog): New function, public interface to set_syslog.
(log_close): New function.
(log_get_stream): Return LOGSTREAM (which must be NULL) in case
Syslog logging is enabled.
(log_get_fd): In case Syslog logging is enabled, return -1 in any
case.
(do_logv): Use assert to make sure that LEVEL contains an allowed
value; implement support for logging to Syslog.

* logging.h (log_set_syslog): New function.
(log_close): Likewise.

src/jnlib/ChangeLog
src/jnlib/argparse.c
src/jnlib/logging.c
src/jnlib/logging.h
src/jnlib/stringhelp.c
src/jnlib/stringhelp.h
src/jnlib/types.h
src/jnlib/utf8conv.c

index e69de29..29f60a8 100644 (file)
@@ -0,0 +1,361 @@
+2005-10-22  Moritz Schulte  <moritz@g10code.com>
+
+       Updated jnlib.
+
+       * logging.c: Include <syslog.h>.
+       (syslog_priorities): New static array.
+       (logging_to_syslog): New static variable.
+       (set_syslog): New function.
+       (log_set_syslog): New function, public interface to set_syslog.
+       (log_close): New function.
+       (log_get_stream): Return LOGSTREAM (which must be NULL) in case
+       Syslog logging is enabled.
+       (log_get_fd): In case Syslog logging is enabled, return -1 in any
+       case.
+       (do_logv): Use assert to make sure that LEVEL contains an allowed
+       value; implement support for logging to Syslog.
+
+       * logging.h (log_set_syslog): New function.
+       (log_close): Likewise.
+
+2005-06-15  Werner Koch  <wk@g10code.com>
+
+       * stringhelp.c (sanitize_buffer): Make P a void*.
+       (ascii_memistr, memistr): Ditto.
+       (ascii_memcasecmp): Ditto.
+       * logging.c (writen): Use void * for arg BUFFER.
+       * stringhelp.c (memistr): Fixed unsigned/signed pointer conflict.
+       (ascii_memistr): Ditto.
+       (ascii_memcasemem): Ditto.
+       * utf8conv.c (utf8_to_native): Ditto.
+       (utf8_to_native): Ditto.
+       * argparse.c (show_version): Removed non-required cast.
+
+2005-01-19  Werner Koch  <wk@g10code.com>
+
+       * logging.c (fun_writer): Don't fallback to stderr. Print to
+       stderr only if connected to a tty.
+
+2004-12-20  Werner Koch  <wk@g10code.com>
+
+       * w32-pth.c (do_pth_event_free): The events are hold in a ring
+       buffer.  Adjust for that.
+       (do_pth_event_body): Ditto.
+       (pth_event_isolate): Ditto.
+       (do_pth_wait): Ditto.
+       (_pth_event_count): Renamed to ..
+       (event_count): .. and adjusted as above.
+       (pth_init): Define 3 debug levels and change all debug calls to
+       make use of them.  This makes the moule now silent.
+
+2004-12-19  Werner Koch  <wk@g10code.com>
+
+       * w32-pth.c (pth_init): Enable debugging depending on env var.
+       (pth_self): New.
+       (pth_mutex_release, pth_mutex_acquire): Implemented directly using
+       the W32 API.
+
+2004-12-18  Werner Koch  <wk@g10code.com>
+
+       * w32-pth.c (pth_init): Reverse return values.  Use TRUE and FALSE
+       constants.
+       (pth_kill, pth_mutex_acquire, pth_attr_set, pth_join, pth_cancel):
+       Ditto.
+
+2004-12-15  Werner Koch  <wk@g10code.com>
+
+       * logging.c [W32]: Don't include unavailable headers.
+
+2004-12-14  Werner Koch  <wk@g10code.com>
+
+       * w32-pth.c (_pth_strerror): Renamed to ...
+       (w32_strerror): .. this. And let callers provide a buffer.
+       (spawn_helper_thread): Removed HD arg and hardwire the stack size
+       to 32k.
+       (do_pth_wait): Removed use of ATTR; not needed for the helper
+       threads.
+       (helper_thread): Renamed to ..
+       (launch_thread): .. this.  Release handle if not joinable.
+       (struct pth_priv_hd_s): Renamed to ...
+       (struct thread_info_s): .. this.  Add member JOINABLE and TH.
+
+2004-12-14  Timo Schulz  <twoaday@g10code.com>
+
+       * w32-pth.c (pth_kill): Just release the crit section if
+       pth_init was really called. And set all handles to NULL.
+       (_pth_strerror): New.
+       (do_pth_wait): Before we enter the loop we check if there
+       are too much events in the ring.
+       
+2004-12-14  Werner Koch  <wk@g10code.com>
+
+       * w32-pth.h (pth_event_occured): Removed macro. 
+       * w32-pth.c: Fixed license statement; its under the LGPL.
+       (enter_pth, leave_pth): Use them to bracket almost all public
+       functions.
+
+2004-12-13  Timo Schulz  <twoaday@g10code.com>
+
+       * w32-pth.c (enter_pth, leave_pth): New.
+       (pth_init): Initialize global mutex section.
+       (pth_kill): Release global mutex section.
+       (helper_thread): New.
+       (pth_spawn): Make sure only one thread is running.
+       
+2004-12-13  Werner Koch  <wk@g10code.com>
+
+       * stringhelp.c (w32_strerror) [W32]: New.
+
+       * w32-pth.c, w32-pth.h: Added real code written by Timo Schulz.
+       Not finished, though.
+
+2004-12-07  Werner Koch  <wk@g10code.com>
+
+       * w32-pth.c, w32-pth.h: New.
+
+2004-11-26  Werner Koch  <wk@g10code.com>
+
+       * logging.c [_WIN32]: Don't include socket headers.
+
+2004-11-30  Timo Schulz  <ts@g10code.com>
+
+       * w32-afunix.c: New. AF_UNIX emulation for W32.
+       * w32-afunix.h: Likewise.
+       
+2004-11-22  Werner Koch  <wk@g10code.com>
+
+       * logging.c (log_test_fd): Add test on LOGSTREAM.  Reported by
+       Barry Schwartz.
+
+2004-11-18  Werner Koch  <wk@g10code.com>
+
+       * logging.c: Explicitly include sys/stat.h for the S_I* constants.
+
+2004-10-21  Werner Koch  <wk@g10code.com>
+
+       * logging.c (do_logv): Use set_log_stream to setup a default.
+       (log_set_file): Factored code out to ..
+       (set_file_fd): .. New function to allow using a file descriptor.
+       (log_set_fd): Make use of new fucntion.
+       (fun_writer): Reworked.
+
+2004-08-18  Werner Koch  <wk@g10code.de>
+
+       * stringhelp.c (print_sanitized_utf8_string): Actually implement
+       it.
+
+2004-06-21  Werner Koch  <wk@g10code.com>
+
+       * logging.c (log_set_file): Do not close an old logstream if it
+       used to be stderr or stdout.
+
+2004-05-05  Werner Koch  <wk@gnupg.org>
+
+       * logging.c (log_set_file): Oops, don't close if LOGSTREAM is NULL.
+
+2004-04-30  Werner Koch  <wk@gnupg.org>
+
+       * logging.c (log_set_file): Make sure the log stream will be
+       closed even if the stderr fileno will be assigned to a new socket.
+
+2004-04-16  Werner Koch  <wk@gnupg.org>
+
+       * logging.h (JNLIB_LOG_WITH_PREFIX): Add constants for the flag
+       values.
+       * logging.c (log_set_prefix): New flag DETACHED.
+       (fun_writer): Take care of this flag.
+       (log_test_fd): New.
+
+2004-02-18  Werner Koch  <wk@gnupg.org>
+
+       * stringhelp.c (print_sanitized_buffer): Don't care about
+       non-ASCII characaters.
+       (sanitize_buffer): Ditto.
+
+2004-02-12  Werner Koch  <wk@gnupg.org>
+
+       * Makefile.am: Replaced INCLUDES by AM_CPPFLAGS.
+
+2004-01-05  Werner Koch  <wk@gnupg.org>
+
+       * argparse.c (strusage): Changed default copyright year to 2004.
+
+2003-12-17  Werner Koch  <wk@gnupg.org>
+
+       * argparse.c (initialize): Replaced use of non-literal format
+       args.  Suggested by Florian Weimer.
+
+2003-12-16  Werner Koch  <wk@gnupg.org>
+
+       * logging.c (writen, fun_writer, fun_closer): New.
+       (log_set_file): Add feature to log to a socket.
+       (log_set_file, do_logv): Force printing with prefix and pid.
+
+2003-11-13  Werner Koch  <wk@gnupg.org>
+
+       * strlist.c (strlist_copy): New.
+
+       * dotlock.c: Define DIRSEP_C et al. if not defined.
+
+2003-11-06  Werner Koch  <wk@gnupg.org>
+
+       * strlist.h (strlist_t): New. STRLIST is now deprecated.
+
+2003-06-18  Werner Koch  <wk@gnupg.org>
+
+       * strlist.c (strlist_pop): New.
+
+       * dotlock.c (dotlock_remove_lockfiles): Prefixed with dotlock_ and
+       made global.
+
+2003-06-17  Werner Koch  <wk@gnupg.org>
+
+       * stringhelp.c (length_sans_trailing_chars)
+       (length_sans_trailing_ws): New.
+
+       * logging.c (log_inc_errorcount): New.
+
+       * stringhelp.c (print_sanitized_utf8_buffer): Implement utf8
+       conversion.
+       (sanitize_buffer): New. Based on gnupg 1.3.2 make_printable_string.
+
+       * dotlock.c: Updated to match the version from 1.3.2
+       * utf8conv.c: New.  Code taken from strgutil.c of gnupg 1.3.2.
+       * utf8conv.h: New.
+
+2003-06-16  Werner Koch  <wk@gnupg.org>
+
+       * logging.c (do_logv): Hack to optionally suppress a leading space.
+
+       * stringhelp.c (ascii_strncasecmp): New.  Taken from gnupg 1.3.
+       (ascii_memistr): New. Taken from gnupg 1.3
+
+2003-06-13  Werner Koch  <wk@gnupg.org>
+
+       * mischelp.h (wipememory2,wipememory): New. Taken from GnuPG 1.3.2. 
+
+2002-06-04  Werner Koch  <wk@gnupg.org>
+
+       * stringhelp.c (print_sanitized_utf8_string): New.  No real
+       implementation for now.
+       (print_sanitized_utf8_buffer): Ditto.
+
+2002-04-04  Werner Koch  <wk@gnupg.org>
+
+       * logging.c (log_get_prefix): New.
+
+2002-03-15  Werner Koch  <wk@gnupg.org>
+
+       * argparse.c (optfile_parse): Fixed missing argument handling.
+
+2002-02-25  Werner Koch  <wk@gnupg.org>
+
+       * stringhelp.c (ascii_memcasemem): New.
+
+2002-02-14  Werner Koch  <wk@gnupg.org>
+
+       * Makefile.am (INCLUDES): Add cflags for libgcrypt.
+
+2002-02-07  Werner Koch  <wk@gnupg.org>
+
+       * logging.c (log_set_fd): New.
+
+       * stringhelp.c (print_sanitized_buffer): New.
+       (print_sanitized_string): New.
+
+2002-01-24  Werner Koch  <wk@gnupg.org>
+
+       * argparse.c (strusage): Set default copyright notice year to 2002.
+
+       Fixed the copyright notice of this file, as it has always been
+       part of GnuPG and therefore belongs to the FSF.
+
+2001-11-01  Marcus Brinkmann  <marcus@g10code.de>
+
+       * logging.c (log_printf): Do not initialize ARG_PTR with 0, we
+       don't know the correct type.  Instead, run va_start and va_end
+       unconditionally.
+       Reported by Jose Carlos Garcia Sogo <jsogo@debian.org>.
+
+2002-01-19  Werner Koch  <wk@gnupg.org>
+
+       * logging.c (log_get_stream): New.
+
+2001-12-05  Werner Koch  <wk@gnupg.org>
+
+       * logging.c (log_set_prefix): New.
+       (do_logv): Include prefix and pid only if enabled. Print time only
+       when explicitly enabled.
+       (log_logv): New.  
+       * logging.h: Include log_logv() only when requested.
+
+2001-11-06  Werner Koch  <wk@gnupg.org>
+
+       * strlist.c, strlist.h: New. Taken from pgnupg/util/strgutil.c
+
+2001-08-30  Werner Koch  <wk@gnupg.org>
+
+       * logging.c (log_printf): Don't pass NULL instead of arg_ptr.
+
+2001-07-19  Werner Koch  <wk@gnupg.org>
+
+       * stringhelp.c (ascii_memistr,ascii_isupper,ascii_islower,
+       ascii_toupper,ascii_tolower, ascii_strcasecmp, ascii_memcasecmp): New.
+
+2000-07-26 10:02:51  Werner Koch  (wk@habibti.openit.de)
+
+  * stringhelp.c.: Add stdarg.h
+  * argparse.h: s/ulong/unsigned long/ although this should be defined
+  by types.h.
+
+2000-06-28 19:40:23  Werner Koch  (wk@habibti.openit.de)
+
+  * Makefile.am: Replaced second logging.c by .h
+
+2000-05-24 08:58:15  Werner Koch  (wk@habibti.openit.de)
+
+  * logging.c (log_get_errorcount): New.
+
+2000-05-24 08:44:47  Werner Koch  (wk@habibti.openit.de)
+
+  * stringhelp.c: Added a few filename related helper functions.
+
+2000-05-11 18:04:43  Werner Koch  (wk@habibti.openit.de)
+
+  * xmalloc.c (xstrcat2):  Replaced stpcpy to quickly address W32
+    problems.
+
+2000-05-02 19:43:38  Werner Koch  (wk@habibti.openit.de)
+
+  * xmalloc.c (xstrcat2): New.
+
+Mon Jan 24 13:04:28 CET 2000  Werner Koch  <wk@gnupg.de>
+
+  * README: New.
+  * Makefile.am: new.
+  * argparse.c argparse.h logging.c logging.h
+    mischelp.h stringhelp.c stringhelp.h xmalloc.c
+    xmalloc.h dotlock.c: Moved from ../util to here.
+  * dotlock.h: New.
+  * libjnlib-config.h: New.
+
+  * logging.c (log_set_file): New.
+  (log_printf): New.
+  (do_logv): Add kludge to insert LFs.
+
+
+     ***********************************************************
+     * Please note that Jnlib is maintained as part of GnuPG.  *
+     * You may find it source-copied in other packages.        *
+     ***********************************************************       
+       
+ Copyright 2000, 2001, 2002, 2003, 2004,
+          2005 Free Software Foundation, Inc.
+
+ This file is free software; as a special exception the author gives
+ unlimited permission to copy and/or distribute it, with or without
+ modifications, as long as this notice is preserved.
+
+ This file is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
index de828e8..980d118 100644 (file)
@@ -852,7 +852,7 @@ show_version()
     /* additional program info */
     for(i=30; i < 40; i++ )
        if( (s=strusage(i)) )
-           fputs( (const byte*)s, stdout);
+           fputs (s, stdout);
     fflush(stdout);
 }
 
@@ -904,7 +904,7 @@ strusage( int level )
     switch( level ) {
       case 11: p = "foo"; break;
       case 13: p = "0.0"; break;
-      case 14: p = "Copyright (C) 2004 Free Software Foundation, Inc."; break;
+      case 14: p = "Copyright (C) 2005 Free Software Foundation, Inc."; break;
       case 15: p =
 "This program comes with ABSOLUTELY NO WARRANTY.\n"
 "This is free software, and you are welcome to redistribute it\n"
index c75efaf..ec984e2 100644 (file)
@@ -1,6 +1,6 @@
 /* logging.c - useful logging functions
  * Copyright (C) 1998, 1999, 2000, 2001, 2003,
- *               2004 Free Software Foundation, Inc.
+ *               2004, 2005 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  */
 
 
-/* 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>
+#include <syslog.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
+
+\f
 
 static FILE *logstream;
 static int log_socket = -1;
@@ -58,23 +61,25 @@ 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
+static int logging_to_syslog;
+
+/* NOTE: This array provides a mapping between values from
+   jnlib_log_levels and syslog priorities.  Therefore the values must
+   match the order of the values in jnlib_log_levels as defined in
+   logging.h.  */
+static int syslog_priorities[] =
+  {
+    /* BEGIN */ 0,
+    /* CONT  */ 0,
+    /* INFO  */ LOG_INFO,
+    /* WARN  */ LOG_WARNING,
+    /* ERROR */ LOG_ERR,
+    /* FATAL */ LOG_CRIT,
+    /* BUG   */ LOG_ALERT,
+    /* DEBUG */ LOG_DEBUG
+  };
+
+\f
 
 int
 log_get_errorcount (int clear)
@@ -91,20 +96,25 @@ log_inc_errorcount (void)
    errorcount++;
 }
 
+\f
 
 /* 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;
   
@@ -122,77 +132,97 @@ writen (int fd, const unsigned char *buf, size_t nbytes)
   return 0;
 }
 
-
 static int 
 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;
 }
 
@@ -201,115 +231,196 @@ fun_closer (void *cookie_arg)
 {
   struct fun_cookie_s *cookie = cookie_arg;
 
+  /* FIXME: don't we need to print an additional newline character
+     here in case missing_lf is true?  -mo */
+
   if (cookie->fd != -1)
     close (cookie->fd);
   jnlib_free (cookie);
+  log_socket = -1;
   return 0;
 }
-#endif /* HAVE_FOPENCOOKIE || HAVE_FUNOPEN */
-
+#endif /*USE_FUNWRITER*/
 
 
+\f
 
-/* 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 && logstream)
-        {
-          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;
 }
 
+/* Use syslog as logging backend.  */
+static void
+set_syslog (const char *ident, int facility) 
+{
+  /* Initialize syslog logging.  */
+  openlog (ident, 0, facility);
+  
+  force_prefixes = 0;
+  missing_lf = 0;
+  logging_to_syslog = 1;
+  log_socket = -1;
+}
+
+\f
+
+/* 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) 
+{
+  set_file_fd (name? name: "-", -1);
+}
 
 void
 log_set_fd (int fd)
 {
-  FILE *fp;
+  set_file_fd (NULL, fd);
+}
 
-  force_prefixes = 0;
-  if (fd == 1)
-    fp = stdout;
-  else if (fd == 2)
-    fp = stderr;
+void
+log_set_syslog (const char *ident, int facility)
+{
+  set_syslog (ident, facility);
+}
+
+void
+log_close (void)
+{
+  if (logging_to_syslog)
+    {
+      closelog ();
+      logging_to_syslog = 0;
+    }
   else
-    fp = fdopen (fd, "a");
-  if (!fp)
     {
-      fprintf (stderr, "failed to fdopen log fd %d: %s\n",
-               fd, strerror(errno));
-      return;
+      if (logstream != stderr && logstream != stdout)
+       fclose (logstream);
+      logstream = NULL;
+      log_socket = -1;
+      /* FIXME: missing_lf should be reset by fun_write, I
+        think... -mo */
     }
-  setvbuf (fp, NULL, _IOLBF, 0);
-  
-  if (logstream && logstream != stderr && logstream != stdout)
-    fclose( logstream);
-  logstream = fp;
-  missing_lf = 0;
 }
 
-
 void
 log_set_prefix (const char *text, unsigned int flags)
 {
@@ -350,9 +461,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;
 }
@@ -360,29 +475,62 @@ log_test_fd (int fd)
 int
 log_get_fd ()
 {
-  return fileno(logstream?logstream:stderr);
+  if (logging_to_syslog)
+    /* FIXME: hopefully this does not break programs, which expect to
+       receive fileno(stderr) here in case logstream is not set.  */
+    return -1;
+  else
+    return fileno(logstream?logstream:stderr);
 }
 
 FILE *
 log_get_stream ()
 {
-  return logstream?logstream:stderr;
-}
+  /* FIXME: We should not return stderr here but initialize the log
+     stream properly.  This might break more things than using stderr,
+     though */
 
+  /* FIXME: Hopefully this does not break programs, which expect
+     stderr to be returned here in case logstream is not set.  */
+  return (logstream || logging_to_syslog) ? logstream : stderr;
+}
 
 static void
 do_logv (int level, const char *fmt, va_list arg_ptr)
 {
-  if (!logstream)
-    logstream = stderr;
+  /* Bail out on illegal parameters.  */
+  assert (0
+         || (level == JNLIB_LOG_BEGIN)
+         || (level == JNLIB_LOG_CONT)
+         || (level == JNLIB_LOG_INFO)
+         || (level == JNLIB_LOG_INFO)
+         || (level == JNLIB_LOG_WARN)
+         || (level == JNLIB_LOG_ERROR)
+         || (level == JNLIB_LOG_FATAL)
+         || (level == JNLIB_LOG_BUG)
+         || (level == JNLIB_LOG_DEBUG));
+
+  if (! logging_to_syslog)
+    {
+      if (!logstream)
+       {
+         log_set_file (NULL); /* Make sure a log stream has been set.  */
+         assert (logstream);
+       }
+
+      if (missing_lf && level != JNLIB_LOG_CONT)
+       putc('\n', logstream );
+      missing_lf = 0;
+    }
 
-  if (missing_lf && level != JNLIB_LOG_CONT)
-    putc('\n', logstream );
-  missing_lf = 0;
+  if ((!logging_to_syslog) && (level != JNLIB_LOG_CONT))
+    {
+      /* Print all required prefixes.  Note this does not work for
+        multiple line logging as we would need to print to a buffer
+        first.  For Syslog logging this code is skipped, since
+        usually Syslog takes care of adding meta data like timestamps
+        in log messages.  */
 
-  if (level != JNLIB_LOG_CONT)
-    { /* Note this does not work for multiple line logging as we would
-       * need to print to a buffer first */
       if (with_time && !force_prefixes)
         {
           struct tm *tp;
@@ -407,31 +555,90 @@ do_logv (int level, const char *fmt, va_list arg_ptr)
         putc (' ', logstream);
     }
 
-  switch (level)
-    {
-    case JNLIB_LOG_BEGIN: break;
-    case JNLIB_LOG_CONT: break;
-    case JNLIB_LOG_INFO: break;
-    case JNLIB_LOG_WARN: break;
-    case JNLIB_LOG_ERROR: break;
-    case JNLIB_LOG_FATAL: fputs("Fatal: ",logstream ); break;
-    case JNLIB_LOG_BUG: fputs("Ohhhh jeeee: ", logstream); break;
-    case JNLIB_LOG_DEBUG: fputs("DBG: ", logstream ); break;
-    default: fprintf(logstream,"[Unknown log level %d]: ", level ); break;
-    }
-
+  if (! logging_to_syslog)
+    /* We do not need to print this level-indicator prefix, since the
+       logging level is mapped to real Syslog levels.  */
+    switch (level)
+      {
+      case JNLIB_LOG_BEGIN: break;
+      case JNLIB_LOG_CONT: break;
+      case JNLIB_LOG_INFO: break;
+      case JNLIB_LOG_WARN: break;
+      case JNLIB_LOG_ERROR: break;
+      case JNLIB_LOG_FATAL: fputs("Fatal: ",logstream ); break;
+      case JNLIB_LOG_BUG: fputs("Ohhhh jeeee: ", logstream); break;
+      case JNLIB_LOG_DEBUG: fputs("DBG: ", logstream ); break;
+      default: fprintf(logstream,"[Unknown log level %d]: ", level ); break;
+      }
 
-  if (fmt)
+  if (logging_to_syslog)
+    {
+      /* Log through Syslog.  */
+
+      if (level == JNLIB_LOG_CONT)
+       {
+         const char *fmt_prefix = "[CONT] ";
+         char *fmt_prefixed;
+         size_t fmt_length;
+
+         /* JNLIB_LOG_CONT is quite tricky, since we cannot really
+            map this well to Syslog.  The least thing we should do in
+            respect to support for _CONT logging is to prefix the
+            syslog message to make clear it is a CONT message.  */
+
+         fmt_length = strlen (fmt);
+         fmt_prefixed = malloc (sizeof (fmt_prefix) + fmt_length);
+         if (fmt_prefixed)
+           {
+             strcpy (fmt_prefixed, fmt_prefix);
+             strcat (fmt_prefixed, fmt);
+
+             vsyslog (syslog_priorities[JNLIB_LOG_INFO],
+                      fmt_prefixed, arg_ptr);
+             free (fmt_prefixed);
+           }
+         else
+           {
+             /* Not enough memory for creating a prefixed version,
+                but we should not simply loose the message...  */
+
+             vsyslog (syslog_priorities[JNLIB_LOG_INFO],
+                      fmt_prefix, NULL);
+             vsyslog (syslog_priorities[JNLIB_LOG_INFO],
+                      fmt, arg_ptr);
+           }
+       }
+      else if (level != JNLIB_LOG_BEGIN)
+       /* This is easy.  Note: we skip JNLIB_LOG_BEGIN messages,
+          since they do not make much sense with the lousy _CONT
+          implementation for Syslog.  */
+       vsyslog (syslog_priorities[level], fmt, arg_ptr);
+    }    
+  else
     {
-      vfprintf(logstream,fmt,arg_ptr) ;
-      if (*fmt && fmt[strlen(fmt)-1] != '\n')
-        missing_lf = 1;
+      /* No Syslog logging; we can simply use the logstream.  */
+      if (fmt)
+       {
+         vfprintf (logstream, fmt, arg_ptr) ;
+         if (*fmt && fmt[strlen (fmt) - 1] != '\n')
+           missing_lf = 1;
+       }
     }
 
+  /* Do not forget to call closelog() when aborting the current
+     program.  */
   if (level == JNLIB_LOG_FATAL)
-    exit(2);
+    {
+      if (logging_to_syslog)
+       closelog ();
+      exit (2);
+    }
   if (level == JNLIB_LOG_BUG)
-    abort();
+    {
+      if (logging_to_syslog)
+       closelog ();
+      abort();
+    }
 }
 
 static void
index b5c0bd7..0566a64 100644 (file)
@@ -1,5 +1,5 @@
 /* logging.h
- *     Copyright (C) 1999, 2000, 2001, 2004 Free Software Foundation, Inc.
+ *     Copyright (C) 1999, 2000, 2001, 2004, 2005 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -34,6 +34,8 @@ int  log_get_errorcount (int clear);
 void log_inc_errorcount (void);
 void log_set_file( const char *name );
 void log_set_fd (int fd);
+void log_set_syslog (const char *ident, int facility);
+void log_close (void);
 void log_set_prefix (const char *text, unsigned int flags);
 const char *log_get_prefix (unsigned int *flags);
 int log_test_fd (int fd);
index 4c8ab31..760398b 100644 (file)
@@ -1,5 +1,6 @@
 /* stringhelp.c -  standard string helper functions
- * Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2003,
+ *               2004, 2005  Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <string.h>
 #include <stdarg.h>
 #include <ctype.h>
+#ifdef HAVE_W32_SYSTEM
+#include <windows.h>
+#endif
 
 #include "libjnlib-config.h"
 #include "utf8conv.h"
 #include "stringhelp.h"
 
 
-/****************
- * look for the substring SUB in buffer and return a pointer to that
- * substring in BUF or NULL if not found.
+/*
+ * Look for the substring SUB in buffer and return a pointer to that
+ * substring in BUFFER or NULL if not found.
  * Comparison is case-insensitive.
  */
 const char *
-memistr( const char *buf, size_t buflen, const char *sub )
+memistr (const void *buffer, size_t buflen, const char *sub)
 {
-    const byte *t, *s ;
-    size_t n;
+  const unsigned char *buf = buffer;
+  const unsigned char *t = (const unsigned char *)buffer;
+  const unsigned char *s = (const unsigned char *)sub;
+  size_t n = buflen;
 
-    for( t=buf, n=buflen, s=sub ; n ; t++, n-- )
-       if( toupper(*t) == toupper(*s) ) {
-           for( buf=t++, buflen = n--, s++;
-                n && toupper(*t) == toupper(*s); t++, s++, n-- )
-               ;
-           if( !*s )
-               return buf;
-           t = buf; n = buflen; s = sub ;
+  for ( ; n ; t++, n-- )
+    {
+      if ( toupper (*t) == toupper (*s) )
+        {
+          for ( buf=t++, buflen = n--, s++;
+                n && toupper (*t) == toupper (*s); t++, s++, n-- )
+            ;
+          if (!*s)
+            return (const char*)buf;
+          t = buf;
+          s = (const unsigned char *)sub ;
+          n = buflen;
        }
-
-    return NULL ;
+    }
+  return NULL;
 }
 
 const char *
-ascii_memistr( const char *buf, size_t buflen, const char *sub )
+ascii_memistr ( const void *buffer, size_t buflen, const char *sub )
 {
-    const byte *t, *s ;
-    size_t n;
+  const unsigned char *buf = buffer;
+  const unsigned char *t = (const unsigned char *)buf;
+  const unsigned char *s = (const unsigned char *)sub;
+  size_t n = buflen;
 
-    for( t=buf, n=buflen, s=sub ; n ; t++, n-- )
-       if( ascii_toupper(*t) == ascii_toupper(*s) ) {
-           for( buf=t++, buflen = n--, s++;
-                n && ascii_toupper(*t) == ascii_toupper(*s); t++, s++, n-- )
-               ;
-           if( !*s )
-               return buf;
-           t = buf; n = buflen; s = sub ;
+  for ( ; n ; t++, n-- )
+    {
+      if (ascii_toupper (*t) == ascii_toupper (*s) )
+        {
+          for ( buf=t++, buflen = n--, s++;
+                n && ascii_toupper (*t) == ascii_toupper (*s); t++, s++, n-- )
+            ;
+          if (!*s)
+            return (const char*)buf;
+          t = (const unsigned char *)buf;
+          s = (const unsigned char *)sub ;
+          n = buflen;
        }
-
-    return NULL ;
+    }
+  return NULL;
 }
 
-/****************
- * Wie strncpy(), aber es werden maximal n-1 zeichen kopiert und ein
- * '\0' angehängt. Ist n = 0, so geschieht nichts, ist Destination
- * gleich NULL, so wird via jnlib_xmalloc Speicher besorgt, ist dann nicht
- * genügend Speicher vorhanden, so bricht die funktion ab.
+/* This function is similar to strncpy().  However it won't copy more
+   than N - 1 characters and makes sure that a '\0' is appended. With
+   N given as 0, nothing will happen.  With DEST given as NULL, memory
+   will be allocated using jnlib_xmalloc (i.e. if it runs out of core
+   the function terminates).  Returns DES or a pointer to the
+   allocated memory.
  */
 char *
 mem2str( char *dest , const void *src , size_t n )
@@ -392,17 +409,19 @@ print_sanitized_string (FILE *fp, const char *string, int delim)
 size_t 
 print_sanitized_utf8_string (FILE *fp, const char *string, int delim)
 {
-  /* FIXME: convert to local characterset */
-  return print_sanitized_string (fp, string, delim);
+  return string? print_sanitized_utf8_buffer (fp,
+                                              string, strlen (string),
+                                              delim) : 0;
 }
 
-/* Create a string from the buffer P of length N which is suitable for
+/* Create a string from the buffer P_ARG of length N which is suitable for
    printing.  Caller must release the created string using xfree. */
 char *
-sanitize_buffer (const unsigned char *p, size_t n, int delim)
+sanitize_buffer (const void *p_arg, size_t n, int delim)
 {
+  const unsigned char *p = p_arg;
   size_t save_n, buflen;
-  const byte *save_p;
+  const unsigned char *save_p;
   char *buffer, *d;
 
   /* first count length */
@@ -451,8 +470,29 @@ sanitize_buffer (const unsigned char *p, size_t n, int delim)
   return buffer;
 }
 
+
 /****************************************************
- ******** locale insensitive ctype functions ********
+ **********  W32 specific functions  ****************
+ ****************************************************/
+
+#ifdef HAVE_W32_SYSTEM
+const char *
+w32_strerror (int ec)
+{
+  static char strerr[256];
+  
+  if (ec == -1)
+    ec = (int)GetLastError ();
+  FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, ec,
+                 MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
+                 strerr, DIM (strerr)-1, NULL);
+  return strerr;    
+}
+#endif /*HAVE_W32_SYSTEM*/
+
+
+/****************************************************
+ ******** Locale insensitive ctype functions ********
  ****************************************************/
 /* FIXME: replace them by a table lookup and macros */
 int
@@ -525,15 +565,19 @@ ascii_strncasecmp (const char *a, const char *b, size_t n)
 
 
 int
-ascii_memcasecmp( const char *a, const char *b, size_t n )
+ascii_memcasecmp (const void *a_arg, const void *b_arg, size_t n )
 {
-    if (a == b)
-        return 0;
-    for ( ; n; n--, a++, b++ ) {
-       if( *a != *b  && ascii_toupper (*a) != ascii_toupper (*b) )
-            return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
-    }
+  const char *a = a_arg;
+  const char *b = b_arg;
+
+  if (a == b)
     return 0;
+  for ( ; n; n--, a++, b++ )
+    {
+      if( *a != *b  && ascii_toupper (*a) != ascii_toupper (*b) )
+        return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
+    }
+  return 0;
 }
 
 int
@@ -559,8 +603,8 @@ ascii_memcasemem (const void *haystack, size_t nhaystack,
     return (void*)haystack; /* finding an empty needle is really easy */
   if (nneedle <= nhaystack)
     {
-      const unsigned char *a = haystack;
-      const unsigned char *b = a + nhaystack - nneedle;
+      const char *a = haystack;
+      const char *b = a + nhaystack - nneedle;
       
       for (; a <= b; a++)
         {
@@ -625,3 +669,5 @@ memicmp( const char *a, const char *b, size_t n )
     return 0;
 }
 #endif
+
+
index fe5786e..bdd7d56 100644 (file)
@@ -23,7 +23,7 @@
 
 #include "types.h"
 
-const char *memistr( const char *buf, size_t buflen, const char *sub );
+const char *memistr (const void *buf, size_t buflen, const char *sub);
 char *mem2str( char *, const void *, size_t);
 char *trim_spaces( char *string );
 char *trim_trailing_spaces( char *string );
@@ -46,18 +46,22 @@ size_t print_sanitized_utf8_buffer (FILE *fp, const void *buffer,
                                     size_t length, int delim);
 size_t print_sanitized_string (FILE *fp, const char *string, int delim);
 size_t print_sanitized_utf8_string (FILE *fp, const char *string, int delim);
-char *sanitize_buffer (const unsigned char *p, size_t n, int delim);
+char *sanitize_buffer (const void *p, size_t n, int delim);
+
+
+#ifdef HAVE_W32_SYSTEM
+const char *w32_strerror (int ec);
+#endif
 
 
-const char *ascii_memistr( const char *buf, size_t buflen, const char *sub );
 int ascii_isupper (int c);
 int ascii_islower (int c);
 int ascii_toupper (int c);
 int ascii_tolower (int c);
 int ascii_strcasecmp( const char *a, const char *b );
 int ascii_strncasecmp (const char *a, const char *b, size_t n);
-int ascii_memcasecmp( const char *a, const char *b, size_t n );
-const char *ascii_memistr ( const char *buf, size_t buflen, const char *sub);
+int ascii_memcasecmp( const void *a, const void *b, size_t n );
+const char *ascii_memistr ( const void *buf, size_t buflen, const char *sub);
 void *ascii_memcasemem (const void *haystack, size_t nhaystack,
                         const void *needle, size_t nneedle);
 
index 230d150..934b7a6 100644 (file)
 
 #ifndef HAVE_BYTE_TYPEDEF
   #undef byte      /* maybe there is a macro with this name */
+/* Windows typedefs byte in the rpc headers.  Avoid warning about
+   double definition.  */
+#if !(defined(_WIN32) && defined(cbNDRContext))
   typedef unsigned char byte;
+#endif
   #define HAVE_BYTE_TYPEDEF
 #endif
 
index 6911767..4df8b7b 100644 (file)
@@ -136,16 +136,17 @@ get_native_charset ()
  * new allocated UTF8 string.
  */
 char *
-native_to_utf8 (const char *string)
+native_to_utf8 (const char *orig_string)
 {
-  const byte *s;
+  const unsigned char *string = (const unsigned char *)orig_string;
+  const unsigned char *s;
   char *buffer;
-  byte *p;
+  unsigned char *p;
   size_t length = 0;
 
   if (no_translation)
     {
-      buffer = jnlib_xstrdup (string);
+      buffer = jnlib_xstrdup (orig_string);
     }
   else if (active_charset)
     {
@@ -156,7 +157,7 @@ native_to_utf8 (const char *string)
            length += 2;        /* we may need 3 bytes */
        }
       buffer = jnlib_xmalloc (length + 1);
-      for (p = buffer, s = string; *s; s++)
+      for (p = (unsigned char *)buffer, s = string; *s; s++)
        {
          if ((*s & 0x80))
            {
@@ -187,7 +188,7 @@ native_to_utf8 (const char *string)
            length++;
        }
       buffer = jnlib_xmalloc (length + 1);
-      for (p = buffer, s = string; *s; s++)
+      for (p = (unsigned char *)buffer, s = string; *s; s++)
        {
          if (*s & 0x80)
            {
@@ -212,11 +213,12 @@ utf8_to_native (const char *string, size_t length, int delim)
 {
   int nleft;
   int i;
-  byte encbuf[8];
+  unsigned char encbuf[8];
   int encidx;
   const byte *s;
   size_t n;
-  byte *buffer = NULL, *p = NULL;
+  char *buffer = NULL;
+  char *p = NULL;
   unsigned long val = 0;
   size_t slen;
   int resync = 0;
@@ -225,7 +227,8 @@ utf8_to_native (const char *string, size_t length, int delim)
   /* 2. pass (p!=NULL): create string */
   for (;;)
     {
-      for (slen = length, nleft = encidx = 0, n = 0, s = string; slen;
+      for (slen = length, nleft = encidx = 0, n = 0,
+             s = (const unsigned char *)string; slen;
           s++, slen--)
        {
          if (resync)