LCOV - code coverage report
Current view: top level - src - util.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 39 71 54.9 %
Date: 2016-12-01 18:28:20 Functions: 9 15 60.0 %

          Line data    Source code
       1             : /* util.c
       2             :  * Copyright (C) 2001, 2009, 2012 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 either
       8             :  *
       9             :  *   - the GNU Lesser General Public License as published by the Free
      10             :  *     Software Foundation; either version 3 of the License, or (at
      11             :  *     your option) any later version.
      12             :  *
      13             :  * or
      14             :  *
      15             :  *   - the GNU General Public License as published by the Free
      16             :  *     Software Foundation; either version 2 of the License, or (at
      17             :  *     your option) any later version.
      18             :  *
      19             :  * or both in parallel, as here.
      20             :  *
      21             :  * KSBA is distributed in the hope that it will be useful, but WITHOUT
      22             :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
      23             :  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
      24             :  * License for more details.
      25             :  *
      26             :  * You should have received a copies of the GNU General Public License
      27             :  * and the GNU Lesser General Public License along with this program;
      28             :  * if not, see <http://www.gnu.org/licenses/>.
      29             :  */
      30             : 
      31             : #include <config.h>
      32             : #include <stdio.h>
      33             : #include <stdlib.h>
      34             : #include <string.h>
      35             : #include <assert.h>
      36             : #include <errno.h>
      37             : 
      38             : #include "util.h"
      39             : 
      40             : static void *(*alloc_func)(size_t n) = malloc;
      41             : static void *(*realloc_func)(void *p, size_t n) = realloc;
      42             : static void (*free_func)(void*) = free;
      43             : static gpg_error_t (*hash_buffer_fnc)(void *arg, const char *oid,
      44             :                                       const void *buffer, size_t length,
      45             :                                       size_t resultsize,
      46             :                                       unsigned char *result, size_t *resultlen);
      47             : static void *hash_buffer_fnc_arg;
      48             : 
      49             : 
      50             : 
      51             : /* Note, that we expect that the free fucntion does not change
      52             :    ERRNO. */
      53             : void
      54           0 : ksba_set_malloc_hooks ( void *(*new_alloc_func)(size_t n),
      55             :                         void *(*new_realloc_func)(void *p, size_t n),
      56             :                         void (*new_free_func)(void*) )
      57             : {
      58           0 :   alloc_func        = new_alloc_func;
      59           0 :   realloc_func      = new_realloc_func;
      60           0 :   free_func         = new_free_func;
      61           0 : }
      62             : 
      63             : 
      64             : /* Register a has function for general use by libksba.  This is
      65             :    required to avoid dependencies to specific low-level
      66             :    crypolibraries.  The function should be used right at the startup
      67             :    of the main program, similar to ksba_set_malloc_hooks.
      68             : 
      69             :    The function provided should behave like this:
      70             : 
      71             :    gpg_error_t hash_buffer (void *arg, const char *oid,
      72             :                             const void *buffer, size_t length,
      73             :                             size_t resultsize,
      74             :                             unsigned char *result,
      75             :                             size_t *resultlen);
      76             : 
      77             :    Where ARG is the same pointer as set along with the fucntion, OID
      78             :    is an OID string telling the hash algorithm to be used - SHA-1
      79             :    shall be used if OID is NULL.  The text to hash is expected in
      80             :    BUFFER of LENGTH and the result will be placed into the provided
      81             :    buffer RESULT which has been allocated by the caller with at LEAST
      82             :    RESULTSIZE bytes; the actual length of the result is put into
      83             :    RESULTLEN.
      84             : 
      85             :    The function shall return 0 on success or any other appropriate
      86             :    gpg-error.
      87             : */
      88             : void
      89           0 : ksba_set_hash_buffer_function ( gpg_error_t (*fnc)
      90             :                                 (void *arg, const char *oid,
      91             :                                  const void *buffer, size_t length,
      92             :                                  size_t resultsize,
      93             :                                  unsigned char *result,
      94             :                                  size_t *resultlen),
      95             :                                 void *fnc_arg)
      96             : {
      97           0 :   hash_buffer_fnc = fnc;
      98           0 :   hash_buffer_fnc_arg = fnc_arg;
      99           0 : }
     100             : 
     101             : /* Hash BUFFER of LENGTH bytes using the algorithjm denoted by OID,
     102             :    where OID may be NULL to demand the use od SHA-1.  The resulting
     103             :    digest will be placed in the provided buffer RESULT which must have
     104             :    been allocated by the caller with at LEAST RESULTSIZE bytes; the
     105             :    actual length of the result is put into RESULTLEN.
     106             : 
     107             :    The function shall return 0 on success or any other appropriate
     108             :    gpg-error.
     109             : */
     110             : gpg_error_t
     111           0 : _ksba_hash_buffer (const char *oid, const void *buffer, size_t length,
     112             :                    size_t resultsize, unsigned char *result, size_t *resultlen)
     113             : {
     114           0 :   if (!hash_buffer_fnc)
     115           0 :     return gpg_error (GPG_ERR_CONFIGURATION);
     116           0 :   return hash_buffer_fnc (hash_buffer_fnc_arg, oid, buffer, length,
     117             :                           resultsize, result, resultlen);
     118             : }
     119             : 
     120             : 
     121             : /* Wrapper for the common memory allocation functions.  These are here
     122             :    so that we can add hooks.  The corresponding macros should be used.
     123             :    These macros are not named xfoo() because this name is commonly
     124             :    used for function which die on errror.  We use macronames like
     125             :    xtryfoo() instead. */
     126             : 
     127             : void *
     128        8587 : ksba_malloc (size_t n )
     129             : {
     130        8587 :   return alloc_func (n);
     131             : }
     132             : 
     133             : void *
     134          60 : ksba_calloc (size_t n, size_t m )
     135             : {
     136             :   size_t nbytes;
     137             :   void *p;
     138             : 
     139          60 :   nbytes = n * m;
     140          60 :   if ( m && nbytes / m != n)
     141             :     {
     142           0 :       gpg_err_set_errno (ENOMEM);
     143           0 :       p = NULL;
     144             :     }
     145             :   else
     146          60 :     p = ksba_malloc (nbytes);
     147          60 :   if (p)
     148          60 :     memset (p, 0, nbytes);
     149          60 :   return p;
     150             : }
     151             : 
     152             : void *
     153          25 : ksba_realloc (void *mem, size_t n)
     154             : {
     155          25 :   return realloc_func (mem, n );
     156             : }
     157             : 
     158             : 
     159             : char *
     160        4596 : ksba_strdup (const char *str)
     161             : {
     162        4596 :   char *p = ksba_malloc (strlen(str)+1);
     163        4596 :   if (p)
     164        4596 :     strcpy (p, str);
     165        4596 :   return p;
     166             : }
     167             : 
     168             : 
     169             : void
     170        9734 : ksba_free ( void *a )
     171             : {
     172        9734 :   if (a)
     173        8598 :     free_func (a);
     174        9734 : }
     175             : 
     176             : 
     177             : static void
     178           0 : out_of_core(void)
     179             : {
     180           0 :   fputs ("\nfatal: out of memory\n", stderr );
     181           0 :   exit (2);
     182             : }
     183             : 
     184             : 
     185             : /* Implementations of the common xfoo() memory allocation functions */
     186             : void *
     187        3786 : _ksba_xmalloc (size_t n )
     188             : {
     189        3786 :   void *p = ksba_malloc (n);
     190        3786 :   if (!p)
     191           0 :     out_of_core();
     192        3786 :   return p;
     193             : }
     194             : 
     195             : void *
     196           0 : _ksba_xcalloc (size_t n, size_t m )
     197             : {
     198           0 :   void *p = ksba_calloc (n,m);
     199           0 :   if (!p)
     200           0 :     out_of_core();
     201           0 :   return p;
     202             : }
     203             : 
     204             : void *
     205           0 : _ksba_xrealloc (void *mem, size_t n)
     206             : {
     207           0 :   void *p = ksba_realloc (mem,n);
     208           0 :   if (!p)
     209           0 :     out_of_core();
     210           0 :   return p;
     211             : }
     212             : 
     213             : 
     214             : char *
     215        4594 : _ksba_xstrdup (const char *str)
     216             : {
     217        4594 :   char *p = ksba_strdup (str);
     218        4594 :   if (!p)
     219           0 :     out_of_core();
     220        4594 :   return p;
     221             : }
     222             : 
     223             : 
     224             : #ifndef HAVE_STPCPY
     225             : char *
     226             : _ksba_stpcpy (char *a,const char *b)
     227             : {
     228             :   while (*b)
     229             :     *a++ = *b++;
     230             :   *a = 0;
     231             : 
     232             :   return a;
     233             : }
     234             : #endif
     235             : 
     236             : 
     237             : static inline int
     238         380 : ascii_toupper (int c)
     239             : {
     240         380 :   if (c >= 'a' && c <= 'z')
     241           0 :     c &= ~0x20;
     242         380 :   return c;
     243             : }
     244             : 
     245             : 
     246             : int
     247         175 : _ksba_ascii_memcasecmp (const void *a_arg, const void *b_arg, size_t n)
     248             : {
     249         175 :   const char *a = a_arg;
     250         175 :   const char *b = b_arg;
     251             : 
     252         175 :   if (a == b)
     253           0 :     return 0;
     254         298 :   for ( ; n; n--, a++, b++ )
     255             :     {
     256         218 :       if (*a != *b && ascii_toupper (*a) != ascii_toupper (*b))
     257          95 :         return *a == *b? 0 : (ascii_toupper (*a) - ascii_toupper (*b));
     258             :     }
     259          80 :   return 0;
     260             : }

Generated by: LCOV version 1.11