if GNUTLS_DEBUG_LEVEL is specified the log function is not updated if it is already...
[gnutls:gnutls.git] / lib / gnutls_global.c
1 /*
2  * Copyright (C) 2001-2012 Free Software Foundation, Inc.
3  *
4  * Author: Nikos Mavrogiannopoulos
5  *
6  * This file is part of GnuTLS.
7  *
8  * The GnuTLS is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public License
10  * as published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
20  *
21  */
22
23 #include <gnutls_int.h>
24 #include <gnutls_errors.h>
25 #include <libtasn1.h>
26 #include <gnutls_dh.h>
27 #include <random.h>
28 #include <gnutls/pkcs11.h>
29
30 #include <gnutls_extensions.h>  /* for _gnutls_ext_init */
31 #include <locks.h>
32 #include <system.h>
33 #include <accelerated/cryptodev.h>
34 #include <accelerated/accelerated.h>
35
36 #include "sockets.h"
37 #include "gettext.h"
38
39 /* Minimum library versions we accept. */
40 #define GNUTLS_MIN_LIBTASN1_VERSION "0.3.4"
41
42 /* created by asn1c */
43 extern const ASN1_ARRAY_TYPE gnutls_asn1_tab[];
44 extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
45 void *_gnutls_file_mutex;
46
47 ASN1_TYPE _gnutls_pkix1_asn;
48 ASN1_TYPE _gnutls_gnutls_asn;
49
50 gnutls_log_func _gnutls_log_func = NULL;
51 gnutls_audit_log_func _gnutls_audit_log_func = NULL;
52 int _gnutls_log_level = 0;      /* default log level */
53
54 static void default_log_func(int level, const char* str)
55 {
56         fprintf(stderr, "gnutls[%d]: %s\n", level, str);
57 }
58
59 /**
60  * gnutls_global_set_log_function:
61  * @log_func: it's a log function
62  *
63  * This is the function where you set the logging function gnutls is
64  * going to use.  This function only accepts a character array.
65  * Normally you may not use this function since it is only used for
66  * debugging purposes.
67  *
68  * @gnutls_log_func is of the form,
69  * void (*gnutls_log_func)( int level, const char*);
70  **/
71 void gnutls_global_set_log_function(gnutls_log_func log_func)
72 {
73         _gnutls_log_func = log_func;
74 }
75
76 /**
77  * gnutls_global_set_audit_log_function:
78  * @log_func: it is the audit log function
79  *
80  * This is the function to set the audit logging function. This
81  * is a function to report important issues, such as possible
82  * attacks in the protocol. This is different from gnutls_global_set_log_function()
83  * because it will report also session-specific events. The session
84  * parameter will be null if there is no corresponding TLS session.
85  *
86  * @gnutls_audit_log_func is of the form,
87  * void (*gnutls_audit_log_func)( gnutls_session_t, const char*);
88  *
89  * Since: 3.0
90  **/
91 void gnutls_global_set_audit_log_function(gnutls_audit_log_func log_func)
92 {
93         _gnutls_audit_log_func = log_func;
94 }
95
96 /**
97  * gnutls_global_set_time_function:
98  * @time_func: it's the system time function, a gnutls_time_func() callback.
99  *
100  * This is the function where you can override the default system time
101  * function.  The application provided function should behave the same
102  * as the standard function.
103  *
104  * Since: 2.12.0
105  **/
106 void gnutls_global_set_time_function(gnutls_time_func time_func)
107 {
108         gnutls_time = time_func;
109 }
110
111 /**
112  * gnutls_global_set_log_level:
113  * @level: it's an integer from 0 to 9.
114  *
115  * This is the function that allows you to set the log level.  The
116  * level is an integer between 0 and 9.  Higher values mean more
117  * verbosity. The default value is 0.  Larger values should only be
118  * used with care, since they may reveal sensitive information.
119  *
120  * Use a log level over 10 to enable all debugging options.
121  **/
122 void gnutls_global_set_log_level(int level)
123 {
124         _gnutls_log_level = level;
125 }
126
127 /**
128  * gnutls_global_set_mem_functions:
129  * @alloc_func: it's the default memory allocation function. Like malloc().
130  * @secure_alloc_func: This is the memory allocation function that will be used for sensitive data.
131  * @is_secure_func: a function that returns 0 if the memory given is not secure. May be NULL.
132  * @realloc_func: A realloc function
133  * @free_func: The function that frees allocated data. Must accept a NULL pointer.
134  *
135  * This is the function where you set the memory allocation functions
136  * gnutls is going to use. By default the libc's allocation functions
137  * (malloc(), free()), are used by gnutls, to allocate both sensitive
138  * and not sensitive data.  This function is provided to set the
139  * memory allocation functions to something other than the defaults
140  *
141  * This function must be called before gnutls_global_init() is called.
142  * This function is not thread safe.
143  **/
144 void
145 gnutls_global_set_mem_functions(gnutls_alloc_function alloc_func,
146                                 gnutls_alloc_function secure_alloc_func,
147                                 gnutls_is_secure_function is_secure_func,
148                                 gnutls_realloc_function realloc_func,
149                                 gnutls_free_function free_func)
150 {
151         gnutls_secure_malloc = secure_alloc_func;
152         gnutls_malloc = alloc_func;
153         gnutls_realloc = realloc_func;
154         gnutls_free = free_func;
155
156         /* if using the libc's default malloc
157          * use libc's calloc as well.
158          */
159         if (gnutls_malloc == malloc) {
160                 gnutls_calloc = calloc;
161         } else {                /* use the included ones */
162                 gnutls_calloc = _gnutls_calloc;
163         }
164         gnutls_strdup = _gnutls_strdup;
165
166 }
167
168 static int _gnutls_init = 0;
169
170 /**
171  * gnutls_global_init:
172  *
173  * This function performs any required precalculations, detects
174  * the supported CPU capabilities and initializes the underlying
175  * cryptographic backend. In order to free any resources 
176  * taken by this call you should gnutls_global_deinit() 
177  * when gnutls usage is no longer needed.
178  *
179  * This function increments a global counter, so that
180  * gnutls_global_deinit() only releases resources when it has been
181  * called as many times as gnutls_global_init().  This is useful when
182  * GnuTLS is used by more than one library in an application.  This
183  * function can be called many times, but will only do something the
184  * first time.
185  *
186  * Note!  This function is not thread safe.  If two threads call this
187  * function simultaneously, they can cause a race between checking
188  * the global counter and incrementing it, causing both threads to
189  * execute the library initialization code.  That could lead to a
190  * memory leak or even a crash.  To handle this, your application should 
191  * invoke this function after aquiring a thread mutex.  
192  *
193  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned,
194  *   otherwise a negative error code is returned.
195  **/
196 int gnutls_global_init(void)
197 {
198         int result = 0;
199         int res, level;
200         const char* e;
201
202         if (_gnutls_init++)
203                 goto out;
204                 
205         e = getenv("GNUTLS_DEBUG_LEVEL");
206         if (e != NULL) {
207                 level = atoi(e);
208                 gnutls_global_set_log_level(level);
209                 if (_gnutls_log_func == NULL)
210                         gnutls_global_set_log_function(default_log_func);
211                 _gnutls_debug_log("Enabled GnuTLS logging...\n");
212         }
213
214         if (gl_sockets_startup(SOCKETS_1_1))
215                 return gnutls_assert_val(GNUTLS_E_FILE_ERROR);
216
217         bindtextdomain(PACKAGE, LOCALEDIR);
218
219         res = gnutls_crypto_init();
220         if (res != 0) {
221                 gnutls_assert();
222                 return GNUTLS_E_CRYPTO_INIT_FAILED;
223         }
224
225         _gnutls_register_accel_crypto();
226
227         /* initialize ASN.1 parser
228          * This should not deal with files in the final
229          * version.
230          */
231         if (asn1_check_version(GNUTLS_MIN_LIBTASN1_VERSION) == NULL) {
232                 gnutls_assert();
233                 _gnutls_debug_log
234                     ("Checking for libtasn1 failed: %s < %s\n",
235                      asn1_check_version(NULL),
236                      GNUTLS_MIN_LIBTASN1_VERSION);
237                 return GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY;
238         }
239
240         res = asn1_array2tree(pkix_asn1_tab, &_gnutls_pkix1_asn, NULL);
241         if (res != ASN1_SUCCESS) {
242                 result = _gnutls_asn2err(res);
243                 goto out;
244         }
245
246         res = asn1_array2tree(gnutls_asn1_tab, &_gnutls_gnutls_asn, NULL);
247         if (res != ASN1_SUCCESS) {
248                 result = _gnutls_asn2err(res);
249                 goto out;
250         }
251
252         /* Initialize the random generator */
253         result = _gnutls_rnd_init();
254         if (result < 0) {
255                 gnutls_assert();
256                 goto out;
257         }
258
259         /* Initialize the default TLS extensions */
260         result = _gnutls_ext_init();
261         if (result < 0) {
262                 gnutls_assert();
263                 goto out;
264         }
265
266         result = gnutls_mutex_init(&_gnutls_file_mutex);
267         if (result < 0) {
268                 gnutls_assert();
269                 goto out;
270         }
271
272         result = gnutls_system_global_init();
273         if (result < 0) {
274                 gnutls_assert();
275                 goto out;
276         }
277 #ifdef ENABLE_PKCS11
278         gnutls_pkcs11_init(GNUTLS_PKCS11_FLAG_AUTO, NULL);
279 #endif
280
281         _gnutls_cryptodev_init();
282
283       out:
284         return result;
285 }
286
287 /**
288  * gnutls_global_deinit:
289  *
290  * This function deinitializes the global data, that were initialized
291  * using gnutls_global_init().
292  *
293  * Note!  This function is not thread safe.  See the discussion for
294  * gnutls_global_init() for more information.
295  **/
296 void gnutls_global_deinit(void)
297 {
298         if (_gnutls_init == 1) {
299                 gl_sockets_cleanup();
300                 gnutls_crypto_deinit();
301                 _gnutls_rnd_deinit();
302                 _gnutls_ext_deinit();
303                 asn1_delete_structure(&_gnutls_gnutls_asn);
304                 asn1_delete_structure(&_gnutls_pkix1_asn);
305                 _gnutls_crypto_deregister();
306                 _gnutls_cryptodev_deinit();
307                 gnutls_system_global_deinit();
308 #ifdef ENABLE_PKCS11
309                 gnutls_pkcs11_deinit();
310 #endif
311                 gnutls_mutex_deinit(&_gnutls_file_mutex);
312         }
313         _gnutls_init--;
314 }
315
316 /* These functions should be elsewere. Kept here for
317  * historical reasons.
318  */
319
320
321 /**
322  * gnutls_check_version:
323  * @req_version: version string to compare with, or %NULL.
324  *
325  * Check GnuTLS Library version.
326  *
327  * See %GNUTLS_VERSION for a suitable @req_version string.
328  *
329  * Returns: Check that the version of the library is at
330  *   minimum the one given as a string in @req_version and return the
331  *   actual version string of the library; return %NULL if the
332  *   condition is not met.  If %NULL is passed to this function no
333  *   check is done and only the version string is returned.
334   **/
335 const char *gnutls_check_version(const char *req_version)
336 {
337         if (!req_version || strverscmp(req_version, VERSION) <= 0)
338                 return VERSION;
339
340         return NULL;
341 }