Bumped LT version to C13/A5/R2.
[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 void
41 ksba_set_malloc_hooks ( void *(*new_alloc_func)(size_t n),
42                         void *(*new_realloc_func)(void *p, size_t n),
43                         void (*new_free_func)(void*) )
44 {
45   alloc_func        = new_alloc_func;
46   realloc_func      = new_realloc_func;
47   free_func         = new_free_func;
48 }
49
50
51 /* Register a has function for general use by libksba.  This is
52    required to avoid dependencies to specific low-level
53    crypolibraries.  The function should be used right at the startup
54    of the main program, similar to ksba_set_malloc_hooks. 
55
56    The function provided should behave like this:
57
58    gpg_error_t hash_buffer (void *arg, const char *oid,
59                             const void *buffer, size_t length,
60                             size_t resultsize,
61                             unsigned char *result,
62                             size_t *resultlen);
63
64    Where ARG is the same pointer as set along with the fucntion, OID
65    is an OID string telling the hash algorithm to be used - SHA-1
66    shall be used if OID is NULL.  The text to hash is expected in
67    BUFFER of LENGTH and the result will be placed into the provided
68    buffer RESULT which has been allocated by the caller with at LEAST
69    RESULTSIZE bytes; the actual length of the result is put into
70    RESULTLEN. 
71
72    The function shall return 0 on success or any other appropriate
73    gpg-error.
74 */ 
75 void
76 ksba_set_hash_buffer_function ( gpg_error_t (*fnc)
77                                 (void *arg, const char *oid,
78                                  const void *buffer, size_t length,
79                                  size_t resultsize,
80                                  unsigned char *result,
81                                  size_t *resultlen),
82                                 void *fnc_arg)
83 {
84   hash_buffer_fnc = fnc;
85   hash_buffer_fnc_arg = fnc_arg;
86 }
87
88 /* Hash BUFFER of LENGTH bytes using the algorithjm denoted by OID,
89    where OID may be NULL to demand the use od SHA-1.  The resulting
90    digest will be placed in the provided buffer RESULT which must have
91    been allocated by the caller with at LEAST RESULTSIZE bytes; the
92    actual length of the result is put into RESULTLEN.
93
94    The function shall return 0 on success or any other appropriate
95    gpg-error.
96 */
97 gpg_error_t
98 _ksba_hash_buffer (const char *oid, const void *buffer, size_t length,
99                    size_t resultsize, unsigned char *result, size_t *resultlen)
100 {
101   if (!hash_buffer_fnc)
102     return gpg_error (GPG_ERR_CONFIGURATION);
103   return hash_buffer_fnc (hash_buffer_fnc_arg, oid, buffer, length,
104                           resultsize, result, resultlen);
105 }
106
107
108 /* Wrapper for the common memory allocation functions.  These are here
109    so that we can add hooks.  The corresponding macros should be used.
110    These macros are not named xfoo() because this name is commonly
111    used for function which die on errror.  We use macronames like
112    xtryfoo() instead. */
113
114 void *
115 ksba_malloc (size_t n )
116 {
117   return alloc_func (n);
118 }
119
120 void *
121 ksba_calloc (size_t n, size_t m )
122 {
123   void *p = ksba_malloc (n*m);
124   if (p)
125     memset (p, 0, n*m);
126   return p;
127 }
128
129 void *
130 ksba_realloc (void *mem, size_t n)
131 {
132   return realloc_func (mem, n );
133 }
134
135
136 char *
137 ksba_strdup (const char *str)
138 {
139   char *p = ksba_malloc (strlen(str)+1);
140   if (p)
141     strcpy (p, str);
142   return p;
143 }
144
145
146 void 
147 ksba_free ( void *a )
148 {
149   if (a)
150     free_func (a);
151 }
152
153
154 static void
155 out_of_core(void)
156 {
157   fputs ("\nfatal: out of memory\n", stderr );
158   exit (2);
159 }
160
161 \f
162 /* Implementations of the common xfoo() memory allocation functions */
163 void *
164 _ksba_xmalloc (size_t n )
165 {
166   void *p = ksba_malloc (n);
167   if (!p)
168     out_of_core();
169   return p;
170 }
171
172 void *
173 _ksba_xcalloc (size_t n, size_t m )
174 {
175   void *p = ksba_calloc (n,m);
176   if (!p)
177     out_of_core();
178   return p;
179 }
180
181 void *
182 _ksba_xrealloc (void *mem, size_t n)
183 {
184   void *p = ksba_realloc (mem,n);
185   if (!p)
186     out_of_core();
187   return p;
188 }
189
190
191 char *
192 _ksba_xstrdup (const char *str)
193 {
194   char *p = ksba_strdup (str);
195   if (!p)
196     out_of_core();
197   return p;
198 }
199
200 \f
201 #ifndef HAVE_STPCPY
202 char *
203 _ksba_stpcpy (char *a,const char *b)
204 {
205   while (*b)
206     *a++ = *b++;
207   *a = 0;
208
209   return a;
210 }
211 #endif
212