Added user data feature for ksba_cert_t
[libksba.git] / src / util.c
1 /* util.c
2  *      Copyright (C) 2001 g10 Code GmbH
3  *
4  * This file is part of KSBA.
5  *
6  * KSBA is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * KSBA is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26
27 #include "util.h"
28
29 static void *(*alloc_func)(size_t n) = malloc;
30 static void *(*realloc_func)(void *p, size_t n) = realloc;
31 static void (*free_func)(void*) = free;
32 static gpg_error_t (*hash_buffer_fnc)(void *arg, const char *oid,
33                                       const void *buffer, size_t length,
34                                       size_t resultsize,
35                                       unsigned char *result, size_t *resultlen);
36 static void *hash_buffer_fnc_arg;
37
38
39
40 /* Note, that we expect that the free fucntion does not change
41    ERRNO. */
42 void
43 ksba_set_malloc_hooks ( void *(*new_alloc_func)(size_t n),
44                         void *(*new_realloc_func)(void *p, size_t n),
45                         void (*new_free_func)(void*) )
46 {
47   alloc_func        = new_alloc_func;
48   realloc_func      = new_realloc_func;
49   free_func         = new_free_func;
50 }
51
52
53 /* Register a has function for general use by libksba.  This is
54    required to avoid dependencies to specific low-level
55    crypolibraries.  The function should be used right at the startup
56    of the main program, similar to ksba_set_malloc_hooks. 
57
58    The function provided should behave like this:
59
60    gpg_error_t hash_buffer (void *arg, const char *oid,
61                             const void *buffer, size_t length,
62                             size_t resultsize,
63                             unsigned char *result,
64                             size_t *resultlen);
65
66    Where ARG is the same pointer as set along with the fucntion, OID
67    is an OID string telling the hash algorithm to be used - SHA-1
68    shall be used if OID is NULL.  The text to hash is expected in
69    BUFFER of LENGTH and the result will be placed into the provided
70    buffer RESULT which has been allocated by the caller with at LEAST
71    RESULTSIZE bytes; the actual length of the result is put into
72    RESULTLEN. 
73
74    The function shall return 0 on success or any other appropriate
75    gpg-error.
76 */ 
77 void
78 ksba_set_hash_buffer_function ( gpg_error_t (*fnc)
79                                 (void *arg, const char *oid,
80                                  const void *buffer, size_t length,
81                                  size_t resultsize,
82                                  unsigned char *result,
83                                  size_t *resultlen),
84                                 void *fnc_arg)
85 {
86   hash_buffer_fnc = fnc;
87   hash_buffer_fnc_arg = fnc_arg;
88 }
89
90 /* Hash BUFFER of LENGTH bytes using the algorithjm denoted by OID,
91    where OID may be NULL to demand the use od SHA-1.  The resulting
92    digest will be placed in the provided buffer RESULT which must have
93    been allocated by the caller with at LEAST RESULTSIZE bytes; the
94    actual length of the result is put into RESULTLEN.
95
96    The function shall return 0 on success or any other appropriate
97    gpg-error.
98 */
99 gpg_error_t
100 _ksba_hash_buffer (const char *oid, const void *buffer, size_t length,
101                    size_t resultsize, unsigned char *result, size_t *resultlen)
102 {
103   if (!hash_buffer_fnc)
104     return gpg_error (GPG_ERR_CONFIGURATION);
105   return hash_buffer_fnc (hash_buffer_fnc_arg, oid, buffer, length,
106                           resultsize, result, resultlen);
107 }
108
109
110 /* Wrapper for the common memory allocation functions.  These are here
111    so that we can add hooks.  The corresponding macros should be used.
112    These macros are not named xfoo() because this name is commonly
113    used for function which die on errror.  We use macronames like
114    xtryfoo() instead. */
115
116 void *
117 ksba_malloc (size_t n )
118 {
119   return alloc_func (n);
120 }
121
122 void *
123 ksba_calloc (size_t n, size_t m )
124 {
125   void *p = ksba_malloc (n*m);
126   if (p)
127     memset (p, 0, n*m);
128   return p;
129 }
130
131 void *
132 ksba_realloc (void *mem, size_t n)
133 {
134   return realloc_func (mem, n );
135 }
136
137
138 char *
139 ksba_strdup (const char *str)
140 {
141   char *p = ksba_malloc (strlen(str)+1);
142   if (p)
143     strcpy (p, str);
144   return p;
145 }
146
147
148 void 
149 ksba_free ( void *a )
150 {
151   if (a)
152     free_func (a);
153 }
154
155
156 static void
157 out_of_core(void)
158 {
159   fputs ("\nfatal: out of memory\n", stderr );
160   exit (2);
161 }
162
163 \f
164 /* Implementations of the common xfoo() memory allocation functions */
165 void *
166 _ksba_xmalloc (size_t n )
167 {
168   void *p = ksba_malloc (n);
169   if (!p)
170     out_of_core();
171   return p;
172 }
173
174 void *
175 _ksba_xcalloc (size_t n, size_t m )
176 {
177   void *p = ksba_calloc (n,m);
178   if (!p)
179     out_of_core();
180   return p;
181 }
182
183 void *
184 _ksba_xrealloc (void *mem, size_t n)
185 {
186   void *p = ksba_realloc (mem,n);
187   if (!p)
188     out_of_core();
189   return p;
190 }
191
192
193 char *
194 _ksba_xstrdup (const char *str)
195 {
196   char *p = ksba_strdup (str);
197   if (!p)
198     out_of_core();
199   return p;
200 }
201
202 \f
203 #ifndef HAVE_STPCPY
204 char *
205 _ksba_stpcpy (char *a,const char *b)
206 {
207   while (*b)
208     *a++ = *b++;
209   *a = 0;
210
211   return a;
212 }
213 #endif
214