Add files to new directory.
authorWerner Koch <wk@gnupg.org>
Mon, 24 Jan 2000 12:05:50 +0000 (12:05 +0000)
committerWerner Koch <wk@gnupg.org>
Mon, 24 Jan 2000 12:05:50 +0000 (12:05 +0000)
This is mainly stuff moved from ../util
to here.

14 files changed:
jnlib/Makefile.am [new file with mode: 0644]
jnlib/README [new file with mode: 0644]
jnlib/argparse.c [new file with mode: 0644]
jnlib/argparse.h [new file with mode: 0644]
jnlib/dotlock.c [new file with mode: 0644]
jnlib/dotlock.h [new file with mode: 0644]
jnlib/libjnlib-config.h [new file with mode: 0644]
jnlib/logging.c [new file with mode: 0644]
jnlib/logging.h [new file with mode: 0644]
jnlib/mischelp.h [new file with mode: 0644]
jnlib/stringhelp.c [new file with mode: 0644]
jnlib/stringhelp.h [new file with mode: 0644]
jnlib/xmalloc.c [new file with mode: 0644]
jnlib/xmalloc.h [new file with mode: 0644]

diff --git a/jnlib/Makefile.am b/jnlib/Makefile.am
new file mode 100644 (file)
index 0000000..b16724d
--- /dev/null
@@ -0,0 +1,19 @@
+## Process this file with automake to produce Makefile.in
+
+# Those 2 files are in the CVS but currently not used.
+EXTRA_DIST = README xmalloc.c xmalloc.h logging.c logging.c
+
+INCLUDES = -I$(top_srcdir)/include -I$(top_srcdir)/intl
+
+noinst_LTLIBRARIES = libjnlib.la
+
+
+libjnlib_la_LDFLAGS =
+libjnlib_la_SOURCES = libjnlib-config.h          \
+                     argparse.c argparse.h     \
+                     stringhelp.c stringhelp.h \
+                     dotlock.c dotlock.h \
+                     mischelp.h
+
+
+
diff --git a/jnlib/README b/jnlib/README
new file mode 100644 (file)
index 0000000..694c378
--- /dev/null
@@ -0,0 +1,7 @@
+jnlib - this is a collection of utility function which are
+too small to put into a library.
+
+libjnlib-config.h should be be modified for each project
+to make these functions fit into the software. Mainly these
+are memory functions in case you need another allocaort (like gcrypt).
+
diff --git a/jnlib/argparse.c b/jnlib/argparse.c
new file mode 100644 (file)
index 0000000..3f77805
--- /dev/null
@@ -0,0 +1,994 @@
+/* [argparse.c wk 17.06.97] Argument Parser for option handling
+ *     Copyright (C) 1998,1999 Free Software Foundation, Inc.
+ *  This file is part of GnuPG.
+ *
+ *  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.
+ *
+ *  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.
+ *
+ *  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
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "libjnlib-config.h"
+#include "mischelp.h"
+#include "stringhelp.h"
+#include "logging.h"
+#include "argparse.h"
+
+
+/*********************************
+ * @Summary arg_parse
+ *  #include <wk/lib.h>
+ *
+ *  typedef struct {
+ *     char *argc;               pointer to argc (value subject to change)
+ *     char ***argv;             pointer to argv (value subject to change)
+ *     unsigned flags;           Global flags (DO NOT CHANGE)
+ *     int err;                  print error about last option
+ *                               1 = warning, 2 = abort
+ *     int r_opt;                return option
+ *     int r_type;               type of return value (0 = no argument found)
+ *     union {
+ *         int   ret_int;
+ *         long  ret_long
+ *         ulong ret_ulong;
+ *         char *ret_str;
+ *     } r;                      Return values
+ *     struct {
+ *         int idx;
+ *         const char *last;
+ *         void *aliases;
+ *     } internal;               DO NOT CHANGE
+ *  } ARGPARSE_ARGS;
+ *
+ *  typedef struct {
+ *     int         short_opt;
+ *     const char *long_opt;
+ *     unsigned flags;
+ *  } ARGPARSE_OPTS;
+ *
+ *  int arg_parse( ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts );
+ *
+ * @Description
+ *  This is my replacement for getopt(). See the example for a typical usage.
+ *  Global flags are:
+ *     Bit 0 : Do not remove options form argv
+ *     Bit 1 : Do not stop at last option but return other args
+ *            with r_opt set to -1.
+ *     Bit 2 : Assume options and real args are mixed.
+ *     Bit 3 : Do not use -- to stop option processing.
+ *     Bit 4 : Do not skip the first arg.
+ *     Bit 5 : allow usage of long option with only one dash
+ *     Bit 6 : ignore --version
+ *     all other bits must be set to zero, this value is modified by the
+ *     function, so assume this is write only.
+ *  Local flags (for each option):
+ *     Bit 2-0 : 0 = does not take an argument
+ *              1 = takes int argument
+ *              2 = takes string argument
+ *              3 = takes long argument
+ *              4 = takes ulong argument
+ *     Bit 3 : argument is optional (r_type will the be set to 0)
+ *     Bit 4 : allow 0x etc. prefixed values.
+ *     Bit 7 : this is a command and not an option
+ *  You stop the option processing by setting opts to NULL, the function will
+ *  then return 0.
+ * @Return Value
+ *   Returns the args.r_opt or 0 if ready
+ *   r_opt may be -2/-7 to indicate an unknown option/command.
+ * @See Also
+ *   ArgExpand
+ * @Notes
+ *  You do not need to process the options 'h', '--help' or '--version'
+ *  because this function includes standard help processing; but if you
+ *  specify '-h', '--help' or '--version' you have to do it yourself.
+ *  The option '--' stops argument processing; if bit 1 is set the function
+ *  continues to return normal arguments.
+ *  To process float args or unsigned args you must use a string args and do
+ *  the conversion yourself.
+ * @Example
+ *
+ *     ARGPARSE_OPTS opts[] = {
+ *     { 'v', "verbose",   0 },
+ *     { 'd', "debug",     0 },
+ *     { 'o', "output",    2 },
+ *     { 'c', "cross-ref", 2|8 },
+ *     { 'm', "my-option", 1|8 },
+ *     { 500, "have-no-short-option-for-this-long-option", 0 },
+ *     {0} };
+ *     ARGPARSE_ARGS pargs = { &argc, &argv, 0 }
+ *
+ *     while( ArgParse( &pargs, &opts) ) {
+ *        switch( pargs.r_opt ) {
+ *          case 'v': opt.verbose++; break;
+ *          case 'd': opt.debug++; break;
+ *          case 'o': opt.outfile = pargs.r.ret_str; break;
+ *          case 'c': opt.crf = pargs.r_type? pargs.r.ret_str:"a.crf"; break;
+ *          case 'm': opt.myopt = pargs.r_type? pargs.r.ret_int : 1; break;
+ *          case 500: opt.a_long_one++;  break
+ *          default : pargs.err = 1; break; -- force warning output --
+ *        }
+ *     }
+ *     if( argc > 1 )
+ *        log_fatal( "Too many args");
+ *
+ */
+
+typedef struct alias_def_s *ALIAS_DEF;
+struct alias_def_s {
+    ALIAS_DEF next;
+    char *name;   /* malloced buffer with name, \0, value */
+    const char *value; /* ptr into name */
+};
+
+static const char *(*strusage_handler)( int ) = NULL;
+
+static int  set_opt_arg(ARGPARSE_ARGS *arg, unsigned flags, char *s);
+static void show_help(ARGPARSE_OPTS *opts, unsigned flags);
+static void show_version(void);
+
+
+static void
+initialize( ARGPARSE_ARGS *arg, const char *filename, unsigned *lineno )
+{
+    if( !(arg->flags & (1<<15)) ) { /* initialize this instance */
+       arg->internal.idx = 0;
+       arg->internal.last = NULL;
+       arg->internal.inarg = 0;
+       arg->internal.stopped = 0;
+       arg->internal.aliases = NULL;
+       arg->internal.cur_alias = NULL;
+       arg->err = 0;
+       arg->flags |= 1<<15; /* mark initialized */
+       if( *arg->argc < 0 )
+           jnlib_log_bug("Invalid argument for ArgParse\n");
+    }
+
+
+    if( arg->err ) { /* last option was erroneous */
+       const char *s;
+
+       if( filename ) {
+           if( arg->r_opt == -6 )
+               s = "%s:%u: argument not expected\n";
+           else if( arg->r_opt == -5 )
+               s = "%s:%u: read error\n";
+           else if( arg->r_opt == -4 )
+               s = "%s:%u: keyword too long\n";
+           else if( arg->r_opt == -3 )
+               s = "%s:%u: missing argument\n";
+           else if( arg->r_opt == -7 )
+               s = "%s:%u: invalid command\n";
+           else if( arg->r_opt == -10 )
+               s = "%s:%u: invalid alias definition\n";
+           else
+               s = "%s:%u: invalid option\n";
+           jnlib_log_error(s, filename, *lineno );
+       }
+       else {
+           if( arg->r_opt == -3 )
+               s = "Missing argument for option \"%.50s\"\n";
+           else if( arg->r_opt == -6 )
+               s = "Option \"%.50s\" does not expect an argument\n";
+           else if( arg->r_opt == -7 )
+               s = "Invalid command \"%.50s\"\n";
+           else if( arg->r_opt == -8 )
+               s = "Option \"%.50s\" is ambiguous\n";
+           else if( arg->r_opt == -9 )
+               s = "Command \"%.50s\" is ambiguous\n";
+           else
+               s = "Invalid option \"%.50s\"\n";
+           jnlib_log_error(s, arg->internal.last? arg->internal.last:"[??]" );
+       }
+       if( arg->err != 1 )
+           exit(2);
+       arg->err = 0;
+    }
+
+    /* clearout the return value union */
+    arg->r.ret_str = NULL;
+    arg->r.ret_long= 0;
+}
+
+
+static void
+store_alias( ARGPARSE_ARGS *arg, char *name, char *value )
+{
+    /* TODO: replace this dummy function with a rea one
+     * and fix the probelms IRIX has with (ALIAS_DEV)arg..
+     * used as lvalue
+     */
+#if 0
+    ALIAS_DEF a = jnlib_xmalloc( sizeof *a );
+    a->name = name;
+    a->value = value;
+    a->next = (ALIAS_DEF)arg->internal.aliases;
+    (ALIAS_DEF)arg->internal.aliases = a;
+#endif
+}
+
+/****************
+ * Get options from a file.
+ * Lines starting with '#' are comment lines.
+ * Syntax is simply a keyword and the argument.
+ * Valid keywords are all keywords from the long_opt list without
+ * the leading dashes. The special keywords "help", "warranty" and "version"
+ * are not valid here.
+ * The special keyword "alias" may be used to store alias definitions,
+ * which are later expanded like long options.
+ * Caller must free returned strings.
+ * If called with FP set to NULL command line args are parse instead.
+ *
+ * Q: Should we allow the syntax
+ *     keyword = value
+ *    and accept for boolean options a value of 1/0, yes/no or true/false?
+ * Note: Abbreviation of options is here not allowed.
+ */
+int
+optfile_parse( FILE *fp, const char *filename, unsigned *lineno,
+              ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts)
+{
+    int state, i, c;
+    int idx=0;
+    char keyword[100];
+    char *buffer = NULL;
+    size_t buflen = 0;
+    int inverse=0;
+    int in_alias=0;
+
+    if( !fp ) /* same as arg_parse() in this case */
+       return arg_parse( arg, opts );
+
+    initialize( arg, filename, lineno );
+
+    /* find the next keyword */
+    state = i = 0;
+    for(;;) {
+       c=getc(fp);
+       if( c == '\n' || c== EOF ) {
+           if( c != EOF )
+               ++*lineno;
+           if( state == -1 )
+               break;
+           else if( state == 2 ) {
+               keyword[i] = 0;
+               for(i=0; opts[i].short_opt; i++ )
+                   if( opts[i].long_opt && !strcmp( opts[i].long_opt, keyword) )
+                       break;
+               idx = i;
+               arg->r_opt = opts[idx].short_opt;
+               if( inverse ) /* this does not have an effect, hmmm */
+                   arg->r_opt = -arg->r_opt;
+               if( !opts[idx].short_opt )   /* unknown command/option */
+                   arg->r_opt = (opts[idx].flags & 256)? -7:-2;
+               else if( (opts[idx].flags & 8) ) /* no argument */
+                   arg->r_opt = -3;           /* error */
+               else                           /* no or optional argument */
+                   arg->r_type = 0;           /* okay */
+               break;
+           }
+           else if( state == 3 ) {            /* no argument found */
+               if( in_alias )
+                   arg->r_opt = -3;           /* error */
+               else if( !(opts[idx].flags & 7) ) /* does not take an arg */
+                   arg->r_type = 0;           /* okay */
+               else if( (opts[idx].flags & 8) )  /* no optional argument */
+                   arg->r_type = 0;           /* okay */
+               else                           /* no required argument */
+                   arg->r_opt = -3;           /* error */
+               break;
+           }
+           else if( state == 4 ) {     /* have an argument */
+               if( in_alias ) {
+                   if( !buffer )
+                       arg->r_opt = -6;
+                   else {
+                       char *p;
+
+                       buffer[i] = 0;
+                       p = strpbrk( buffer, " \t" );
+                       if( p ) {
+                           *p++ = 0;
+                           trim_spaces( p );
+                       }
+                       if( !p || !*p ) {
+                           jnlib_free( buffer );
+                           arg->r_opt = -10;
+                       }
+                       else {
+                           store_alias( arg, buffer, p );
+                       }
+                   }
+               }
+               else if( !(opts[idx].flags & 7) )  /* does not take an arg */
+                   arg->r_opt = -6;        /* error */
+               else {
+                   char *p;
+                   if( !buffer ) {
+                       keyword[i] = 0;
+                       buffer = jnlib_xstrdup(keyword);
+                   }
+                   else
+                       buffer[i] = 0;
+
+                   trim_spaces( buffer );
+                   p = buffer;
+                   if( *p == '"' ) { /* remove quotes */
+                       p++;
+                       if( *p && p[strlen(p)-1] == '"' )
+                           p[strlen(p)-1] = 0;
+                   }
+                   if( !set_opt_arg(arg, opts[idx].flags, p) )
+                       jnlib_free(buffer);
+               }
+               break;
+           }
+           else if( c == EOF ) {
+               if( ferror(fp) )
+                   arg->r_opt = -5;   /* read error */
+               else
+                   arg->r_opt = 0;    /* eof */
+               break;
+           }
+           state = 0;
+           i = 0;
+       }
+       else if( state == -1 )
+           ; /* skip */
+       else if( !state && isspace(c) )
+           ; /* skip leading white space */
+       else if( !state && c == '#' )
+           state = 1;  /* start of a comment */
+       else if( state == 1 )
+           ; /* skip comments */
+       else if( state == 2 && isspace(c) ) {
+           keyword[i] = 0;
+           for(i=0; opts[i].short_opt; i++ )
+               if( opts[i].long_opt && !strcmp( opts[i].long_opt, keyword) )
+                   break;
+           idx = i;
+           arg->r_opt = opts[idx].short_opt;
+           if( !opts[idx].short_opt ) {
+               if( !strcmp( keyword, "alias" ) ) {
+                   in_alias = 1;
+                   state = 3;
+               }
+               else {
+                   arg->r_opt = (opts[idx].flags & 256)? -7:-2;
+                   state = -1;        /* skip rest of line and leave */
+               }
+           }
+           else
+               state = 3;
+       }
+       else if( state == 3 ) { /* skip leading spaces of the argument */
+           if( !isspace(c) ) {
+               i = 0;
+               keyword[i++] = c;
+               state = 4;
+           }
+       }
+       else if( state == 4 ) { /* collect the argument */
+           if( buffer ) {
+               if( i < buflen-1 )
+                   buffer[i++] = c;
+               else {
+                   buflen += 50;
+                   buffer = jnlib_xrealloc(buffer, buflen);
+                   buffer[i++] = c;
+               }
+           }
+           else if( i < DIM(keyword)-1 )
+               keyword[i++] = c;
+           else {
+               buflen = DIM(keyword)+50;
+               buffer = jnlib_xmalloc(buflen);
+               memcpy(buffer, keyword, i);
+               buffer[i++] = c;
+           }
+       }
+       else if( i >= DIM(keyword)-1 ) {
+           arg->r_opt = -4;   /* keyword to long */
+           state = -1;        /* skip rest of line and leave */
+       }
+       else {
+           keyword[i++] = c;
+           state = 2;
+       }
+    }
+
+    return arg->r_opt;
+}
+
+
+
+static int
+find_long_option( ARGPARSE_ARGS *arg,
+                 ARGPARSE_OPTS *opts, const char *keyword )
+{
+    int i;
+    size_t n;
+
+    /* Would be better if we can do a binary search, but it is not
+       possible to reorder our option table because we would mess
+       up our help strings - What we can do is: Build a nice option
+       lookup table wehn this function is first invoked */
+    if( !*keyword )
+       return -1;
+    for(i=0; opts[i].short_opt; i++ )
+       if( opts[i].long_opt && !strcmp( opts[i].long_opt, keyword) )
+           return i;
+  #if 0
+    {
+       ALIAS_DEF a;
+       /* see whether it is an alias */
+       for( a = args->internal.aliases; a; a = a->next ) {
+           if( !strcmp( a->name, keyword) ) {
+               /* todo: must parse the alias here */
+               args->internal.cur_alias = a;
+               return -3; /* alias available */
+           }
+       }
+    }
+  #endif
+    /* not found, see whether it is an abbreviation */
+    /* aliases may not be abbreviated */
+    n = strlen( keyword );
+    for(i=0; opts[i].short_opt; i++ ) {
+       if( opts[i].long_opt && !strncmp( opts[i].long_opt, keyword, n ) ) {
+           int j;
+           for(j=i+1; opts[j].short_opt; j++ ) {
+               if( opts[j].long_opt
+                   && !strncmp( opts[j].long_opt, keyword, n ) )
+                   return -2;  /* abbreviation is ambiguous */
+           }
+           return i;
+       }
+    }
+    return -1;
+}
+
+int
+arg_parse( ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts)
+{
+    int idx;
+    int argc;
+    char **argv;
+    char *s, *s2;
+    int i;
+
+    initialize( arg, NULL, NULL );
+    argc = *arg->argc;
+    argv = *arg->argv;
+    idx = arg->internal.idx;
+
+    if( !idx && argc && !(arg->flags & (1<<4)) ) { /* skip the first entry */
+       argc--; argv++; idx++;
+    }
+
+  next_one:
+    if( !argc ) { /* no more args */
+       arg->r_opt = 0;
+       goto leave; /* ready */
+    }
+
+    s = *argv;
+    arg->internal.last = s;
+
+    if( arg->internal.stopped && (arg->flags & (1<<1)) ) {
+       arg->r_opt = -1;  /* not an option but a argument */
+       arg->r_type = 2;
+       arg->r.ret_str = s;
+       argc--; argv++; idx++; /* set to next one */
+    }
+    else if( arg->internal.stopped ) { /* ready */
+       arg->r_opt = 0;
+       goto leave;
+    }
+    else if( *s == '-' && s[1] == '-' ) { /* long option */
+       char *argpos;
+
+       arg->internal.inarg = 0;
+       if( !s[2] && !(arg->flags & (1<<3)) ) { /* stop option processing */
+           arg->internal.stopped = 1;
+           argc--; argv++; idx++;
+           goto next_one;
+       }
+
+       argpos = strchr( s+2, '=' );
+       if( argpos )
+           *argpos = 0;
+       i = find_long_option( arg, opts, s+2 );
+       if( argpos )
+           *argpos = '=';
+
+       if( i < 0 && !strcmp( "help", s+2) )
+           show_help(opts, arg->flags);
+       else if( i < 0 && !strcmp( "version", s+2) ) {
+           if( !(arg->flags & (1<<6)) ) {
+               show_version();
+               exit(0);
+           }
+       }
+       else if( i < 0 && !strcmp( "warranty", s+2) ) {
+           puts( strusage(16) );
+           exit(0);
+       }
+       else if( i < 0 && !strcmp( "dump-options", s+2) ) {
+           for(i=0; opts[i].short_opt; i++ ) {
+               if( opts[i].long_opt )
+                   printf( "--%s\n", opts[i].long_opt );
+           }
+           fputs("--dump-options\n--help\n--version\n--warranty\n", stdout );
+           exit(0);
+       }
+
+       if( i == -2 ) /* ambiguous option */
+           arg->r_opt = -8;
+       else if( i == -1 ) {
+           arg->r_opt = -2;
+           arg->r.ret_str = s+2;
+       }
+       else
+           arg->r_opt = opts[i].short_opt;
+       if( i < 0 )
+           ;
+       else if( (opts[i].flags & 7) ) {
+           if( argpos ) {
+               s2 = argpos+1;
+               if( !*s2 )
+                   s2 = NULL;
+           }
+           else
+               s2 = argv[1];
+           if( !s2 && (opts[i].flags & 8) ) { /* no argument but it is okay*/
+               arg->r_type = 0;               /* because it is optional */
+           }
+           else if( !s2 ) {
+               arg->r_opt = -3; /* missing argument */
+           }
+           else if( !argpos && *s2 == '-' && (opts[i].flags & 8) ) {
+               /* the argument is optional and the next seems to be
+                * an option. We do not check this possible option
+                * but assume no argument */
+               arg->r_type = 0;
+           }
+           else {
+               set_opt_arg(arg, opts[i].flags, s2);
+               if( !argpos ) {
+                   argc--; argv++; idx++; /* skip one */
+               }
+           }
+       }
+       else { /* does not take an argument */
+           if( argpos )
+               arg->r_type = -6; /* argument not expected */
+           else
+               arg->r_type = 0;
+       }
+       argc--; argv++; idx++; /* set to next one */
+    }
+    else if( (*s == '-' && s[1]) || arg->internal.inarg ) { /* short option */
+       int dash_kludge = 0;
+       i = 0;
+       if( !arg->internal.inarg ) {
+           arg->internal.inarg++;
+           if( arg->flags & (1<<5) ) {
+               for(i=0; opts[i].short_opt; i++ )
+                   if( opts[i].long_opt && !strcmp( opts[i].long_opt, s+1)) {
+                       dash_kludge=1;
+                       break;
+                   }
+           }
+       }
+       s += arg->internal.inarg;
+
+       if( !dash_kludge ) {
+           for(i=0; opts[i].short_opt; i++ )
+               if( opts[i].short_opt == *s )
+                   break;
+       }
+
+       if( !opts[i].short_opt && ( *s == 'h' || *s == '?' ) )
+           show_help(opts, arg->flags);
+
+       arg->r_opt = opts[i].short_opt;
+       if( !opts[i].short_opt ) {
+           arg->r_opt = (opts[i].flags & 256)? -7:-2;
+           arg->internal.inarg++; /* point to the next arg */
+           arg->r.ret_str = s;
+       }
+       else if( (opts[i].flags & 7) ) {
+           if( s[1] && !dash_kludge ) {
+               s2 = s+1;
+               set_opt_arg(arg, opts[i].flags, s2);
+           }
+           else {
+               s2 = argv[1];
+               if( !s2 && (opts[i].flags & 8) ) { /* no argument but it is okay*/
+                   arg->r_type = 0;               /* because it is optional */
+               }
+               else if( !s2 ) {
+                   arg->r_opt = -3; /* missing argument */
+               }
+               else if( *s2 == '-' && s2[1] && (opts[i].flags & 8) ) {
+                   /* the argument is optional and the next seems to be
+                    * an option. We do not check this possible option
+                    * but assume no argument */
+                   arg->r_type = 0;
+               }
+               else {
+                   set_opt_arg(arg, opts[i].flags, s2);
+                   argc--; argv++; idx++; /* skip one */
+               }
+           }
+           s = "x"; /* so that !s[1] yields false */
+       }
+       else { /* does not take an argument */
+           arg->r_type = 0;
+           arg->internal.inarg++; /* point to the next arg */
+       }
+       if( !s[1] || dash_kludge ) { /* no more concatenated short options */
+           arg->internal.inarg = 0;
+           argc--; argv++; idx++;
+       }
+    }
+    else if( arg->flags & (1<<2) ) {
+       arg->r_opt = -1;  /* not an option but a argument */
+       arg->r_type = 2;
+       arg->r.ret_str = s;
+       argc--; argv++; idx++; /* set to next one */
+    }
+    else {
+       arg->internal.stopped = 1; /* stop option processing */
+       goto next_one;
+    }
+
+  leave:
+    *arg->argc = argc;
+    *arg->argv = argv;
+    arg->internal.idx = idx;
+    return arg->r_opt;
+}
+
+
+
+static int
+set_opt_arg(ARGPARSE_ARGS *arg, unsigned flags, char *s)
+{
+    int base = (flags & 16)? 0 : 10;
+
+    switch( arg->r_type = (flags & 7) ) {
+      case 1: /* takes int argument */
+       arg->r.ret_int = (int)strtol(s,NULL,base);
+       return 0;
+      case 3: /* takes long argument   */
+       arg->r.ret_long= strtol(s,NULL,base);
+       return 0;
+      case 4: /* takes ulong argument  */
+       arg->r.ret_ulong= strtoul(s,NULL,base);
+       return 0;
+      case 2: /* takes string argument */
+      default:
+       arg->r.ret_str = s;
+       return 1;
+    }
+}
+
+
+static size_t
+long_opt_strlen( ARGPARSE_OPTS *o )
+{
+    size_t n = strlen(o->long_opt);
+
+    if( o->description && *o->description == '|' ) {
+       const char *s;
+
+       s=o->description+1;
+       if( *s != '=' )
+           n++;
+       for(; *s && *s != '|'; s++ )
+           n++;
+    }
+    return n;
+}
+
+/****************
+ * Print formatted help. The description string has some special
+ * meanings:
+ *  - A description string which is "@" suppresses help output for
+ *    this option
+ *  - a description,ine which starts with a '@' and is followed by
+ *    any other characters is printed as is; this may be used for examples
+ *    ans such.
+ *  - A description which starts with a '|' outputs the string between this
+ *    bar and the next one as arguments of the long option.
+ */
+static void
+show_help( ARGPARSE_OPTS *opts, unsigned flags )
+{
+    const char *s;
+
+    show_version();
+    putchar('\n');
+    s = strusage(41);
+    puts(s);
+    if( opts[0].description ) { /* auto format the option description */
+       int i,j, indent;
+       /* get max. length of long options */
+       for(i=indent=0; opts[i].short_opt; i++ ) {
+           if( opts[i].long_opt )
+               if( !opts[i].description || *opts[i].description != '@' )
+                   if( (j=long_opt_strlen(opts+i)) > indent && j < 35 )
+                        indent = j;
+       }
+       /* example: " -v, --verbose   Viele Sachen ausgeben" */
+       indent += 10;
+       if( *opts[0].description != '@' )
+           puts("Options:");
+       for(i=0; opts[i].short_opt; i++ ) {
+           s = _( opts[i].description );
+           if( s && *s== '@' && !s[1] ) /* hide this line */
+               continue;
+           if( s && *s == '@' ) { /* unindented comment only line */
+               for(s++; *s; s++ ) {
+                   if( *s == '\n' ) {
+                       if( s[1] )
+                           putchar('\n');
+                   }
+                   else
+                       putchar(*s);
+               }
+               putchar('\n');
+               continue;
+           }
+
+           j = 3;
+           if( opts[i].short_opt < 256 ) {
+               printf(" -%c", opts[i].short_opt );
+               if( !opts[i].long_opt ) {
+                   if(s && *s == '|' ) {
+                       putchar(' '); j++;
+                       for(s++ ; *s && *s != '|'; s++, j++ )
+                           putchar(*s);
+                       if( *s )
+                           s++;
+                   }
+               }
+           }
+           else
+               fputs("   ", stdout);
+           if( opts[i].long_opt ) {
+               j += printf("%c --%s", opts[i].short_opt < 256?',':' ',
+                                      opts[i].long_opt );
+               if(s && *s == '|' ) {
+                   if( *++s != '=' ) {
+                       putchar(' ');
+                       j++;
+                   }
+                   for( ; *s && *s != '|'; s++, j++ )
+                       putchar(*s);
+                   if( *s )
+                       s++;
+               }
+               fputs("   ", stdout);
+               j += 3;
+           }
+           for(;j < indent; j++ )
+               putchar(' ');
+           if( s ) {
+               if( *s && j > indent ) {
+                   putchar('\n');
+                   for(j=0;j < indent; j++ )
+                       putchar(' ');
+               }
+               for(; *s; s++ ) {
+                   if( *s == '\n' ) {
+                       if( s[1] ) {
+                           putchar('\n');
+                           for(j=0;j < indent; j++ )
+                               putchar(' ');
+                       }
+                   }
+                   else
+                       putchar(*s);
+               }
+           }
+           putchar('\n');
+       }
+       if( flags & 32 )
+           puts("\n(A single dash may be used instead of the double ones)");
+    }
+    if( (s=strusage(19)) ) {  /* bug reports to ... */
+       putchar('\n');
+       fputs(s, stdout);
+    }
+    fflush(stdout);
+    exit(0);
+}
+
+static void
+show_version()
+{
+    const char *s;
+    int i;
+    /* version line */
+    fputs(strusage(11), stdout);
+    if( (s=strusage(12)) )
+       printf(" (%s)", s );
+    printf(" %s\n", strusage(13) );
+    /* additional version lines */
+    for(i=20; i < 30; i++ )
+       if( (s=strusage(i)) )
+           printf("%s\n", s );
+    /* copyright string */
+    if( (s=strusage(14)) )
+       printf("%s\n", s );
+    /* copying conditions */
+    if( (s=strusage(15)) )
+       fputs(s, stdout);
+    /* thanks */
+    if( (s=strusage(18)) )
+       fputs(s, stdout);
+    /* additional program info */
+    for(i=30; i < 40; i++ )
+       if( (s=strusage(i)) )
+           fputs( (const byte*)s, stdout);
+    fflush(stdout);
+}
+
+
+void
+usage( int level )
+{
+    if( !level ) {
+       fprintf(stderr,"%s %s; %s\n", strusage(11), strusage(13),
+                                                    strusage(14) );
+       fflush(stderr);
+    }
+    else if( level == 1 ) {
+       fputs(strusage(40),stderr);
+       exit(2);
+    }
+    else if( level == 2 ) {
+       puts(strusage(41));
+       exit(0);
+    }
+}
+
+/* Level
+ *     0: Copyright String auf stderr ausgeben
+ *     1: Kurzusage auf stderr ausgeben und beenden
+ *     2: Langusage auf stdout ausgeben und beenden
+ *    11: name of program
+ *    12: optional name of package which includes this program.
+ *    13: version  string
+ *    14: copyright string
+ *    15: Short copying conditions (with LFs)
+ *    16: Long copying conditions (with LFs)
+ *    17: Optional printable OS name
+ *    18: Optional thanks list  (with LFs)
+ *    19: Bug report info
+ *20..29: Additional lib version strings.
+ *30..39: Additional program info (with LFs)
+ *    40: short usage note (with LF)
+ *    41: long usage note (with LF)
+ */
+const char *
+strusage( int level )
+{
+    const char *p = strusage_handler? strusage_handler(level) : NULL;
+
+    if( p )
+       return p;
+
+    switch( level ) {
+      case 11: p = "foo"; break;
+      case 13: p = "0.0"; break;
+      case 14: p = "Copyright (C) 1999 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"
+"under certain conditions. See the file COPYING for details.\n"; break;
+      case 16: p =
+"This is free software; you can redistribute it and/or modify\n"
+"it under the terms of the GNU General Public License as published by\n"
+"the Free Software Foundation; either version 2 of the License, or\n"
+"(at your option) any later version.\n\n"
+"It is distributed in the hope that it will be useful,\n"
+"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
+"GNU General Public License for more details.\n\n"
+"You should have received a copy of the GNU General Public License\n"
+"along with this program; if not, write to the Free Software\n"
+"Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n";
+       break;
+      case 40: /* short and long usage */
+      case 41: p = ""; break;
+    }
+
+    return p;
+}
+
+void
+set_strusage( const char *(*f)( int ) )
+{
+    strusage_handler = f;
+}
+
+
+#ifdef TEST
+static struct {
+    int verbose;
+    int debug;
+    char *outfile;
+    char *crf;
+    int myopt;
+    int echo;
+    int a_long_one;
+}opt;
+
+int
+main(int argc, char **argv)
+{
+    ARGPARSE_OPTS opts[] = {
+    { 'v', "verbose",   0 , "Laut sein"},
+    { 'e', "echo"   ,   0 , "Zeile ausgeben, damit wir sehen, was wir einegegeben haben"},
+    { 'd', "debug",     0 , "Debug\nfalls mal etasws\nSchief geht"},
+    { 'o', "output",    2   },
+    { 'c', "cross-ref", 2|8, "cross-reference erzeugen\n" },
+    { 'm', "my-option", 1|8 },
+    { 500, "a-long-option", 0 },
+    {0} };
+    ARGPARSE_ARGS pargs = { &argc, &argv, 2|4|32 };
+    int i;
+
+    while( ArgParse( &pargs, opts) ) {
+       switch( pargs.r_opt ) {
+         case -1 : printf( "arg=`%s'\n", pargs.r.ret_str); break;
+         case 'v': opt.verbose++; break;
+         case 'e': opt.echo++; break;
+         case 'd': opt.debug++; break;
+         case 'o': opt.outfile = pargs.r.ret_str; break;
+         case 'c': opt.crf = pargs.r_type? pargs.r.ret_str:"a.crf"; break;
+         case 'm': opt.myopt = pargs.r_type? pargs.r.ret_int : 1; break;
+         case 500: opt.a_long_one++;  break;
+         default : pargs.err = 1; break; /* force warning output */
+       }
+    }
+    for(i=0; i < argc; i++ )
+       printf("%3d -> (%s)\n", i, argv[i] );
+    puts("Options:");
+    if( opt.verbose )
+       printf("  verbose=%d\n", opt.verbose );
+    if( opt.debug )
+       printf("  debug=%d\n", opt.debug );
+    if( opt.outfile )
+       printf("  outfile=`%s'\n", opt.outfile );
+    if( opt.crf )
+       printf("  crffile=`%s'\n", opt.crf );
+    if( opt.myopt )
+       printf("  myopt=%d\n", opt.myopt );
+    if( opt.a_long_one )
+       printf("  a-long-one=%d\n", opt.a_long_one );
+    if( opt.echo       )
+       printf("  echo=%d\n", opt.echo );
+    return 0;
+}
+#endif
+
+/**** bottom of file ****/
diff --git a/jnlib/argparse.h b/jnlib/argparse.h
new file mode 100644 (file)
index 0000000..3f5605b
--- /dev/null
@@ -0,0 +1,64 @@
+/* argparse.h
+ *     Copyright (C) 1998,1999 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+#ifndef LIBJNLIB_ARGPARSE_H
+#define LIBJNLIB_ARGPARSE_H
+
+typedef struct {
+     int  *argc;           /* pointer to argc (value subject to change) */
+     char ***argv;         /* pointer to argv (value subject to change) */
+     unsigned flags;       /* Global flags (DO NOT CHANGE) */
+     int err;              /* print error about last option */
+                           /* 1 = warning, 2 = abort */
+     int r_opt;            /* return option */
+     int r_type;           /* type of return value (0 = no argument found)*/
+     union {
+        int   ret_int;
+        long  ret_long;
+        ulong ret_ulong;
+        char *ret_str;
+     } r;                  /* Return values */
+     struct {
+        int idx;
+        int inarg;
+        int stopped;
+        const char *last;
+        void *aliases;
+        const void *cur_alias;
+     } internal;           /* DO NOT CHANGE */
+} ARGPARSE_ARGS;
+
+typedef struct {
+    int        short_opt;
+    const char *long_opt;
+    unsigned flags;
+    const char *description; /* optional option description */
+} ARGPARSE_OPTS;
+
+
+
+int arg_parse( ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts);
+int optfile_parse( FILE *fp, const char *filename, unsigned *lineno,
+                  ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts);
+void usage( int level );
+const char *strusage( int level );
+void set_strusage( const char *(*f)( int ) );
+
+#endif /*LIBJNLIB_ARGPARSE_H*/
diff --git a/jnlib/dotlock.c b/jnlib/dotlock.c
new file mode 100644 (file)
index 0000000..8e61f7a
--- /dev/null
@@ -0,0 +1,346 @@
+/* dotlock.c - dotfile locking
+ *     Copyright (C) 1998,2000 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+#include <config.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include <errno.h>
+#include <unistd.h>
+#ifndef  HAVE_DOSISH_SYSTEM
+#include <sys/utsname.h>
+#endif
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <signal.h>
+
+#include "libjnlib-config.h"
+#include "dotlock.h"
+
+struct dotlock_handle {
+    struct dotlock_handle *next;
+    char *tname;    /* name of lockfile template */
+    char *lockname; /* name of the real lockfile */
+    int locked;     /* lock status */
+};
+
+
+static DOTLOCK all_lockfiles;
+
+static int read_lockfile( const char *name );
+static void remove_lockfiles(void);
+
+/****************
+ * Create a lockfile with the given name and return an object of
+ * type DOTLOCK which may be used later to actually do the lock.
+ * A cleanup routine gets installed to cleanup left over locks
+ * or other files used together with the lockmechanism.
+ * Althoug the function is called dotlock, this does not necessarily
+ * mean that real lockfiles are used - the function may decide to
+ * use fcntl locking.  Calling the function with NULL only install
+ * the atexit handler and maybe used to assure that the cleanup
+ * is called after all other atexit handlers.
+ *
+ * Notes: This function creates a lock file in the same directory
+ *       as file_to_lock with the name "file_to_lock.lock"
+ *       A temporary file ".#lk.<hostname>.pid[.threadid] is used.
+ *       This function does nothing for Windoze.
+ */
+DOTLOCK
+create_dotlock( const char *file_to_lock )
+{
+    static int initialized;
+    DOTLOCK h;
+    int  fd = -1;
+    char pidstr[16];
+  #ifndef  HAVE_DOSISH_SYSTEM
+    struct utsname utsbuf;
+  #endif
+    const char *nodename;
+    const char *dirpart;
+    int dirpartlen;
+
+    if( !initialized ) {
+       atexit( remove_lockfiles );
+       initialized = 1;
+    }
+    if( !file_to_lock )
+       return NULL;
+
+    h = jnlib_xcalloc( 1, sizeof *h );
+#ifndef HAVE_DOSISH_SYSTEM
+    sprintf( pidstr, "%10d\n", (int)getpid() );
+    /* fixme: add the hostname to the second line (FQDN or IP addr?) */
+
+    /* create a temporary file */
+    if( uname( &utsbuf ) )
+       nodename = "unknown";
+    else
+       nodename = utsbuf.nodename;
+
+    if( !(dirpart = strrchr( file_to_lock, '/' )) ) {
+       dirpart = ".";
+       dirpartlen = 1;
+    }
+    else {
+       dirpartlen = dirpart - file_to_lock;
+       dirpart = file_to_lock;
+    }
+
+  #ifdef _REENTRANT
+    /* fixme: aquire mutex on all_lockfiles */
+  #endif
+    h->next = all_lockfiles;
+    all_lockfiles = h;
+
+    h->tname = jnlib_xmalloc( dirpartlen + 6+30+ strlen(nodename) + 11 );
+    sprintf( h->tname, "%.*s/.#lk%p.%s.%d",
+            dirpartlen, dirpart, h, nodename, (int)getpid() );
+
+    do {
+       errno = 0;
+       fd = open( h->tname, O_WRONLY|O_CREAT|O_EXCL,
+                         S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR );
+    } while( fd == -1 && errno == EINTR );
+    if( fd == -1 ) {
+       all_lockfiles = h->next;
+       log_error( "failed to create temporary file `%s': %s\n",
+                                           h->tname, strerror(errno));
+       jnlib_free(h->tname);
+       jnlib_free(h);
+       return NULL;
+    }
+    if( write(fd, pidstr, 11 ) != 11 ) {
+       all_lockfiles = h->next;
+      #ifdef _REENTRANT
+       /* release mutex */
+      #endif
+       log_fatal( "error writing to `%s': %s\n", h->tname, strerror(errno) );
+       close(fd);
+       unlink(h->tname);
+       jnlib_free(h->tname);
+       jnlib_free(h);
+       return NULL;
+    }
+    if( close(fd) ) {
+       all_lockfiles = h->next;
+      #ifdef _REENTRANT
+       /* release mutex */
+      #endif
+       log_error( "error closing `%s': %s\n", h->tname, strerror(errno));
+       unlink(h->tname);
+       jnlib_free(h->tname);
+       jnlib_free(h);
+       return NULL;
+    }
+
+  #ifdef _REENTRANT
+    /* release mutex */
+  #endif
+#endif /* !HAVE_DOSISH_SYSTEM */
+    h->lockname = jnlib_xmalloc( strlen(file_to_lock) + 6 );
+    strcpy(stpcpy(h->lockname, file_to_lock), ".lock");
+    return h;
+}
+
+static int
+maybe_deadlock( DOTLOCK h )
+{
+    DOTLOCK r;
+
+    for( r=all_lockfiles; r; r = r->next ) {
+       if( r != h && r->locked )
+           return 1;
+    }
+    return 0;
+}
+
+/****************
+ * Do a lock on H. A TIMEOUT of 0 returns immediately,
+ * -1 waits forever (hopefully not), other
+ * values are timeouts in milliseconds.
+ * Returns: 0 on success
+ */
+int
+make_dotlock( DOTLOCK h, long timeout )
+{
+#ifdef HAVE_DOSISH_SYSTEM
+    return 0;
+#else
+    int  pid;
+    const char *maybe_dead="";
+    int backoff=0;
+
+    if( h->locked ) {
+       log_debug("oops, `%s' is already locked\n", h->lockname );
+       return 0;
+    }
+
+    for(;;) {
+       if( !link(h->tname, h->lockname) ) {
+           /* fixme: better use stat to check the link count */
+           h->locked = 1;
+           return 0; /* okay */
+       }
+       if( errno != EEXIST ) {
+           log_error( "lock not made: link() failed: %s\n", strerror(errno) );
+           return -1;
+       }
+       if( (pid = read_lockfile(h->lockname)) == -1 ) {
+           if( errno != ENOENT ) {
+               log_info("cannot read lockfile\n");
+               return -1;
+           }
+           log_info( "lockfile disappeared\n");
+           continue;
+       }
+       else if( pid == getpid() ) {
+           log_info( "Oops: lock already hold by us\n");
+           h->locked = 1;
+           return 0; /* okay */
+       }
+       else if( kill(pid, 0) && errno == ESRCH ) {
+           maybe_dead = " - probably dead";
+        #if 0 /* we should not do this without checking the permissions */
+              /* and the hostname */
+           log_info( "removing stale lockfile (created by %d)", pid );
+        #endif
+       }
+       if( timeout == -1 ) {
+           struct timeval tv;
+           log_info( "waiting for lock (hold by %d%s) %s...\n",
+                     pid, maybe_dead, maybe_deadlock(h)? "(deadlock?) ":"");
+
+
+           /* can't use sleep, cause signals may be blocked */
+           tv.tv_sec = 1 + backoff;
+           tv.tv_usec = 0;
+           select(0, NULL, NULL, NULL, &tv);
+           if( backoff < 10 )
+               backoff++ ;
+       }
+       else
+           return -1;
+    }
+    /*not reached */
+#endif /* !HAVE_DOSISH_SYSTEM */
+}
+
+
+/****************
+ * release a lock
+ * Returns: 0 := success
+ */
+int
+release_dotlock( DOTLOCK h )
+{
+#ifdef HAVE_DOSISH_SYSTEM
+    return 0;
+#else
+    int pid;
+
+    if( !h->locked ) {
+       log_debug("oops, `%s' is not locked\n", h->lockname );
+       return 0;
+    }
+
+    pid = read_lockfile( h->lockname );
+    if( pid == -1 ) {
+       log_error( "release_dotlock: lockfile error\n");
+       return -1;
+    }
+    if( pid != getpid() ) {
+       log_error( "release_dotlock: not our lock (pid=%d)\n", pid);
+       return -1;
+    }
+    if( unlink( h->lockname ) ) {
+       log_error( "release_dotlock: error removing lockfile `%s'",
+                                                       h->lockname);
+       return -1;
+    }
+    /* fixme: check that the link count is now 1 */
+    h->locked = 0;
+    return 0;
+#endif /* !HAVE_DOSISH_SYSTEM */
+}
+
+
+/****************
+ * Read the lock file and return the pid, returns -1 on error.
+ */
+static int
+read_lockfile( const char *name )
+{
+  #ifdef HAVE_DOSISH_SYSTEM
+    return 0;
+  #else
+    int fd, pid;
+    char pidstr[16];
+
+    if( (fd = open(name, O_RDONLY)) == -1 ) {
+       int e = errno;
+       log_debug("error opening lockfile `%s': %s\n", name, strerror(errno) );
+       errno = e;
+       return -1;
+    }
+    if( read(fd, pidstr, 10 ) != 10 ) {  /* Read 10 digits w/o newline */
+       log_debug("error reading lockfile `%s'", name );
+       close(fd);
+       errno = 0;
+       return -1;
+    }
+    pidstr[10] = 0;  /* terminate pid string */
+    close(fd);
+    pid = atoi(pidstr);
+    if( !pid || pid == -1 ) {
+       log_error("invalid pid %d in lockfile `%s'", pid, name );
+       errno = 0;
+       return -1;
+    }
+    return pid;
+  #endif
+}
+
+
+static void
+remove_lockfiles()
+{
+  #ifndef HAVE_DOSISH_SYSTEM
+    DOTLOCK h, h2;
+
+    h = all_lockfiles;
+    all_lockfiles = NULL;
+
+    while( h ) {
+       h2 = h->next;
+       if( h->locked )
+           unlink( h->lockname );
+       unlink(h->tname);
+       jnlib_free(h->tname);
+       jnlib_free(h->lockname);
+       jnlib_free(h);
+       h = h2;
+    }
+  #endif
+}
+
diff --git a/jnlib/dotlock.h b/jnlib/dotlock.h
new file mode 100644 (file)
index 0000000..d54219e
--- /dev/null
@@ -0,0 +1,32 @@
+/* dotlock.h
+ *     Copyright (C) 2000 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+#ifndef LIBJNLIB_DOTLOCK_H
+#define LIBJNLIB_DOTLOCK_H
+
+struct dotlock_handle;
+typedef struct dotlock_handle *DOTLOCK;
+
+DOTLOCK create_dotlock( const char *file_to_lock );
+int make_dotlock( DOTLOCK h, long timeout );
+int release_dotlock( DOTLOCK h );
+
+
+#endif /*LIBJNLIB_DOTLOCK_H*/
diff --git a/jnlib/libjnlib-config.h b/jnlib/libjnlib-config.h
new file mode 100644 (file)
index 0000000..35cee64
--- /dev/null
@@ -0,0 +1,49 @@
+/* libjnlib-config.h - local configuration of the jnlib functions
+ *     Copyright (C) 2000 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+/****************
+ * This header is to be included only by the files in this directory
+ * it should not be used by other modules.
+ */
+
+#ifndef LIBJNLIB_CONFIG_H
+#define LIBJNLIB_CONFIG_H
+
+#define LIBJNLIB_LOGGING_H 1 /* don't include the jnlib logging */
+
+#include "types.h"
+#include <gcrypt.h>
+#include "util.h"
+#include "i18n.h"
+
+#define jnlib_xmalloc(a)    gcry_xmalloc( (a) )
+#define jnlib_xcalloc(a,b)  gcry_xcalloc( (a), (b) )
+#define jnlib_xrealloc(a,n) gcry_xrealloc( (a), (n) )
+#define jnlib_xstrdup(a)    gcry_xstrdup( (a) )
+#define jnlib_free(a)      gcry_free( (a) )
+
+#define jnlib_log_debug    log_debug
+#define jnlib_log_info    log_info
+#define jnlib_log_error    log_error
+#define jnlib_log_fatal    log_fatal
+#define jnlib_log_bug     log_bug
+
+
+#endif /*LIBJNUTIL_CONFIG_H*/
diff --git a/jnlib/logging.c b/jnlib/logging.c
new file mode 100644 (file)
index 0000000..7de36fb
--- /dev/null
@@ -0,0 +1,241 @@
+/* logging.c - useful logging functions
+ *     Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+
+/* This file should replace logger.c in the future - for now it is not
+ * used GnuPG.
+ * It is a quite simple implemenation but sufficient for most purposes.
+ */
+
+#include <config.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <time.h>
+
+#include "libjnlib-config.h"
+#include "logging.h"
+
+enum my_log_levels {
+    MY_LOG_BEGIN,  /* only print the timestamp if configured */
+    MY_LOG_CONT,
+    MY_LOG_INFO,
+    MY_LOG_WARN,
+    MY_LOG_ERROR,
+    MY_LOG_FATAL,
+    MY_LOG_BUG,
+    MY_LOG_DEBUG
+};
+
+static FILE *logstream;
+static int use_time;
+static int missing_lf;
+
+#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
+
+void
+log_set_file( const char *name )
+{
+    FILE *fp = (name && strcmp(name,"-"))? fopen(name, "a") : stderr;
+    if( !fp ) {
+       fprintf(stderr, "failed to open log file `%s': %s\n",
+                                               name, strerror(errno));
+       return;
+    }
+    setvbuf( fp, NULL, _IOLBF, 0 );
+
+    if( logstream && logstream != stderr )
+       fclose( logstream );
+    logstream = fp;
+    use_time = fp != stderr;
+    missing_lf = 0;
+}
+
+
+int
+log_get_fd()
+{
+    return fileno(logstream?logstream:stderr);
+}
+
+static void
+do_logv( int level, const char *fmt, va_list arg_ptr )
+{
+    if( !logstream )
+       logstream = stderr;
+
+    if( missing_lf && level != MY_LOG_CONT )
+       putc('\n', logstream );
+    missing_lf = 0;
+
+    if( use_time && level != MY_LOG_CONT ) {
+       /* Note this does not work for multiple line logging as we would
+        * need to print to a buffer first */
+       struct tm *tp;
+       time_t atime = time(NULL);
+
+       tp = localtime( &atime );
+       fprintf( logstream, "%04d-%02d-%02d %02d:%02d:%02d ",
+                   1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
+                        tp->tm_hour, tp->tm_min, tp->tm_sec );
+    }
+
+    switch ( level ) {
+      case MY_LOG_BEGIN: break;
+      case MY_LOG_CONT: break;
+      case MY_LOG_INFO: break;
+      case MY_LOG_WARN: break;
+      case MY_LOG_ERROR: break;
+      case MY_LOG_FATAL: fputs("Fatal: ",logstream ); break;
+      case MY_LOG_BUG: fputs("Ohhhh jeeee: ", logstream); break;
+      case MY_LOG_DEBUG: fputs("DBG: ", logstream ); break;
+      default: fprintf(logstream,"[Unknown log level %d]: ", level ); break;
+    }
+
+    if( fmt ) {
+       vfprintf(logstream,fmt,arg_ptr) ;
+       if( *fmt && fmt[strlen(fmt)-1] != '\n' )
+           missing_lf = 1;
+    }
+
+    if( level == MY_LOG_FATAL )
+       exit(2);
+    if( level == MY_LOG_BUG )
+       abort();
+}
+
+static void
+do_log( int level, const char *fmt, ... )
+{
+    va_list arg_ptr ;
+
+    va_start( arg_ptr, fmt ) ;
+    do_logv( level, fmt, arg_ptr );
+    va_end(arg_ptr);
+}
+
+
+
+void
+log_info( const char *fmt, ... )
+{
+    va_list arg_ptr ;
+
+    va_start( arg_ptr, fmt ) ;
+    do_logv( MY_LOG_INFO, fmt, arg_ptr );
+    va_end(arg_ptr);
+}
+
+void
+log_error( const char *fmt, ... )
+{
+    va_list arg_ptr ;
+
+    va_start( arg_ptr, fmt ) ;
+    do_logv( MY_LOG_ERROR, fmt, arg_ptr );
+    va_end(arg_ptr);
+}
+
+
+void
+log_fatal( const char *fmt, ... )
+{
+    va_list arg_ptr ;
+
+    va_start( arg_ptr, fmt ) ;
+    do_logv( MY_LOG_FATAL, fmt, arg_ptr );
+    va_end(arg_ptr);
+    abort(); /* never called, bugs it makes the compiler happy */
+}
+
+void
+log_bug( const char *fmt, ... )
+{
+    va_list arg_ptr ;
+
+    va_start( arg_ptr, fmt ) ;
+    do_logv( MY_LOG_BUG, fmt, arg_ptr );
+    va_end(arg_ptr);
+    abort(); /* never called, but it makes the compiler happy */
+}
+
+void
+log_debug( const char *fmt, ... )
+{
+    va_list arg_ptr ;
+
+    va_start( arg_ptr, fmt ) ;
+    do_logv( MY_LOG_DEBUG, fmt, arg_ptr );
+    va_end(arg_ptr);
+}
+
+
+void
+log_printf( const char *fmt, ... )
+{
+    va_list arg_ptr ;
+
+    if( !fmt ) {
+       do_logv( MY_LOG_BEGIN, NULL, NULL );
+    }
+    else {
+       va_start( arg_ptr, fmt ) ;
+       do_logv( MY_LOG_CONT, fmt, arg_ptr );
+       va_end(arg_ptr);
+    }
+}
+
+
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
+void
+bug_at( const char *file, int line, const char *func )
+{
+    do_log( MY_LOG_BUG,
+            ("... this is a bug (%s:%d:%s)\n"), file, line, func );
+    abort(); /* never called, but it makes the compiler happy */
+}
+#else
+void
+bug_at( const char *file, int line )
+{
+    do_log( MY_LOG_BUG,
+            _("you found a bug ... (%s:%d)\n"), file, line);
+    abort(); /* never called, but it makes the compiler happy */
+}
+#endif
+
diff --git a/jnlib/logging.h b/jnlib/logging.h
new file mode 100644 (file)
index 0000000..2470c1c
--- /dev/null
@@ -0,0 +1,46 @@
+/* logging.h
+ *     Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+#ifndef LIBJNLIB_LOGGING_H
+#define LIBJNLIB_LOGGING_H
+
+#include <stdio.h>
+#include "mischelp.h"
+
+void log_set_file( const char *name );
+int  log_get_fd(void);
+
+#ifdef JNLIB_GCC_M_FUNCTION
+  void bug_at( const char *file, int line, const char *func ) JNLIB_GCC_A_NR;
+# define BUG() bug_at( __FILE__ , __LINE__, __FUNCTION__ )
+#else
+  void bug_at( const char *file, int line );
+# define BUG() bug_at( __FILE__ , __LINE__ )
+#endif
+
+void log_bug( const char *fmt, ... )   JNLIB_GCC_A_NR_PRINTF(1,2);
+void log_fatal( const char *fmt, ... ) JNLIB_GCC_A_NR_PRINTF(1,2);
+void log_error( const char *fmt, ... ) JNLIB_GCC_A_PRINTF(1,2);
+void log_info( const char *fmt, ... )  JNLIB_GCC_A_PRINTF(1,2);
+void log_debug( const char *fmt, ... ) JNLIB_GCC_A_PRINTF(1,2);
+void log_printf( const char *fmt, ... ) JNLIB_GCC_A_PRINTF(1,2);
+
+
+#endif /*LIBJNLIB_LOGGING_H*/
diff --git a/jnlib/mischelp.h b/jnlib/mischelp.h
new file mode 100644 (file)
index 0000000..684a697
--- /dev/null
@@ -0,0 +1,43 @@
+/* mischelp.h
+ *     Copyright (C) 1999 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+#ifndef LIBJNLIB_MISCHELP_H
+#define LIBJNLIB_MISCHHELP_H
+
+
+#define DIM(v)              (sizeof(v)/sizeof((v)[0]))
+#define DIMof(type,member)   DIM(((type *)0)->member)
+
+
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
+# define JNLIB_GCC_M_FUNCTION 1
+# define JNLIB_GCC_A_NR             __attribute__ ((noreturn))
+# define JNLIB_GCC_A_PRINTF( f, a )  __attribute__ ((format (printf,f,a)))
+# define JNLIB_GCC_A_NR_PRINTF( f, a ) \
+                           __attribute__ ((noreturn, format (printf,f,a)))
+#else
+# define JNLIB_GCC_A_NR
+# define JNLIB_GCC_A_PRINTF( f, a )
+# define JNLIB_GCC_A_NR_PRINTF( f, a )
+#endif
+
+
+
+#endif /*LIBJNLIB_MISCHELP_H*/
diff --git a/jnlib/stringhelp.c b/jnlib/stringhelp.c
new file mode 100644 (file)
index 0000000..f3dbedb
--- /dev/null
@@ -0,0 +1,219 @@
+/* stringhelp.c -  standard string helper functions
+ *     Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+#include <config.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "libjnlib-config.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.
+ * Comparison is case-insensitive.
+ */
+const char *
+memistr( const char *buf, size_t buflen, const char *sub )
+{
+    const byte *t, *s ;
+    size_t n;
+
+    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 ;
+       }
+
+    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.
+ */
+char *
+mem2str( char *dest , const void *src , size_t n )
+{
+    char *d;
+    const char *s;
+
+    if( n ) {
+       if( !dest )
+           dest = jnlib_xmalloc( n ) ;
+       d = dest;
+       s = src ;
+       for(n--; n && *s; n-- )
+           *d++ = *s++;
+       *d = '\0' ;
+    }
+
+    return dest ;
+}
+
+
+/****************
+ * remove leading and trailing white spaces
+ */
+char *
+trim_spaces( char *str )
+{
+    char *string, *p, *mark;
+
+    string = str;
+    /* find first non space character */
+    for( p=string; *p && isspace( *(byte*)p ) ; p++ )
+       ;
+    /* move characters */
+    for( (mark = NULL); (*string = *p); string++, p++ )
+       if( isspace( *(byte*)p ) ) {
+           if( !mark )
+               mark = string ;
+       }
+       else
+           mark = NULL ;
+    if( mark )
+       *mark = '\0' ;  /* remove trailing spaces */
+
+    return str ;
+}
+
+/****************
+ * remove trailing white spaces
+ */
+char *
+trim_trailing_spaces( char *string )
+{
+    char *p, *mark;
+
+    for( mark = NULL, p = string; *p; p++ ) {
+       if( isspace( *(byte*)p ) ) {
+           if( !mark )
+               mark = p;
+       }
+       else
+           mark = NULL;
+    }
+    if( mark )
+       *mark = '\0' ;
+
+    return string ;
+}
+
+
+
+unsigned
+trim_trailing_chars( byte *line, unsigned len, const char *trimchars )
+{
+    byte *p, *mark;
+    unsigned n;
+
+    for(mark=NULL, p=line, n=0; n < len; n++, p++ ) {
+       if( strchr(trimchars, *p ) ) {
+           if( !mark )
+               mark = p;
+       }
+       else
+           mark = NULL;
+    }
+
+    if( mark ) {
+       *mark = 0;
+       return mark - line;
+    }
+    return len;
+}
+
+/****************
+ * remove trailing white spaces and return the length of the buffer
+ */
+unsigned
+trim_trailing_ws( byte *line, unsigned len )
+{
+    return trim_trailing_chars( line, len, " \t\r\n" );
+}
+
+
+
+/*********************************************
+ ********** missing string functions *********
+ *********************************************/
+
+#ifndef HAVE_STPCPY
+char *
+stpcpy(char *a,const char *b)
+{
+    while( *b )
+       *a++ = *b++;
+    *a = 0;
+
+    return (char*)a;
+}
+#endif
+
+#ifndef HAVE_STRLWR
+char *
+strlwr(char *s)
+{
+    char *p;
+    for(p=s; *p; p++ )
+       *p = tolower(*p);
+    return s;
+}
+#endif
+
+
+#ifndef HAVE_STRCASECMP
+int
+strcasecmp( const char *a, const char *b )
+{
+    for( ; *a && *b; a++, b++ ) {
+       if( *a != *b && toupper(*a) != toupper(*b) )
+           break;
+    }
+    return *(const byte*)a - *(const byte*)b;
+}
+#endif
+
+
+/****************
+ * mingw32/cpd has a memicmp()
+ */
+#ifndef HAVE_MEMICMP
+int
+memicmp( const char *a, const char *b, size_t n )
+{
+    for( ; n; n--, a++, b++ )
+       if( *a != *b  && toupper(*(const byte*)a) != toupper(*(const byte*)b) )
+           return *(const byte *)a - *(const byte*)b;
+    return 0;
+}
+#endif
+
+
+
diff --git a/jnlib/stringhelp.h b/jnlib/stringhelp.h
new file mode 100644 (file)
index 0000000..9aed124
--- /dev/null
@@ -0,0 +1,60 @@
+/* stringhelp.h
+ *     Copyright (C) 1998,1999 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+#ifndef LIBJNLIB_STRINGHELP_H
+#define LIBJNLIB_STRINGHELP_H
+
+
+const char *memistr( const char *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 );
+unsigned int trim_trailing_chars( unsigned char *line, unsigned len,
+                                             const char *trimchars);
+unsigned int trim_trailing_ws( unsigned char *line, unsigned len );
+
+
+#ifndef HAVE_MEMICMP
+int memicmp( const char *a, const char *b, size_t n );
+#endif
+#ifndef HAVE_STPCPY
+char *stpcpy(char *a,const char *b);
+#endif
+#ifndef HAVE_STRLWR
+char *strlwr(char *a);
+#endif
+#ifndef HAVE_STRTOUL
+  #define strtoul(a,b,c)  ((unsigned long)strtol((a),(b),(c)))
+#endif
+#ifndef HAVE_MEMMOVE
+  #define memmove(d, s, n) bcopy((s), (d), (n))
+#endif
+#ifndef HAVE_STRICMP
+  #define stricmp(a,b)  strcasecmp( (a), (b) )
+#endif
+
+
+#ifndef STR
+  #define STR(v) #v
+#endif
+#define STR2(v) STR(v)
+
+
+#endif /*LIBJNLIB_STRINGHELP_H*/
diff --git a/jnlib/xmalloc.c b/jnlib/xmalloc.c
new file mode 100644 (file)
index 0000000..fa016d8
--- /dev/null
@@ -0,0 +1,70 @@
+/* xmalloc.c - standard malloc wrappers
+ *     Copyright (C) 1999 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+#include <config.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "libjnlib-config.h"
+#include "xmalloc.h"
+
+static void
+out_of_core(void)
+{
+    fputs("\nfatal: out of memory\n", stderr );
+    exit(2);
+}
+
+
+void *
+xmalloc( size_t n )
+{
+    void *p = malloc( n );
+    if( !p )
+       out_of_core();
+    return p;
+}
+
+void *
+xrealloc( void *a, size_t n )
+{
+    void *p = realloc( a, n );
+    if( !p )
+       out_of_core();
+    return p;
+}
+
+void *
+xcalloc( size_t n, size_t m )
+{
+    void *p = calloc( n, m );
+    if( !p )
+       out_of_core();
+    return p;
+}
+
+char *
+xstrdup( const char *string )
+{
+    void *p = xmalloc( strlen(string)+1 );
+    strcpy( p, string );
+    return p;
+}
+
diff --git a/jnlib/xmalloc.h b/jnlib/xmalloc.h
new file mode 100644 (file)
index 0000000..95489c5
--- /dev/null
@@ -0,0 +1,30 @@
+/* xmalloc.h
+ *     Copyright (C) 1999 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ */
+
+#ifndef LIBJNLIB_XMALLOC_H
+#define LIBJNLIB_XMALLOC_H
+
+void *xmalloc( size_t n );
+void *xrealloc( void *a, size_t n );
+void *xcalloc( size_t n, size_t m );
+char *xstrdup( const char *string );
+
+
+#endif /*LIBJNLIB_XMALLOC_H*/