g10/ does build again.

8 files changed, 201 insertions, 61 deletions

diff --git a/jnlib/ChangeLog b/jnlib/ChangeLog
index f3074c6af..61d12d580 100644
--- a/jnlib/ChangeLog
+++ b/jnlib/ChangeLog
@@ -1,3 +1,22 @@
+2006-05-23  Werner Koch  <wk@g10code.com>
+
+	* libjnlib-config.h (JNLIB_NEED_UTF8CONV): Fixed typo in name.
+
+	* dotlock.c (release_dotlock): Don't act if we don't have any
+	locks at all.
+	(destroy_dotlock): New.  From 1.4.3.
+	(dotlock_remove_lockfiles): Make use of destroy function.
+
+2006-05-19  Werner Koch  <wk@g10code.com>
+
+	* strlist.c (append_to_strlist2): Enabled.
+
+	* stringhelp.c (print_sanitized_buffer2): New.  Changed the rules
+	to match the behaviour of print_string2 from gnupg 1.4.3.
+	(print_sanitized_buffer): Use the new function.
+	(print_sanitized_string2): New.
+	(hextobyte): New.  Taken from gpg 1.4.3.
+
 2006-04-28  Werner Koch  <wk@g10code.com>
 
 	* stringhelp.c (print_sanitized_buffer): Fix bug where the count
diff --git a/jnlib/dotlock.c b/jnlib/dotlock.c
index a50a0ee99..b7f892717 100644
--- a/jnlib/dotlock.c
+++ b/jnlib/dotlock.c
@@ -1,5 +1,6 @@
 /* dotlock.c - dotfile locking
- *	Copyright (C) 1998,2000,2001,2003 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 2000, 2001, 2003, 2004, 
+ *               2005 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -149,9 +150,9 @@ create_dotlock( const char *file_to_lock )
 	dirpart = file_to_lock;
     }
 
-  #ifdef _REENTRANT
+#ifdef _REENTRANT
     /* fixme: aquire mutex on all_lockfiles */
-  #endif
+#endif
     h->next = all_lockfiles;
     all_lockfiles = h;
 
@@ -202,15 +203,54 @@ create_dotlock( const char *file_to_lock )
 	return NULL;
     }
 
-  #ifdef _REENTRANT
+# ifdef _REENTRANT
     /* release mutex */
-  #endif
+# endif
 #endif /* !HAVE_DOSISH_SYSTEM */
     h->lockname = jnlib_xmalloc( strlen(file_to_lock) + 6 );
     strcpy(stpcpy(h->lockname, file_to_lock), EXTSEP_S "lock");
     return h;
 }
 
+
+void
+destroy_dotlock ( DOTLOCK h )
+{
+#if !defined (HAVE_DOSISH_SYSTEM)
+    if ( h )
+      {
+        DOTLOCK hprev, htmp;
+
+        /* First remove the handle from our global list of all locks. */
+        for (hprev=NULL, htmp=all_lockfiles; htmp; hprev=htmp, htmp=htmp->next)
+          if (htmp == h)
+            {
+              if (hprev)
+                hprev->next = htmp->next;
+              else
+                all_lockfiles = htmp->next;
+              h->next = NULL;
+              break;
+            }
+
+        /* Second destroy the lock. */
+	if (!h->disable)
+          {
+	    if (h->locked && h->lockname)
+              unlink (h->lockname);
+            if (h->tname)
+              unlink (h->tname);
+	    jnlib_free (h->tname);
+	    jnlib_free (h->lockname);
+          }
+	jnlib_free(h);
+
+      }
+#endif
+}
+
+
+
 static int
 maybe_deadlock( DOTLOCK h )
 {
@@ -331,6 +371,13 @@ release_dotlock( DOTLOCK h )
 #else
     int pid;
 
+    /* To avoid atexit race conditions we first check whether there
+       are any locks left.  It might happen that another atexit
+       handler tries to release the lock while the atexit handler of
+       this module already ran and thus H is undefined.  */
+    if(!all_lockfiles)
+        return 0;
+
     if( h->disable ) {
 	return 0;
     }
@@ -414,22 +461,16 @@ void
 dotlock_remove_lockfiles()
 {
 #ifndef HAVE_DOSISH_SYSTEM
-    DOTLOCK h, h2;
-
-    h = all_lockfiles;
-    all_lockfiles = NULL;
-
-    while( h ) {
-	h2 = h->next;
-        if (!h->disable ) {
-          if( h->locked )
-	    unlink( h->lockname );
-          unlink(h->tname);
-          jnlib_free(h->tname);
-          jnlib_free(h->lockname);
-        }
-	jnlib_free(h);
-	h = h2;
+  DOTLOCK h, h2;
+  
+  h = all_lockfiles;
+  all_lockfiles = NULL;
+    
+  while ( h )
+    {
+      h2 = h->next;
+      destroy_dotlock (h);
+      h = h2;
     }
 #endif
 }
diff --git a/jnlib/dotlock.h b/jnlib/dotlock.h
index 9235687df..2cb39008a 100644
--- a/jnlib/dotlock.h
+++ b/jnlib/dotlock.h
@@ -26,6 +26,7 @@ typedef struct dotlock_handle *DOTLOCK;
 
 void disable_dotlock (void);
 DOTLOCK create_dotlock(const char *file_to_lock);
+void destroy_dotlock ( DOTLOCK h );
 int make_dotlock (DOTLOCK h, long timeout);
 int release_dotlock (DOTLOCK h);
 void dotlock_remove_lockfiles (void);
diff --git a/jnlib/libjnlib-config.h b/jnlib/libjnlib-config.h
index 8ae2a9ce9..da3991432 100644
--- a/jnlib/libjnlib-config.h
+++ b/jnlib/libjnlib-config.h
@@ -30,31 +30,31 @@
 #include "logging.h"
 
 /* We require support for utf-8 conversion. */
-#define JNLIB_NEED_UTF8CONF 1
+#define JNLIB_NEED_UTF8CONV 1
 
 #ifdef USE_SIMPLE_GETTEXT
   int set_gettext_file( const char *filename );
   const char *gettext( const char *msgid );
 
-  #define _(a) gettext (a)
-  #define N_(a) (a)
+# define _(a) gettext (a)
+# define N_(a) (a)
 
 #else
 #ifdef HAVE_LOCALE_H
-  #include <locale.h>
+#  include <locale.h>
 #endif
 
 #ifdef ENABLE_NLS
-  #include <libintl.h>
-  #define _(a) gettext (a)
-  #ifdef gettext_noop
-    #define N_(a) gettext_noop (a)
-  #else
-    #define N_(a) (a)
-  #endif
+# include <libintl.h>
+# define _(a) gettext (a)
+# ifdef gettext_noop
+# define N_(a) gettext_noop (a)
+# else
+# define N_(a) (a)
+# endif
 #else
-  #define _(a) (a)
-  #define N_(a) (a)
+# define _(a) (a)
+# define N_(a) (a)
 #endif
 #endif /* !USE_SIMPLE_GETTEXT */
 
diff --git a/jnlib/stringhelp.c b/jnlib/stringhelp.c
index d5a2c29b6..27b8a25e8 100644
--- a/jnlib/stringhelp.c
+++ b/jnlib/stringhelp.c
@@ -218,8 +218,8 @@ length_sans_trailing_chars (const unsigned char *line, size_t len,
   return len;
 }
 
-/****************
- * remove trailing white spaces and return the length of the buffer
+/*
+ *  Return the length of line ignoring trailing white-space.
  */
 size_t
 length_sans_trailing_ws (const unsigned char *line, size_t len)
@@ -336,34 +336,86 @@ compare_filenames( const char *a, const char *b )
 #endif
 }
 
+
+/* Convert 2 hex characters at S to a byte value.  Return this value
+   or -1 if there is an error. */
+int
+hextobyte (const char *s)
+{
+  int c;
+
+  if ( *s >= '0' && *s <= '9' )
+    c = 16 * (*s - '0');
+  else if ( *s >= 'A' && *s <= 'F' )
+    c = 16 * (10 + *s - 'A');
+  else if ( *s >= 'a' && *s <= 'f' )
+    c = 16 * (10 + *s - 'a');
+  else
+    return -1;
+  s++;
+  if ( *s >= '0' && *s <= '9' )
+    c += *s - '0';
+  else if ( *s >= 'A' && *s <= 'F' )
+    c += 10 + *s - 'A';
+  else if ( *s >= 'a' && *s <= 'f' )
+    c += 10 + *s - 'a';
+  else
+    return -1;
+  return c;
+}
+
+
 /* Print a BUFFER to stream FP while replacing all control characters
-   and the character DELIM with standard C escape sequences.  Returns
-   the number of characters printed. */
+   and the characters DELIM and DELIM2 with standard C escape
+   sequences.  Returns the number of characters printed. */
 size_t 
-print_sanitized_buffer (FILE *fp, const void *buffer, size_t length,
-                        int delim)
+print_sanitized_buffer2 (FILE *fp, const void *buffer, size_t length,
+                         int delim, int delim2)
 {
   const unsigned char *p = buffer;
   size_t count = 0;
 
   for (; length; length--, p++, count++)
     {
-      if (*p < 0x20 || *p == 0x7f || *p == delim)
+      /* Fixme: Check whether *p < 0xa0 is correct for utf8 encoding. */
+      if (*p < 0x20 
+          || (*p >= 0x7f && *p < 0xa0)
+          || *p == delim 
+          || *p == delim2
+          || ((delim || delim2) && *p=='\\'))
         {
           putc ('\\', fp);
           count++;
           if (*p == '\n')
-            putc ('n', fp);
+            {
+              putc ('n', fp);
+              count++;
+            }
           else if (*p == '\r')
-            putc ('r', fp);
+            {
+              putc ('r', fp);
+              count++;
+            }
           else if (*p == '\f')
-            putc ('f', fp);
+            {
+              putc ('f', fp);
+              count++;
+            }
           else if (*p == '\v')
-            putc ('v', fp);
+            {
+              putc ('v', fp);
+              count++;
+            }
           else if (*p == '\b')
-            putc ('b', fp);
+            {
+              putc ('b', fp);
+              count++;
+            }
           else if (!*p)
-            putc('0', fp);
+            {
+              putc('0', fp);
+              count++;
+            }
           else
             {
               fprintf (fp, "x%02x", *p);
@@ -371,12 +423,24 @@ print_sanitized_buffer (FILE *fp, const void *buffer, size_t length,
             }
 	}
       else
-        putc (*p, fp);
+        {
+          putc (*p, fp);
+          count++;
+        }
     }
 
   return count;
 }
 
+/* Same as print_sanitized_buffer2 but with just one delimiter. */
+size_t 
+print_sanitized_buffer (FILE *fp, const void *buffer, size_t length,
+                        int delim)
+{
+  return print_sanitized_buffer2 (fp, buffer, length, delim, 0);
+}
+
+
 size_t 
 print_sanitized_utf8_buffer (FILE *fp, const void *buffer,
                              size_t length, int delim)
@@ -405,6 +469,13 @@ print_sanitized_utf8_buffer (FILE *fp, const void *buffer,
 
 
 size_t 
+print_sanitized_string2 (FILE *fp, const char *string, int delim, int delim2)
+{
+  return string? print_sanitized_buffer2 (fp, string, strlen (string),
+                                          delim, delim2):0;
+}
+
+size_t 
 print_sanitized_string (FILE *fp, const char *string, int delim)
 {
   return string? print_sanitized_buffer (fp, string, strlen (string), delim):0;
diff --git a/jnlib/stringhelp.h b/jnlib/stringhelp.h
index 4c9e66452..405d6dbc4 100644
--- a/jnlib/stringhelp.h
+++ b/jnlib/stringhelp.h
@@ -40,11 +40,17 @@ char *make_dirname(const char *filepath);
 char *make_filename( const char *first_part, ... );
 int compare_filenames( const char *a, const char *b );
 
+int hextobyte (const char *s);
+
 size_t print_sanitized_buffer (FILE *fp, const void *buffer, size_t length,
                                int delim);
+size_t print_sanitized_buffer2 (FILE *fp, const void *buffer, size_t length,
+                                int delim, int delim2);
 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_string2 (FILE *fp, const char *string,
+                                int delim, int delim2);
 size_t print_sanitized_utf8_string (FILE *fp, const char *string, int delim);
 char *sanitize_buffer (const void *p, size_t n, int delim);
 
diff --git a/jnlib/strlist.c b/jnlib/strlist.c
index d1924c102..52b4d5869 100644
--- a/jnlib/strlist.c
+++ b/jnlib/strlist.c
@@ -95,22 +95,24 @@ append_to_strlist( strlist_t *list, const char *string )
     return sl;
 }
 
-#if 0
+
+#ifdef JNLIB_NEED_UTF8CONV
 strlist_t
 append_to_strlist2( strlist_t *list, const char *string, int is_utf8 )
 {
-    strlist_t sl;
-
-    if( is_utf8 )
-	sl = append_to_strlist( list, string );
-    else {
-	char *p = native_to_utf8( string );
-	sl = append_to_strlist( list, p );
-	m_free( p );
+  strlist_t sl;
+    
+  if( is_utf8 )
+    sl = append_to_strlist( list, string );
+  else
+    {
+      char *p = native_to_utf8 (string);
+      sl = append_to_strlist( list, p );
+      jnlib_free( p );
     }
-    return sl;
+  return sl;
 }
-#endif
+#endif /* JNLIB_NEED_UTF8CONV */
 
 
 /* Return a copy of LIST. */
diff --git a/jnlib/strlist.h b/jnlib/strlist.h
index 47ac5bd4e..3c1252a44 100644
--- a/jnlib/strlist.h
+++ b/jnlib/strlist.h
@@ -35,11 +35,11 @@ strlist_t add_to_strlist (strlist_t *list, const char *string);
 strlist_t add_to_strlist2( strlist_t *list, const char *string, int is_utf8);
 
 strlist_t append_to_strlist (strlist_t *list, const char *string);
+strlist_t append_to_strlist2 (strlist_t *list, const char *string,
+                              int is_utf8);
 
 strlist_t strlist_copy (strlist_t list);
 
-/*strlist_t append_to_strlist2( strlist_t *list, const char *string,
-                              int is_utf8);*/
 strlist_t strlist_prev (strlist_t head, strlist_t node);
 strlist_t strlist_last (strlist_t node);
 char * strlist_pop (strlist_t *list);