Added gnulib stuff to allow for a portable alloca
authorWerner Koch <wk@gnupg.org>
Thu, 2 Jun 2005 06:05:31 +0000 (06:05 +0000)
committerWerner Koch <wk@gnupg.org>
Thu, 2 Jun 2005 06:05:31 +0000 (06:05 +0000)
15 files changed:
ChangeLog
Makefile.am
autogen.sh
configure.ac
doc/ksba.texi
gl/Makefile.am [new file with mode: 0644]
gl/alloca.c [new file with mode: 0644]
gl/alloca.h [new file with mode: 0644]
gl/alloca_.h [new file with mode: 0644]
gl/m4/alloca.m4 [new file with mode: 0644]
gl/m4/gnulib.m4 [new file with mode: 0644]
gl/m4/onceonly_2_57.m4 [new file with mode: 0644]
src/ChangeLog
src/Makefile.am
src/asn1-func.c

index 03ddc8f..f9904c1 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,14 @@
+2005-06-02  Werner Koch  <wk@g10code.com>
+
+       * gl/, gp/m4/: New.
+       * configure.ac: Add test for gnulib module alloca.
+       * Makefile.am (SUBDIRS): Include gl/
+
 2005-04-20  Werner Koch  <wk@g10code.com>
 
+       * configure.ac: Fixed typo in saving CFLAGS for gpg-error symbol
+       test.
+
        Released 0.9.11.
        
 2005-04-19  Werner Koch  <wk@g10code.com>
index b388d0e..0d1e6e9 100644 (file)
@@ -19,7 +19,7 @@
 
 ## Process this file with automake to produce Makefile.in
 
-ACLOCAL_AMFLAGS = -I m4
+ACLOCAL_AMFLAGS = -I m4 -I gl/m4
 AUTOMAKE_OPTIONS = dist-bzip2
 
 EXTRA_DIST = README-alpha autogen.sh
@@ -32,7 +32,7 @@ tests = tests
 endif
 
 
-SUBDIRS = src ${tests} doc
+SUBDIRS = gl src ${tests} doc
 
 dist-hook:
        @set -e; echo "$(VERSION)" > $(distdir)/VERSION
index 3708892..00a814e 100755 (executable)
@@ -145,8 +145,8 @@ EOF
     exit 1
 fi
 
-echo "Running aclocal -I m4 ${ACLOCAL_FLAGS:+$ACLOCAL_FLAGS }..."
-$ACLOCAL -I m4 $ACLOCAL_FLAGS
+echo "Running aclocal -I m4 -I gl/m4 ${ACLOCAL_FLAGS:+$ACLOCAL_FLAGS }..."
+$ACLOCAL -I m4 -I gl/m4 $ACLOCAL_FLAGS
 echo "Running autoheader..."
 $AUTOHEADER
 echo "Running automake --gnu ..."
index 6c40b1c..2537ada 100644 (file)
@@ -75,6 +75,7 @@ AC_PROG_CPP
 AC_PROG_INSTALL
 AC_PROG_LN_S
 AC_PROG_MAKE_SET
+gl_EARLY
 #AC_ARG_PROGRAM
 AC_PROG_YACC
 AC_C_INLINE
@@ -113,7 +114,7 @@ if test "x$GPG_ERROR_LIBS" = "x"; then
   AC_MSG_ERROR([libgpg-error is needed.
                 See ftp://ftp.gnupg.org/gcrypt/libgpg-error/ .])
 fi
-_tmp_gpg_error_save_cflags="$CFLAGaS"
+_tmp_gpg_error_save_cflags="$CFLAGS"
 CFLAGS="$CFLAGS $GPG_ERROR_CFLAGS"
 AC_CHECK_DECLS(GPG_ERR_UNKNOWN_CRIT_EXTN,,,[#include <gpg-error.h>])
 CFLAGS="${_tmp_gpg_error_save_cflags}"
@@ -139,6 +140,12 @@ GNUPG_CHECK_TYPEDEF(u32, HAVE_U32_TYPEDEF)
 AC_CHECK_FUNCS([memmove strchr strtol strtoul stpcpy gmtime_r])
 
 
+# GNUlib checks
+gl_SOURCE_BASE(gl)
+gl_M4_BASE(gl/m4)
+gl_MODULES(alloca)
+gl_INIT
+
 # To be used in ksba-config
 KSBA_CONFIG_LIBS="-lksba"
 KSBA_CONFIG_CFLAGS=""
@@ -150,6 +157,7 @@ AM_CONDITIONAL(CROSS_COMPILING, test x$cross_compiling = xyes)
 
 AC_CONFIG_FILES([
 Makefile
+gl/Makefile
 src/Makefile
 src/ksba-config
 tests/Makefile
index 43e8bd7..ce3e39b 100644 (file)
@@ -82,10 +82,10 @@ This is edition @value{EDITION}, last updated @value{UPDATED}, of
 @menu
 * Introduction::                How to use this manual.
 * Preparation::                 What you should do before using the library.
-* Certificate Handling::        
-* CMS::                         
-* CRLs::                        
-* PKCS10::                      
+* Certificate Handling::        How to work with X.509 certificates.
+* CMS::                         How to work with CMS (PKCS#7) messages.
+* CRLs::                        How to wor with Certificate Revocation Lists.
+* PKCS10::                      How to request certificates.
 * Utilities::                   Various utility functions.
 * Error Handling::              Error numbers and their meanings.
 
@@ -142,8 +142,8 @@ certifictes, CMS data and related data more easy.
 @node Getting Started
 @section Getting Started
 
-This manual documents the `KSBA' library programming interface.  All functions
-and data types provided by the library are explained.
+This manual documents the `KSBA' library programming interface.  All
+functions and data types provided by the library are explained.
 
 The reader is assumed to possess basic knowledge about the implemented
 protocols.
@@ -170,16 +170,17 @@ Anybody can use, modify, and redistribute it under the terms of the GNU
 General Public License (@pxref{Copying}).
 
 @item It hides the low level stuff
-`KSBA' a higlevel interface to the implemented protocols and presents the data
-in a consistent way.  There is no more need to worry about all the nasty
-details of the protocols.  The API gives the C programmer a more usual way of
-interacting with the data.
+`KSBA' a higlevel interface to the implemented protocols and presents
+the data in a consistent way.  There is no more need to worry about all
+the nasty details of the protocols.  The API gives the C programmer a
+more usual way of interacting with the data.
 
 @item It copes with the version details
-X.509 protocols tend to have many different versions  and dialects.
-Applications must usually cope with all of this and it has to be coded over
-and over again.  `KSBA' hides this by providing just one API which does the
-Right Thing.  Support for new versions will be added over time.
+X.509 protocols tend to have many different versions and dialects.
+Applications must usually cope with all of this and it has to be coded
+over and over again.  `KSBA' hides this by providing just one API which
+does the Right Thing.  Support for new versions and features of the
+protocols will be added over time.
 @end table
 
 
@@ -188,17 +189,19 @@ Right Thing.  Support for new versions will be added over time.
 
 @c [Needs more stuff]
 
-The `KSBA' library is thread-safe.
+The `KSBA' library is thread-safe as long as objects described by one
+context are only used by one thread at a time.  No initialization is
+required.
 
 
 @node Preparation
 @chapter Preparation
 
-To use `KSBA', you have to perform some changes to your
-sources and the build system.  The necessary changes are small and
-explained in the following sections.  At the end of this chapter, it
-is described how the library is initialized, and how the requirements
-of the library are verified.
+To use `KSBA', you have to perform some changes to your sources and the
+build system.  The necessary changes are small and explained in the
+following sections.  At the end of this chapter, it is described how the
+library is initialized, and how the requirements of the library are
+verified.
 
 @menu
 * Header::                      
@@ -210,75 +213,75 @@ of the library are verified.
 @node Header
 @section Header
 
-All interfaces (data types and functions) of the library are defined
-in the header file `ksba.h'.  You must include this in all programs
+All interfaces (data types and functions) of the library are defined in
+the header file @file{ksba.h}.  You must include this in all programs
 using the library, either directly or through some other header file,
 like this:
 
-@example
+@smallexample
 #include <ksba.h>
-@end example
+@end smallexample
 
-The name space of `KSBA' is @code{ksba_*} for function names, @code{ksba*} for
-data types and @code{KSBA_*} for other symbols.  In addition the same name
-prefixes with one prepended underscore are reserved for internal use and
-should never be used by an application.
+The name space of `KSBA' is @code{ksba_*} for function names,
+@code{ksba*} for data types and @code{KSBA_*} for other symbols.  In
+addition the same name prefixes with one prepended underscore are
+reserved for internal use and should never be used by an application.
 
 @node Version Check
 @section Version Check
 
 It is often desirable to check that the version of `KSBA' used is indeed
-one which fits all requirements.  Even with binary compatibility new
-features may have been introduced but due to problem with the dynamic
-linker an old version is actually used.  So you may want to check that
-the version is okay right after program startup.
+one which fits all requirements.  Even with binary compatibility, new
+features may have been introduced but through peculiarities of the
+runtime linker an old version gets actually used.  So you bettero check
+that the version is as expected right after program startup.
 
 @deftypefun {const char *} ksba_check_version (@w{const char *@var{req_version}})
 
 Check that the the version of the library is at minimum the one given as
 a string in @var{req_version} and return the actual version string of
-the library; return NULL if the condition is not met.  If @code{NULL} is
-passed to this function no check is done and only the version string is
-returned.  It is a pretty good idea to run this function as soon as
-possible, because it may also intializes some subsystems.  In a
-multithreaded environment if should be called before any more threads
-are created.
+the library; return @code{NULL} if the condition is not met.  If
+@code{NULL} is passed to this function, no check is done and only the
+version string is returned.  It is a pretty good idea to run this
+function as soon as possible, because it may also intializes some
+subsystems.  In a multi-threaded environment if should be called before
+any more threads are created.
 @end deftypefun
 
 @node Building the source
 @section Building the source
 
-If you want to compile a source file including the `ksba.h' header
-file, you must make sure that the compiler can find it in the
-directory hierarchy.  This is accomplished by adding the path to the
-directory in which the header file is located to the compilers include
-file search path (via the @option{-I} option).
+If you want to compile a source file including the @file{ksba.h} header
+file, you must make sure that the compiler can find it in the directory
+hierarchy.  This is accomplished by adding the path to the directory in
+which the header file is located to the compiler's include file search
+path (via the @option{-I} option).
 
 However, the path to the include file is determined at the time the
 source is configured.  To solve this problem, `KSBA' ships with a small
 helper program @command{ksba-config} that knows about the path to the
-include file and other configuration options.  The options that need
-to be added to the compiler invocation at compile time are output by
-the @option{--cflags} option to @command{ksba-config}.  The following
+include file and other configuration options.  The options that need to
+be added to the compiler invocation at compile time are output by the
+@option{--cflags} option of @command{ksba-config}.  The following
 example shows how it can be used at the command line:
 
 @example
 gcc -c foo.c `ksba-config --cflags`
 @end example
 
-Adding the output of @samp{ksba-config --cflags} to the compilers
-command line will ensure that the compiler can find the `KSBA' header
-file.
+Adding the output of @samp{ksba-config --cflags} to the compiler's
+command line will ensure that the compiler can find the @file{ksba.h}
+header file.
 
 A similar problem occurs when linking the program with the library.
 Again, the compiler has to find the library files.  For this to work,
-the path to the library files has to be added to the library search
-path (via the @option{-L} option).  For this, the option
-@option{--libs} to @command{ksba-config} can be used.  For
-convenience, this option also outputs all other options that are
-required to link the program with the `KSBA' libararies (in particular, the
-@samp{-lksba} option).  The example shows how to link @file{foo.o}
-with the `KSBA' libraries to a program @command{foo}.
+the path to the library files has to be added to the library search path
+(via the @option{-L} option).  For this, the option @option{--libs} of
+@command{ksba-config} can be used.  For convenience, this option also
+outputs all other options that are required to link the program with the
+`KSBA' libararies (in particular, the @samp{-lksba} option).  The
+example shows how to link @file{foo.o} with the `KSBA' libraries to a
+program @command{foo}.
 
 @example
 gcc -o foo foo.o `ksba-config --libs`
@@ -292,9 +295,8 @@ gcc -o foo foo.c `ksba-config --cflags --libs`
 @end example
 
 
-
 @node Certificate Handling
-@chapter Certificate Handling
+@chapter How to work with X.509 certificates.
 
 One of the most complex data formats are the X.509 certificates.
 @acronym{KSBA} provides an easy to use interface to handle them.
@@ -303,6 +305,13 @@ One of the most complex data formats are the X.509 certificates.
 The @code{ksba_cert_t} type is a handle for an X.509 certificate.
 @end deftp
 
+@deftp {Data type} ksba_sexp_t
+The @code{ksba_sexp_t} type descripes a canonical encodes S-expression
+stored in a memory buffer.  It is alias for @code{unisgned char *}.
+Note that a length argument is not required because the length of such
+an S-expression is intrinsic available. 
+@end deftp
+
 @menu
 * Creating certificates::       How to create a certificate object.
 * Retrieving attributes::       How to get the attributes of a certificate.
@@ -313,15 +322,16 @@ The @code{ksba_cert_t} type is a handle for an X.509 certificate.
 @node Creating certificates
 @section How to create a certificate object
 
-This section explains how to create a certificate object, initialize it
+This section explains how to create a certificate object, initialize it,
 copy it and eventually destroy it. 
 
 @deftypefun ksba_cert_t ksba_cert_new (void)
-The function @code{ksba_cert_new} creates a new @code{ksba_cert_t}
+The function @code{ksba_cert_new} creates a new certificate
 object and returns a handle for it.
 
 The only reason why this function may fail is an out-of-memory condition in
-which case @code{NULL} is returned.
+which case @code{NULL} is returned.  You might then get the actual error
+code using @samp{gpg_error_from_errno (errno)}.
 @end deftypefun
 
 @deftypefun void ksba_cert_ref (@w{ksba_cert_t @var{cert}})
@@ -331,67 +341,69 @@ required to actually release the memory used for the object.
 @end deftypefun
 
 @deftypefun void ksba_cert_release (@w{ksba_cert_t @var{cert}})
-The function @code{ksba_cert_release} destroys the certificate object with the
-handle @var{cert} and releases all associated resources.  Due to the use of
-reference counting no actual memory may be released.  It is okay to pass
-@code{NULL} to the function in which case nothing happens.
+The function @code{ksba_cert_release} destroys the certificate object
+with the handle @var{cert} and releases all associated resources.  Due
+to the use of reference counting no actual memory may be released if
+another refrence still exists.  It is okay to pass @code{NULL} to the
+function in which case nothing happens.
 @end deftypefun
 
 @deftypefun gpg_error_t ksba_cert_read_der (@w{ksba_cert_t @var{cert}}, @w{ksba_reader_t @var{reader}})
 
-Read the next certificate from @var{reader} and store it in the
-certificate object @var{cert} for future access.  The certificate is parsed
-and rejected if it has any syntactical or semantical error
-(i.e. does not match the ASN.1 description).
+Read the next certificate from the @var{reader} object and store it in
+the certificate object @var{cert} for future access.  The certificate is
+parsed and rejected if it has any syntactical or semantical error
+(i.e. does not match the @acronym{ASN.1} description).
 
-The function returns zero if the operation was successfully performed or
-an error code.
+The function returns @code{0} if the operation was successfully
+performed.  An error code is returned on failure.
 @end deftypefun
 
 @deftypefun gpg_error_t ksba_cert_init_from_mem (@w{ksba_cert_t @var{cert}}, @w{const void *@var{buffer}}, @w{size_t @var{length}})
 
 Parse the @var{buffer} which should contain a @acronym{DER} encoded
-certificate of @var{length} and initialize the @var{cert}.  This
-function is intended as a conveninence function to be used when a
-certifciate is already available in a internal memory buffer.  This
-avoids the extra code needed to setup the reader object.  Note that
-@var{cert} must be a valid certificate object.
+certificate of @var{length} and initialize the certificate object
+@var{cert} with it.  This function is intended as a conveninence
+function to be used when a certifciate is already available in a
+internal memory buffer.  This avoids the extra code needed to setup the
+reader object.  Note that @var{cert} must be a valid certificate object.
 
-The function returns zero if the operation was successfully performed or
-an error code.
+The function returns @code{0} if the operation was successfully performed.
+An error code is returned on failure.
 @end deftypefun
 
 @node Retrieving attributes
 @section How to get the attributes of a certificate
 
-The functions in this section allow accesing the attributes of a
-certificate in a well defined manner.  An error will be retruned if the
+The functions in this section allow accessing the attributes of a
+certificate in a well defined manner.  An error will be returned if the
 certificate object has not yet been initialzied by means of
 @code{ksba_cert_read_der} or @code{ksba_cert_init_from_mem}.
 
 @deftypefun {const unsigned char *} ksba_cert_get_image (@w{ksba_cert_t @var{cert}}, @w{size_t *@var{r_length}}) 
 
-This function returns a pointer
-to the @acronym{DER} encoded buffer with the raw certificate as well as
-the length of that buffer in @var{r_length}.  This function is useful to
-export or store the raw certificate.
+This function returns a pointer to the @acronym{DER} encoded buffer with
+the raw certificate.  The length of that buffer gets stored at
+@var{r_length}.  This function is useful to export or store the raw
+certificate.
 
-The function returns @code{NULL} on error or a pointer which is valid as
-long as @var{cert} is valid.
+The function returns @code{NULL} on error or a pointer to a buffer with
+the raw certificate data.  That pointer is only valid as long as the
+certificat object @var{cert} is valid and has not been reinitialized.
 @end deftypefun
 
 @deftypefun gpg_error_t ksba_cert_hash (@w{ksba_cert_t @var{cert}}, @w{int @var{what}}, @w{void (*@var{hasher})(void *, const void *, size_t length)}, @w{void *@var{hasher_arg}})
 
 This function feeds the data which is expected to be hashed into the
-given function @var{hasher}, where the first argument passed is
+supplied function @var{hasher}, where the first argument passed is
 @var{hasher_arg}, the second the pointer to the data to be hashed and
 the third the length of this data.
 
-The function returns 0 on success or an error code when somethign goes
-wrong.  The @var{hasher} function is not expected to retrun an error,
-instead the caller should setup that function in a way to store
-encounters error by means of the @var{hasher_arg}.  However, a hash
-function is not expected to yiled errors anyway.
+The function returns @code{0} on success or an error code when something
+goes wrong.  The @var{hasher} function is not expected to return an
+error; instead the caller should setup that function in a way to convey
+encountered errors by means of the @var{hasher_arg}.  Note that a hash
+function is in general not expected to yield errors anyway.
 @end deftypefun
 
 
@@ -399,42 +411,44 @@ function is not expected to yiled errors anyway.
 
 Figure out the the digest algorithm used for the signature and return
 its @acronym{OID} in dotted decimal format.  This function is most
-likely used to setup the hash context before calling @code{ksba_cert_hash}
+likely used to setup the hash context before calling
+@code{ksba_cert_hash}.
 
-The function returns @code{NULL} for an error, otherwise a constant
-string with the @acronym{OID}.  This string is valid as long the
-certificate object is valid.
+The function returns @code{NULL} for an error; on success a constant
+string with the @acronym{OID} is returned.  This string is valid as long
+the certificate object is valid.
 @end deftypefun
 
 @deftypefun ksba_sexp_t ksba_cert_get_serial (@w{ksba_cert_t @var{cert}})
 
 The function returns the serial number of the certificate @var{cert}.
-The serial number is an integer returned as an cancnical encoded
+The serial number is an integer returned as an canonical encoded
 S-expression with just one element.  The caller must free the returned
-value.  @code{NULL} is returned in case of error.
+value.  The value @code{NULL} is returned in case of error. 
 @end deftypefun
 
 @deftypefun {char *} ksba_cert_get_issuer (@w{ksba_cert_t @var{cert}, int @var{idx}})
 
 With @var{idx} given as @code{0}, this function returns the
-Distinguished Name (@acronym{DN}) of the certificate issuer which
-usually is the name of a @acronym{CA}.  The format of the returned
-string is in accordance with RFC-2253.  @code{NULL} is returned if the
-@acronym{DN} is not available which is an error and should have been
-catched by the certificate reading function.
+Distinguished Name (@acronym{DN}) of the certificate issuer; this
+usually is the name of a certification authority (@acronym{CA}).  The
+format of the returned string is in accordance with RFC-2253.
+@code{NULL} is returned if the @acronym{DN} is not available; This is a
+severe error and actually should have been catched by the certificate
+reading function.
  
 With @var{idx} greater than zero, the function may be used to enumerate
 alternate issuer names.  The function returns @code{NULL} when there are
 no more alternate names. Only alternate names recognized by
 @code{libksba} are returned, others are simply skipped.  The format of
 the returned name is either a RFC-2253 formated string which can be
-detected by checking whether the first character is letter or digit.
-rfc-2822 conform email addresses are returned enclosed in angle
-brackets, the opening angle bracket should be used to detect this.
+detected by checking whether the first character is letter or digit.
+RFC-822 conform email addresses are returned enclosed in angle
+brackets; the opening angle bracket should be used to detect this.
 Other formats are returned as an S-Expression in canonical format, so a
 opening parenthesis should be used to detect this encoding, the name may
-include binary null characters, so strlen may return a length shorter
-than actually used, the real length is implictly given by the structure
+include binary null characters, thus strlen may return a length shorter
+than actually used.  The real length is implictly given by the structure
 of the S-expression, an extra null is appended for safety reasons.
  
 The caller must free the returned string using @code{ksba_free} or
@@ -449,17 +463,17 @@ format of the returned string is in accordance with RFC-2253.
 @code{NULL} is returned if the @acronym{DN} is not available.
 
 With @var{idx} greater than zero, the function may be used to enumerate
-alternate subject names.  The function returns @code{NULL} when there are
-no more alternate names. Only alternate names recognized by
+alternate subject names.  The function returns @code{NULL} when there
+are no more alternate names. Only alternate names recognized by
 @code{libksba} are returned, others are simply skipped.  The format of
 the returned name is either a RFC-2253 formated string which can be
-detected by checking whether the first character is letter or digit.
-rfc-2822 conform email addresses are returned enclosed in angle
-brackets, the opening angle bracket should be used to detect this.
+detected by checking whether the first character is letter or digit.
+RFC-2822 conform email addresses are returned enclosed in angle
+brackets; the opening angle bracket should be used to detect this.
 Other formats are returned as an S-Expression in canonical format, so a
 opening parenthesis should be used to detect this encoding, the name may
-include binary null characters, so strlen may return a length shorter
-than actually used, the real length is implictly given by the structure
+include binary null characters, thus strlen may return a length shorter
+than actually used.  The real length is implictly given by the structure
 of the S-expression, an extra null is appended for safety reasons.
  
 The caller must free the returned string using @code{ksba_free} or
@@ -467,19 +481,62 @@ whatever function has been registered as a replacement.
 @end deftypefun
 
 
-@deftypefun time_t ksba_cert_get_validity (@w{ksba_cert_t @var{cert}, int @var{what}})
+@deftp {Data type} ksba_isotime_t
+Due to problems with the C data type @code{time_t}, which will overflow
+on most 32 bit machines in the year 2038, it was not advisable to use
+this type for referencing times stored in certificates.  Thus this type
+has been defined.  It is also useful to represent any time since the
+year 0.
+
+It is implemented as a buffer of 16 bytes and may be handled like a
+standard string.  It should be initialized to zero (i.e. the first byte
+needs to be 0x00) if it does not hold a valid date.  Date values
+themselfs are stored in ISO format and assumed to mean UTC.  The string
+with the date value is always guaranteed to be of length 15 and having a
+format like: @samp{"19610711T172059"}.  Note that the `T' is required by
+ISO rules.
+
+A simple assignment of these data types is no good idea.  You may use
+@code{strcpy} or better a specialized function like:
+
+@example
+void
+copy_time (ksba_isotime_t d, const ksba_isotime_t s)
+@{
+  if (!*s)
+    memset (d, 0, 16);
+  else  
+    strcpy (d, s);
+@}
+@end example
+
+For reasons of documentation a special function should also be used to
+compare such times:
+
+@example
+int 
+cmp_time (const ksba_isotime_t a, const ksba_isotime_t b) 
+@{
+  return strcmp (a, b);
+@}
+@end example
+@end deftp
+
+@deftypefun gpg_error_t ksba_cert_get_validity (@w{ksba_cert_t @var{cert}, int @var{what}, ksba_isotime_t @var{timebuf}})
 
 Return the validity dates from the certificate.  If no value is
-available @code{0} is returned because we can safely assume that the
-first January 1970 is not a valid date.  @code{-1} casted to
-@code{time_t} is retruned in case of error.
+available an empty date object (i.e. a @code{strlen} will be
+stored at @var{timebuf}, otherwiese it will receive the date. On failure
+an error ode is returned.
 
 To return the `notBefore' date, the value @code{0} must be supplied for
-@var{what};  @code{1} yields the `notAfter' value.
+@var{what}; @code{1} yields the `notAfter' value.
 @end deftypefun
 
 @deftypefun ksba_sexp_t ksba_cert_get_public_key (@w{ksba_cert_t @var{cert}})
 
+@c  {{{{ CONTINUE HERE }}}}}}
+
 @c !FIXME!
 [This needs to get written - for now please see libksba/src/cert.c]
 
@@ -604,7 +661,7 @@ See RFC-2459, section 4.2.2.2 for the defintion of this attribute.
 @node CMS
 @chapter Mastering the Cryptographic Message Syntax
 The @acronym{CMS} is also known under the name PKCS#7.  Is is
-acryptographic framework for securing data transactions adn storage,much
+a cryptographic framework for securing data transactions and storage, much
 like OpenPGP.  It is heavily based on X.509 semantics and for example
 used with the email encryption protocol S/MIME.
 
diff --git a/gl/Makefile.am b/gl/Makefile.am
new file mode 100644 (file)
index 0000000..8d4e776
--- /dev/null
@@ -0,0 +1,50 @@
+## Process this file with automake to produce Makefile.in.
+# Copyright (C) 2004 Free Software Foundation, Inc.
+#
+# This file is free software, distributed under the terms of the GNU
+# General Public License.  As a special exception to the GNU General
+# Public License, this file may be distributed as part of a program
+# that contains a configuration script generated by Automake, under
+# the same distribution terms as the rest of that program.
+#
+# Generated by gnulib-tool.
+# Invoked as: gnulib-tool --import
+# Reproduce by: gnulib-tool --import --dir=. --lib=libgnu --source-base=gl --m4-base=gl/m4 --aux-dir=. --libtool  alloca alloca-opt
+
+AUTOMAKE_OPTIONS = 1.5 gnits no-dependencies
+
+noinst_LTLIBRARIES = libgnu.la
+
+libgnu_la_SOURCES =
+libgnu_la_LIBADD = @LTLIBOBJS@
+EXTRA_DIST =
+BUILT_SOURCES =
+SUFFIXES =
+MOSTLYCLEANFILES =
+CLEANFILES =
+DISTCLEANFILES =
+MAINTAINERCLEANFILES =
+
+## begin gnulib module alloca
+
+
+libgnu_la_LIBADD += @LTALLOCA@
+## end   gnulib module alloca
+
+## begin gnulib module alloca-opt
+
+BUILT_SOURCES += $(ALLOCA_H)
+EXTRA_DIST += alloca_.h
+
+# We need the following in order to create an <alloca.h> when the system
+# doesn't have one that works with the given compiler.
+all-local $(libgnu_la_OBJECTS): $(ALLOCA_H)
+alloca.h: alloca_.h
+       cp $(srcdir)/alloca_.h $@-t
+       mv $@-t $@
+MOSTLYCLEANFILES += alloca.h alloca.h-t
+
+## end   gnulib module alloca-opt
+
+
+# Makefile.am ends here
diff --git a/gl/alloca.c b/gl/alloca.c
new file mode 100644 (file)
index 0000000..d1d5447
--- /dev/null
@@ -0,0 +1,491 @@
+/* alloca.c -- allocate automatically reclaimed memory
+   (Mostly) portable public-domain implementation -- D A Gwyn
+
+   This implementation of the PWB library alloca function,
+   which is used to allocate space off the run-time stack so
+   that it is automatically reclaimed upon procedure exit,
+   was inspired by discussions with J. Q. Johnson of Cornell.
+   J.Otto Tennant <jot@cray.com> contributed the Cray support.
+
+   There are some preprocessor constants that can
+   be defined when compiling for your specific system, for
+   improved efficiency; however, the defaults should be okay.
+
+   The general concept of this implementation is to keep
+   track of all alloca-allocated blocks, and reclaim any
+   that are found to be deeper in the stack than the current
+   invocation.  This heuristic does not reclaim storage as
+   soon as it becomes invalid, but it will do so eventually.
+
+   As a special case, alloca(0) reclaims storage without
+   allocating any.  It is a good idea to use alloca(0) in
+   your main control loop, etc. to force garbage collection.  */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <alloca.h>
+
+#include <string.h>
+#include <stdlib.h>
+
+#ifdef emacs
+# include "lisp.h"
+# include "blockinput.h"
+# ifdef EMACS_FREE
+#  undef free
+#  define free EMACS_FREE
+# endif
+#else
+# define memory_full() abort ()
+#endif
+
+/* If compiling with GCC 2, this file's not needed.  */
+#if !defined (__GNUC__) || __GNUC__ < 2
+
+/* If someone has defined alloca as a macro,
+   there must be some other way alloca is supposed to work.  */
+# ifndef alloca
+
+#  ifdef emacs
+#   ifdef static
+/* actually, only want this if static is defined as ""
+   -- this is for usg, in which emacs must undefine static
+   in order to make unexec workable
+   */
+#    ifndef STACK_DIRECTION
+you
+lose
+-- must know STACK_DIRECTION at compile-time
+/* Using #error here is not wise since this file should work for
+   old and obscure compilers.  */
+#    endif /* STACK_DIRECTION undefined */
+#   endif /* static */
+#  endif /* emacs */
+
+/* If your stack is a linked list of frames, you have to
+   provide an "address metric" ADDRESS_FUNCTION macro.  */
+
+#  if defined (CRAY) && defined (CRAY_STACKSEG_END)
+long i00afunc ();
+#   define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg))
+#  else
+#   define ADDRESS_FUNCTION(arg) &(arg)
+#  endif
+
+/* Define STACK_DIRECTION if you know the direction of stack
+   growth for your system; otherwise it will be automatically
+   deduced at run-time.
+
+   STACK_DIRECTION > 0 => grows toward higher addresses
+   STACK_DIRECTION < 0 => grows toward lower addresses
+   STACK_DIRECTION = 0 => direction of growth unknown  */
+
+#  ifndef STACK_DIRECTION
+#   define STACK_DIRECTION     0       /* Direction unknown.  */
+#  endif
+
+#  if STACK_DIRECTION != 0
+
+#   define STACK_DIR   STACK_DIRECTION /* Known at compile-time.  */
+
+#  else /* STACK_DIRECTION == 0; need run-time code.  */
+
+static int stack_dir;          /* 1 or -1 once known.  */
+#   define STACK_DIR   stack_dir
+
+static void
+find_stack_direction (void)
+{
+  static char *addr = NULL;    /* Address of first `dummy', once known.  */
+  auto char dummy;             /* To get stack address.  */
+
+  if (addr == NULL)
+    {                          /* Initial entry.  */
+      addr = ADDRESS_FUNCTION (dummy);
+
+      find_stack_direction (); /* Recurse once.  */
+    }
+  else
+    {
+      /* Second entry.  */
+      if (ADDRESS_FUNCTION (dummy) > addr)
+       stack_dir = 1;          /* Stack grew upward.  */
+      else
+       stack_dir = -1;         /* Stack grew downward.  */
+    }
+}
+
+#  endif /* STACK_DIRECTION == 0 */
+
+/* An "alloca header" is used to:
+   (a) chain together all alloca'ed blocks;
+   (b) keep track of stack depth.
+
+   It is very important that sizeof(header) agree with malloc
+   alignment chunk size.  The following default should work okay.  */
+
+#  ifndef      ALIGN_SIZE
+#   define ALIGN_SIZE  sizeof(double)
+#  endif
+
+typedef union hdr
+{
+  char align[ALIGN_SIZE];      /* To force sizeof(header).  */
+  struct
+    {
+      union hdr *next;         /* For chaining headers.  */
+      char *deep;              /* For stack depth measure.  */
+    } h;
+} header;
+
+static header *last_alloca_header = NULL;      /* -> last alloca header.  */
+
+/* Return a pointer to at least SIZE bytes of storage,
+   which will be automatically reclaimed upon exit from
+   the procedure that called alloca.  Originally, this space
+   was supposed to be taken from the current stack frame of the
+   caller, but that method cannot be made to work for some
+   implementations of C, for example under Gould's UTX/32.  */
+
+void *
+alloca (size_t size)
+{
+  auto char probe;             /* Probes stack depth: */
+  register char *depth = ADDRESS_FUNCTION (probe);
+
+#  if STACK_DIRECTION == 0
+  if (STACK_DIR == 0)          /* Unknown growth direction.  */
+    find_stack_direction ();
+#  endif
+
+  /* Reclaim garbage, defined as all alloca'd storage that
+     was allocated from deeper in the stack than currently.  */
+
+  {
+    register header *hp;       /* Traverses linked list.  */
+
+#  ifdef emacs
+    BLOCK_INPUT;
+#  endif
+
+    for (hp = last_alloca_header; hp != NULL;)
+      if ((STACK_DIR > 0 && hp->h.deep > depth)
+         || (STACK_DIR < 0 && hp->h.deep < depth))
+       {
+         register header *np = hp->h.next;
+
+         free (hp);            /* Collect garbage.  */
+
+         hp = np;              /* -> next header.  */
+       }
+      else
+       break;                  /* Rest are not deeper.  */
+
+    last_alloca_header = hp;   /* -> last valid storage.  */
+
+#  ifdef emacs
+    UNBLOCK_INPUT;
+#  endif
+  }
+
+  if (size == 0)
+    return NULL;               /* No allocation required.  */
+
+  /* Allocate combined header + user data storage.  */
+
+  {
+    /* Address of header.  */
+    register header *new;
+
+    size_t combined_size = sizeof (header) + size;
+    if (combined_size < sizeof (header))
+      memory_full ();
+
+    new = malloc (combined_size);
+
+    if (! new)
+      memory_full ();
+
+    new->h.next = last_alloca_header;
+    new->h.deep = depth;
+
+    last_alloca_header = new;
+
+    /* User storage begins just after header.  */
+
+    return (void *) (new + 1);
+  }
+}
+
+#  if defined (CRAY) && defined (CRAY_STACKSEG_END)
+
+#   ifdef DEBUG_I00AFUNC
+#    include <stdio.h>
+#   endif
+
+#   ifndef CRAY_STACK
+#    define CRAY_STACK
+#    ifndef CRAY2
+/* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */
+struct stack_control_header
+  {
+    long shgrow:32;            /* Number of times stack has grown.  */
+    long shaseg:32;            /* Size of increments to stack.  */
+    long shhwm:32;             /* High water mark of stack.  */
+    long shsize:32;            /* Current size of stack (all segments).  */
+  };
+
+/* The stack segment linkage control information occurs at
+   the high-address end of a stack segment.  (The stack
+   grows from low addresses to high addresses.)  The initial
+   part of the stack segment linkage control information is
+   0200 (octal) words.  This provides for register storage
+   for the routine which overflows the stack.  */
+
+struct stack_segment_linkage
+  {
+    long ss[0200];             /* 0200 overflow words.  */
+    long sssize:32;            /* Number of words in this segment.  */
+    long ssbase:32;            /* Offset to stack base.  */
+    long:32;
+    long sspseg:32;            /* Offset to linkage control of previous
+                                  segment of stack.  */
+    long:32;
+    long sstcpt:32;            /* Pointer to task common address block.  */
+    long sscsnm;               /* Private control structure number for
+                                  microtasking.  */
+    long ssusr1;               /* Reserved for user.  */
+    long ssusr2;               /* Reserved for user.  */
+    long sstpid;               /* Process ID for pid based multi-tasking.  */
+    long ssgvup;               /* Pointer to multitasking thread giveup.  */
+    long sscray[7];            /* Reserved for Cray Research.  */
+    long ssa0;
+    long ssa1;
+    long ssa2;
+    long ssa3;
+    long ssa4;
+    long ssa5;
+    long ssa6;
+    long ssa7;
+    long sss0;
+    long sss1;
+    long sss2;
+    long sss3;
+    long sss4;
+    long sss5;
+    long sss6;
+    long sss7;
+  };
+
+#    else /* CRAY2 */
+/* The following structure defines the vector of words
+   returned by the STKSTAT library routine.  */
+struct stk_stat
+  {
+    long now;                  /* Current total stack size.  */
+    long maxc;                 /* Amount of contiguous space which would
+                                  be required to satisfy the maximum
+                                  stack demand to date.  */
+    long high_water;           /* Stack high-water mark.  */
+    long overflows;            /* Number of stack overflow ($STKOFEN) calls.  */
+    long hits;                 /* Number of internal buffer hits.  */
+    long extends;              /* Number of block extensions.  */
+    long stko_mallocs;         /* Block allocations by $STKOFEN.  */
+    long underflows;           /* Number of stack underflow calls ($STKRETN).  */
+    long stko_free;            /* Number of deallocations by $STKRETN.  */
+    long stkm_free;            /* Number of deallocations by $STKMRET.  */
+    long segments;             /* Current number of stack segments.  */
+    long maxs;                 /* Maximum number of stack segments so far.  */
+    long pad_size;             /* Stack pad size.  */
+    long current_address;      /* Current stack segment address.  */
+    long current_size;         /* Current stack segment size.  This
+                                  number is actually corrupted by STKSTAT to
+                                  include the fifteen word trailer area.  */
+    long initial_address;      /* Address of initial segment.  */
+    long initial_size;         /* Size of initial segment.  */
+  };
+
+/* The following structure describes the data structure which trails
+   any stack segment.  I think that the description in 'asdef' is
+   out of date.  I only describe the parts that I am sure about.  */
+
+struct stk_trailer
+  {
+    long this_address;         /* Address of this block.  */
+    long this_size;            /* Size of this block (does not include
+                                  this trailer).  */
+    long unknown2;
+    long unknown3;
+    long link;                 /* Address of trailer block of previous
+                                  segment.  */
+    long unknown5;
+    long unknown6;
+    long unknown7;
+    long unknown8;
+    long unknown9;
+    long unknown10;
+    long unknown11;
+    long unknown12;
+    long unknown13;
+    long unknown14;
+  };
+
+#    endif /* CRAY2 */
+#   endif /* not CRAY_STACK */
+
+#   ifdef CRAY2
+/* Determine a "stack measure" for an arbitrary ADDRESS.
+   I doubt that "lint" will like this much.  */
+
+static long
+i00afunc (long *address)
+{
+  struct stk_stat status;
+  struct stk_trailer *trailer;
+  long *block, size;
+  long result = 0;
+
+  /* We want to iterate through all of the segments.  The first
+     step is to get the stack status structure.  We could do this
+     more quickly and more directly, perhaps, by referencing the
+     $LM00 common block, but I know that this works.  */
+
+  STKSTAT (&status);
+
+  /* Set up the iteration.  */
+
+  trailer = (struct stk_trailer *) (status.current_address
+                                   + status.current_size
+                                   - 15);
+
+  /* There must be at least one stack segment.  Therefore it is
+     a fatal error if "trailer" is null.  */
+
+  if (trailer == 0)
+    abort ();
+
+  /* Discard segments that do not contain our argument address.  */
+
+  while (trailer != 0)
+    {
+      block = (long *) trailer->this_address;
+      size = trailer->this_size;
+      if (block == 0 || size == 0)
+       abort ();
+      trailer = (struct stk_trailer *) trailer->link;
+      if ((block <= address) && (address < (block + size)))
+       break;
+    }
+
+  /* Set the result to the offset in this segment and add the sizes
+     of all predecessor segments.  */
+
+  result = address - block;
+
+  if (trailer == 0)
+    {
+      return result;
+    }
+
+  do
+    {
+      if (trailer->this_size <= 0)
+       abort ();
+      result += trailer->this_size;
+      trailer = (struct stk_trailer *) trailer->link;
+    }
+  while (trailer != 0);
+
+  /* We are done.  Note that if you present a bogus address (one
+     not in any segment), you will get a different number back, formed
+     from subtracting the address of the first block.  This is probably
+     not what you want.  */
+
+  return (result);
+}
+
+#   else /* not CRAY2 */
+/* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP.
+   Determine the number of the cell within the stack,
+   given the address of the cell.  The purpose of this
+   routine is to linearize, in some sense, stack addresses
+   for alloca.  */
+
+static long
+i00afunc (long address)
+{
+  long stkl = 0;
+
+  long size, pseg, this_segment, stack;
+  long result = 0;
+
+  struct stack_segment_linkage *ssptr;
+
+  /* Register B67 contains the address of the end of the
+     current stack segment.  If you (as a subprogram) store
+     your registers on the stack and find that you are past
+     the contents of B67, you have overflowed the segment.
+
+     B67 also points to the stack segment linkage control
+     area, which is what we are really interested in.  */
+
+  stkl = CRAY_STACKSEG_END ();
+  ssptr = (struct stack_segment_linkage *) stkl;
+
+  /* If one subtracts 'size' from the end of the segment,
+     one has the address of the first word of the segment.
+
+     If this is not the first segment, 'pseg' will be
+     nonzero.  */
+
+  pseg = ssptr->sspseg;
+  size = ssptr->sssize;
+
+  this_segment = stkl - size;
+
+  /* It is possible that calling this routine itself caused
+     a stack overflow.  Discard stack segments which do not
+     contain the target address.  */
+
+  while (!(this_segment <= address && address <= stkl))
+    {
+#    ifdef DEBUG_I00AFUNC
+      fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl);
+#    endif
+      if (pseg == 0)
+       break;
+      stkl = stkl - pseg;
+      ssptr = (struct stack_segment_linkage *) stkl;
+      size = ssptr->sssize;
+      pseg = ssptr->sspseg;
+      this_segment = stkl - size;
+    }
+
+  result = address - this_segment;
+
+  /* If you subtract pseg from the current end of the stack,
+     you get the address of the previous stack segment's end.
+     This seems a little convoluted to me, but I'll bet you save
+     a cycle somewhere.  */
+
+  while (pseg != 0)
+    {
+#    ifdef DEBUG_I00AFUNC
+      fprintf (stderr, "%011o %011o\n", pseg, size);
+#    endif
+      stkl = stkl - pseg;
+      ssptr = (struct stack_segment_linkage *) stkl;
+      size = ssptr->sssize;
+      pseg = ssptr->sspseg;
+      result += size;
+    }
+  return (result);
+}
+
+#   endif /* not CRAY2 */
+#  endif /* CRAY */
+
+# endif /* no alloca */
+#endif /* not GCC version 2 */
diff --git a/gl/alloca.h b/gl/alloca.h
new file mode 100644 (file)
index 0000000..3e3fdf4
--- /dev/null
@@ -0,0 +1,52 @@
+/* Memory allocation on the stack.
+
+   Copyright (C) 1995, 1999, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   This program 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, or (at your option)
+   any later version.
+
+   This program 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+   USA.  */
+
+/* Avoid using the symbol _ALLOCA_H here, as Bison assumes _ALLOCA_H
+   means there is a real alloca function.  */
+#ifndef _GNULIB_ALLOCA_H
+# define _GNULIB_ALLOCA_H
+
+/* alloca (N) returns a pointer to N bytes of memory
+   allocated on the stack, which will last until the function returns.
+   Use of alloca should be avoided:
+     - inside arguments of function calls - undefined behaviour,
+     - in inline functions - the allocation may actually last until the
+       calling function returns,
+     - for huge N (say, N >= 65536) - you never know how large (or small)
+       the stack is, and when the stack cannot fulfill the memory allocation
+       request, the program just crashes.
+ */
+
+#ifdef __GNUC__
+# define alloca __builtin_alloca
+#elif defined _AIX
+# define alloca __alloca
+#elif defined _MSC_VER
+# include <malloc.h>
+# define alloca _alloca
+#else
+# include <stddef.h>
+# ifdef  __cplusplus
+extern "C"
+# endif
+void *alloca (size_t);
+#endif
+
+#endif /* _GNULIB_ALLOCA_H */
diff --git a/gl/alloca_.h b/gl/alloca_.h
new file mode 100644 (file)
index 0000000..3e3fdf4
--- /dev/null
@@ -0,0 +1,52 @@
+/* Memory allocation on the stack.
+
+   Copyright (C) 1995, 1999, 2001, 2002, 2003, 2004 Free Software
+   Foundation, Inc.
+
+   This program 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, or (at your option)
+   any later version.
+
+   This program 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+   USA.  */
+
+/* Avoid using the symbol _ALLOCA_H here, as Bison assumes _ALLOCA_H
+   means there is a real alloca function.  */
+#ifndef _GNULIB_ALLOCA_H
+# define _GNULIB_ALLOCA_H
+
+/* alloca (N) returns a pointer to N bytes of memory
+   allocated on the stack, which will last until the function returns.
+   Use of alloca should be avoided:
+     - inside arguments of function calls - undefined behaviour,
+     - in inline functions - the allocation may actually last until the
+       calling function returns,
+     - for huge N (say, N >= 65536) - you never know how large (or small)
+       the stack is, and when the stack cannot fulfill the memory allocation
+       request, the program just crashes.
+ */
+
+#ifdef __GNUC__
+# define alloca __builtin_alloca
+#elif defined _AIX
+# define alloca __alloca
+#elif defined _MSC_VER
+# include <malloc.h>
+# define alloca _alloca
+#else
+# include <stddef.h>
+# ifdef  __cplusplus
+extern "C"
+# endif
+void *alloca (size_t);
+#endif
+
+#endif /* _GNULIB_ALLOCA_H */
diff --git a/gl/m4/alloca.m4 b/gl/m4/alloca.m4
new file mode 100644 (file)
index 0000000..a9e3f45
--- /dev/null
@@ -0,0 +1,42 @@
+# alloca.m4 serial 5
+dnl Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
+dnl This file is free software; the Free Software Foundation
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+AC_DEFUN([gl_FUNC_ALLOCA],
+[
+  dnl Work around a bug of AC_EGREP_CPP in autoconf-2.57.
+  AC_REQUIRE([AC_PROG_CPP])
+  AC_REQUIRE([AC_PROG_EGREP])
+
+  AC_REQUIRE([AC_FUNC_ALLOCA])
+  if test $ac_cv_func_alloca_works = no; then
+    gl_PREREQ_ALLOCA
+  fi
+
+  # Define an additional variable used in the Makefile substitution.
+  if test $ac_cv_working_alloca_h = yes; then
+    AC_EGREP_CPP([Need own alloca], [
+#if defined __GNUC__ || defined _AIX || defined _MSC_VER
+       Need own alloca
+#endif
+      ],
+      [AC_DEFINE(HAVE_ALLOCA, 1,
+           [Define to 1 if you have `alloca' after including <alloca.h>,
+            a header that may be supplied by this distribution.])
+       ALLOCA_H=alloca.h],
+      [ALLOCA_H=])
+  else
+    ALLOCA_H=alloca.h
+  fi
+  AC_SUBST([ALLOCA_H])
+
+  AC_DEFINE(HAVE_ALLOCA_H, 1,
+    [Define HAVE_ALLOCA_H for backward compatibility with older code
+     that includes <alloca.h> only if HAVE_ALLOCA_H is defined.])
+])
+
+# Prerequisites of lib/alloca.c.
+# STACK_DIRECTION is already handled by AC_FUNC_ALLOCA.
+AC_DEFUN([gl_PREREQ_ALLOCA], [:])
diff --git a/gl/m4/gnulib.m4 b/gl/m4/gnulib.m4
new file mode 100644 (file)
index 0000000..074e76e
--- /dev/null
@@ -0,0 +1,41 @@
+# Copyright (C) 2004 Free Software Foundation, Inc.
+# This file is free software, distributed under the terms of the GNU
+# General Public License.  As a special exception to the GNU General
+# Public License, this file may be distributed as part of a program
+# that contains a configuration script generated by Autoconf, under
+# the same distribution terms as the rest of that program.
+#
+# Generated by gnulib-tool.
+#
+# Invoked as: gnulib-tool --import
+# Reproduce by: gnulib-tool --import --dir=. --lib=libgnu --source-base=gl --m4-base=gl/m4 --aux-dir=. --libtool  alloca alloca-opt
+
+AC_DEFUN([gl_EARLY],
+[
+])
+
+AC_DEFUN([gl_INIT],
+[
+changequote(,)dnl
+LTALLOCA=`echo "$ALLOCA" | sed 's/\.[^.]* /.lo /g;s/\.[^.]*$/.lo/'`
+changequote([, ])dnl
+AC_SUBST(LTALLOCA)
+  gl_FUNC_ALLOCA
+])
+
+dnl Usage: gl_MODULES(module1 module2 ...)
+AC_DEFUN([gl_MODULES], [])
+
+dnl Usage: gl_SOURCE_BASE(DIR)
+AC_DEFUN([gl_SOURCE_BASE], [])
+
+dnl Usage: gl_M4_BASE(DIR)
+AC_DEFUN([gl_M4_BASE], [])
+
+dnl Usage: gl_LIB(LIBNAME)
+AC_DEFUN([gl_LIB], [])
+
+dnl Usage: gl_LGPL
+AC_DEFUN([gl_LGPL], [])
+
+# gnulib.m4 ends here
diff --git a/gl/m4/onceonly_2_57.m4 b/gl/m4/onceonly_2_57.m4
new file mode 100644 (file)
index 0000000..9fc510e
--- /dev/null
@@ -0,0 +1,86 @@
+# onceonly_2_57.m4 serial 3
+dnl Copyright (C) 2002-2003 Free Software Foundation, Inc.
+dnl This file is free software, distributed under the terms of the GNU
+dnl General Public License.  As a special exception to the GNU General
+dnl Public License, this file may be distributed as part of a program
+dnl that contains a configuration script generated by Autoconf, under
+dnl the same distribution terms as the rest of that program.
+
+dnl This file defines some "once only" variants of standard autoconf macros.
+dnl   AC_CHECK_HEADERS_ONCE         like  AC_CHECK_HEADERS
+dnl   AC_CHECK_FUNCS_ONCE           like  AC_CHECK_FUNCS
+dnl   AC_CHECK_DECLS_ONCE           like  AC_CHECK_DECLS
+dnl   AC_REQUIRE([AC_HEADER_STDC])  like  AC_HEADER_STDC
+dnl The advantage is that the check for each of the headers/functions/decls
+dnl will be put only once into the 'configure' file. It keeps the size of
+dnl the 'configure' file down, and avoids redundant output when 'configure'
+dnl is run.
+dnl The drawback is that the checks cannot be conditionalized. If you write
+dnl   if some_condition; then gl_CHECK_HEADERS(stdlib.h); fi
+dnl inside an AC_DEFUNed function, the gl_CHECK_HEADERS macro call expands to
+dnl empty, and the check will be inserted before the body of the AC_DEFUNed
+dnl function.
+
+dnl This is like onceonly.m4, except that it uses diversions to named sections
+dnl DEFAULTS and INIT_PREPARE in order to check all requested headers at once,
+dnl thus reducing the size of 'configure'. Works with autoconf-2.57. The
+dnl size reduction is ca. 9%.
+
+dnl Autoconf version 2.57 or newer is recommended.
+AC_PREREQ(2.54)
+
+# AC_CHECK_HEADERS_ONCE(HEADER1 HEADER2 ...) is a once-only variant of
+# AC_CHECK_HEADERS(HEADER1 HEADER2 ...).
+AC_DEFUN([AC_CHECK_HEADERS_ONCE], [
+  :
+  AC_FOREACH([gl_HEADER_NAME], [$1], [
+    AC_DEFUN([gl_CHECK_HEADER_]m4_quote(translit(gl_HEADER_NAME,
+                                                 [./-], [___])), [
+      m4_divert_text([INIT_PREPARE],
+        [gl_header_list="$gl_header_list gl_HEADER_NAME"])
+      gl_HEADERS_EXPANSION
+      AH_TEMPLATE(AS_TR_CPP([HAVE_]m4_defn([gl_HEADER_NAME])),
+        [Define to 1 if you have the <]m4_defn([gl_HEADER_NAME])[> header file.])
+    ])
+    AC_REQUIRE([gl_CHECK_HEADER_]m4_quote(translit(gl_HEADER_NAME,
+                                                   [./-], [___])))
+  ])
+])
+m4_define([gl_HEADERS_EXPANSION], [
+  m4_divert_text([DEFAULTS], [gl_header_list=])
+  AC_CHECK_HEADERS([$gl_header_list])
+  m4_define([gl_HEADERS_EXPANSION], [])
+])
+
+# AC_CHECK_FUNCS_ONCE(FUNC1 FUNC2 ...) is a once-only variant of
+# AC_CHECK_FUNCS(FUNC1 FUNC2 ...).
+AC_DEFUN([AC_CHECK_FUNCS_ONCE], [
+  :
+  AC_FOREACH([gl_FUNC_NAME], [$1], [
+    AC_DEFUN([gl_CHECK_FUNC_]m4_defn([gl_FUNC_NAME]), [
+      m4_divert_text([INIT_PREPARE],
+        [gl_func_list="$gl_func_list gl_FUNC_NAME"])
+      gl_FUNCS_EXPANSION
+      AH_TEMPLATE(AS_TR_CPP([HAVE_]m4_defn([gl_FUNC_NAME])),
+        [Define to 1 if you have the `]m4_defn([gl_FUNC_NAME])[' function.])
+    ])
+    AC_REQUIRE([gl_CHECK_FUNC_]m4_defn([gl_FUNC_NAME]))
+  ])
+])
+m4_define([gl_FUNCS_EXPANSION], [
+  m4_divert_text([DEFAULTS], [gl_func_list=])
+  AC_CHECK_FUNCS([$gl_func_list])
+  m4_define([gl_FUNCS_EXPANSION], [])
+])
+
+# AC_CHECK_DECLS_ONCE(DECL1 DECL2 ...) is a once-only variant of
+# AC_CHECK_DECLS(DECL1, DECL2, ...).
+AC_DEFUN([AC_CHECK_DECLS_ONCE], [
+  :
+  AC_FOREACH([gl_DECL_NAME], [$1], [
+    AC_DEFUN([gl_CHECK_DECL_]m4_defn([gl_DECL_NAME]), [
+      AC_CHECK_DECLS(m4_defn([gl_DECL_NAME]))
+    ])
+    AC_REQUIRE([gl_CHECK_DECL_]m4_defn([gl_DECL_NAME]))
+  ])
+])
index 7e916a7..d7ac6c1 100644 (file)
@@ -1,3 +1,8 @@
+2005-06-02  Werner Koch  <wk@g10code.com>
+
+       * Makefile.am: Add flags for gnulib.
+       * asn1-func.c: Include alloca.h.
+
 2005-04-20  Werner Koch  <wk@g10code.com>
 
        * time.c (_ksba_asntime_to_iso): Add arg IS_UTCTIME to allow for
index 89290ac..1f40d43 100644 (file)
@@ -35,7 +35,8 @@ endif
 m4datadir = $(datadir)/aclocal
 m4data_DATA = ksba.m4
 
-AM_CFLAGS = @GPG_ERROR_CFLAGS@
+AM_CCPFLAGS = -I$(top_srcdir)/gl
+AM_CFLAGS = $(GPG_ERROR_CFLAGS)
 
 
 if HAVE_LD_VERSION_SCRIPT
@@ -72,7 +73,7 @@ libksba_la_SOURCES = \
        asn1-tables.c
 
 asn1_gentables_SOURCES = asn1-gentables.c asn1-parse.c asn1-func.c oid.c util.c
-asn1_gentables_LDADD = @GPG_ERROR_LIBS@
+asn1_gentables_LDADD = $(GPG_ERROR_LIBS) ../gl/libgnu.la
 # Note that we need to use per-target flags to force renaming of the 
 # object files to avoid clashes with libtool.
 asn1_gentables_CFLAGS = $(AM_CFLAGS)
@@ -80,7 +81,7 @@ asn1_gentables_CFLAGS = $(AM_CFLAGS)
 ber_dump_SOURCES = ber-dump.c \
                    ber-decoder.c ber-help.c reader.c writer.c asn1-parse.c \
                    asn1-func.c oid.c util.c
-ber_dump_LDADD = @GPG_ERROR_LIBS@
+ber_dump_LDADD = $(GPG_ERROR_LIBS) ../gl/libgnu.la
 ber_dump_CFLAGS = $(AM_CFLAGS)
 
 asn1-parse.c : asn1-func.h
index 3b0c8c9..82bfede 100755 (executable)
@@ -26,6 +26,8 @@
 #include <ctype.h>
 #include <assert.h>
 
+#include <alloca.h>
+
 #include "ksba.h"
 #include "asn1-func.h"
 #include "util.h"