LCOV - code coverage report
Current view: top level - tests - common.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 46 98 46.9 %
Date: 2016-12-01 18:29:29 Functions: 8 14 57.1 %

          Line data    Source code
       1             : /* common.h - Common functions for the tests.
       2             :  * Copyright (C) 2006 Free Software Foundation, Inc.
       3             :  *
       4             :  * This file is part of Assuan.
       5             :  *
       6             :  * Assuan is free software; you can redistribute it and/or modify it
       7             :  * under the terms of the GNU Lesser General Public License as
       8             :  * published by the Free Software Foundation; either version 3 of
       9             :  * the License, or (at your option) any later version.
      10             :  *
      11             :  * Assuan is distributed in the hope that it will be useful, but
      12             :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :  * Lesser General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU Lesser General Public
      17             :  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
      18             :  */
      19             : 
      20             : #include <stdarg.h>
      21             : 
      22             : #if __GNUC__ >= 4 
      23             : # define MY_GCC_A_SENTINEL(a) __attribute__ ((sentinel(a)))
      24             : #else
      25             : # define MY_GCC_A_SENTINEL(a) 
      26             : #endif
      27             : 
      28             : 
      29             : #ifdef HAVE_W32CE_SYSTEM
      30             : #define getpid() GetCurrentProcessId ()
      31             : #define getenv(a) (NULL)
      32             : #endif
      33             : 
      34             : #if HAVE_W32_SYSTEM
      35             : #define SOCKET2HANDLE(s) ((void *)(s))
      36             : #define HANDLE2SOCKET(h) ((unsigned int)(h))
      37             : CRITICAL_SECTION _log_critsect;
      38             : #define _log_enter()  do { EnterCriticalSection (&_log_critsect); } while (0)
      39             : #define _log_leave()  do { LeaveCriticalSection (&_log_critsect); } while (0)
      40             : #else
      41             : #define SOCKET2HANDLE(s) (s)
      42             : #define HANDLE2SOCKET(h) (h)
      43             : #define _log_enter()  do { } while (0)
      44             : #define _log_leave()  do { } while (0)
      45             : #endif
      46             : 
      47             : #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
      48             : #define DIMof(type,member)   DIM(((type *)0)->member)
      49             : 
      50             : 
      51             : char *xstrconcat (const char *s1, ...) MY_GCC_A_SENTINEL(0);
      52             : 
      53             : 
      54             : static const char *log_prefix;
      55             : static int errorcount;
      56             : static int verbose;
      57             : static int debug;
      58             : 
      59             : void *
      60           4 : xmalloc (size_t n)
      61             : {
      62           4 :   char *p = malloc (n);
      63           4 :   if (!p)
      64             :     {
      65           0 :       if (log_prefix)
      66           0 :         fprintf (stderr, "%s[%u]: ", log_prefix, (unsigned int)getpid ());
      67           0 :       fprintf (stderr, "out of core\n");
      68           0 :       exit (1);
      69             :     }
      70           4 :   return p;
      71             : }
      72             : 
      73             : void *
      74           0 : xcalloc (size_t n, size_t m)
      75             : {
      76           0 :   char *p = calloc (n, m);
      77           0 :   if (!p)
      78             :     {
      79             :       _log_enter ();
      80           0 :       if (log_prefix)
      81           0 :         fprintf (stderr, "%s[%u]: ", log_prefix, (unsigned int)getpid ());
      82           0 :       fprintf (stderr, "out of core\n");
      83             :       _log_leave ();
      84           0 :       exit (1);
      85             :     }
      86           0 :   return p;
      87             : }
      88             : 
      89             : void
      90           2 : xfree (void *a)
      91             : {
      92           2 :   if (a)
      93           2 :     free (a);
      94           2 : }
      95             : 
      96             : void *
      97           0 : xstrdup (const char *string)
      98             : {
      99           0 :   char *p = xmalloc (strlen (string) + 1);
     100           0 :   strcpy (p, string);
     101           0 :   return p;
     102             : }
     103             : 
     104             : 
     105             : void
     106           7 : log_set_prefix (const char *s)
     107             : {
     108             : #ifdef HAVE_W32_SYSTEM
     109             :   InitializeCriticalSection (&_log_critsect);
     110             :   log_prefix = strrchr (s, '\\');
     111             : #else  
     112           7 :   log_prefix = strrchr (s, '/');
     113             : #endif  
     114           7 :   if (log_prefix)
     115           5 :     log_prefix++;
     116             :   else
     117           2 :     log_prefix = s;
     118           7 : }
     119             : 
     120             : 
     121             : const char *
     122           4 : log_get_prefix (void)
     123             : {
     124           4 :   return log_prefix? log_prefix:"";
     125             : }
     126             : 
     127             : 
     128             : void
     129          24 : log_info (const char *format, ...)
     130             : {
     131             :   va_list arg_ptr ;
     132             : 
     133          24 :   if (!verbose)
     134          48 :     return;
     135             : 
     136           0 :   va_start (arg_ptr, format) ;
     137             :   _log_enter ();
     138           0 :   if (log_prefix)
     139           0 :     fprintf (stderr, "%s[%u]: ", log_prefix, (unsigned int)getpid ());
     140           0 :   vfprintf (stderr, format, arg_ptr );
     141             :   _log_leave ();
     142           0 :   va_end (arg_ptr);
     143             : }
     144             : 
     145             : 
     146             : void
     147           0 : log_error (const char *format, ...)
     148             : {
     149             :   va_list arg_ptr ;
     150             : 
     151           0 :   va_start (arg_ptr, format) ;
     152             :   _log_enter ();
     153           0 :   if (log_prefix)
     154           0 :     fprintf (stderr, "%s[%u]: ", log_prefix, (unsigned int)getpid ());
     155           0 :   vfprintf (stderr, format, arg_ptr );
     156             :   _log_leave ();
     157           0 :   va_end (arg_ptr);
     158           0 :   errorcount++;
     159           0 : }
     160             : 
     161             : 
     162             : void
     163           0 : log_fatal (const char *format, ...)
     164             : {
     165             :   va_list arg_ptr ;
     166             : 
     167           0 :   va_start (arg_ptr, format) ;
     168             :   _log_enter ();
     169           0 :   if (log_prefix)
     170           0 :     fprintf (stderr, "%s[%u]: ", log_prefix, (unsigned int)getpid ());
     171           0 :   vfprintf (stderr, format, arg_ptr );
     172             :   _log_leave ();
     173           0 :   va_end (arg_ptr);
     174           0 :   exit (2);
     175             : }
     176             : 
     177             : 
     178             : void
     179           0 : log_printhex (const char *text, const void *buffer, size_t length)
     180             : {
     181             :   const unsigned char *s;
     182             : 
     183             :   _log_enter ();
     184           0 :   if (log_prefix)
     185           0 :     fprintf (stderr, "%s[%u]: ", log_prefix, (unsigned int)getpid ());
     186           0 :   fputs (text, stderr);
     187           0 :   for (s=buffer; length; s++, length--)
     188           0 :     fprintf (stderr, "%02X", *s);
     189           0 :   putc ('\n', stderr);
     190             :   _log_leave ();
     191           0 : }
     192             : 
     193             : 
     194             : /* Prepend FNAME with the srcdir environment variable's value and
     195             :    return an allocated filename. */
     196             : char *
     197           2 : prepend_srcdir (const char *fname)
     198             : {
     199             :   static const char *srcdir;
     200             :   char *result;
     201             : 
     202           2 :   if (!srcdir && !(srcdir = getenv ("srcdir")))
     203           0 :     srcdir = ".";
     204             :   
     205           2 :   result = xmalloc (strlen (srcdir) + 1 + strlen (fname) + 1);
     206           2 :   strcpy (result, srcdir);
     207           2 :   strcat (result, "/");
     208           2 :   strcat (result, fname);
     209           2 :   return result;
     210             : }
     211             : 
     212             : 
     213             : #ifndef HAVE_STPCPY
     214             : #undef __stpcpy
     215             : #undef stpcpy
     216             : #ifndef weak_alias
     217             : # define __stpcpy stpcpy
     218             : #endif
     219             : char *
     220             : __stpcpy (char *a,const char *b)
     221             : {
     222           0 :   while (*b)
     223           0 :     *a++ = *b++;
     224           0 :   *a = 0;
     225           0 :   return (char*)a;
     226             : }
     227             : #ifdef libc_hidden_def
     228             : libc_hidden_def (__stpcpy)
     229             : #endif
     230             : #ifdef weak_alias
     231             : weak_alias (__stpcpy, stpcpy)
     232             : #endif
     233             : #ifdef libc_hidden_builtin_def
     234             : libc_hidden_builtin_def (stpcpy)
     235             : #endif
     236             : #endif
     237             : 
     238             : 
     239             : static char *
     240           2 : do_strconcat (const char *s1, va_list arg_ptr)
     241             : {
     242             :   const char *argv[48];
     243             :   size_t argc;
     244             :   size_t needed;
     245             :   char *buffer, *p;
     246             : 
     247           2 :   argc = 0;
     248           2 :   argv[argc++] = s1;
     249           2 :   needed = strlen (s1);
     250           6 :   while (((argv[argc] = va_arg (arg_ptr, const char *))))
     251             :     {
     252           2 :       needed += strlen (argv[argc]);
     253           2 :       if (argc >= DIM (argv)-1)
     254             :         {
     255           0 :           fprintf (stderr, "too many args in strconcat\n");
     256           0 :           exit (1);
     257             :         }
     258           2 :       argc++;
     259             :     }
     260           2 :   needed++;
     261           2 :   buffer = xmalloc (needed);
     262           2 :   if (buffer)
     263             :     {
     264           6 :       for (p = buffer, argc=0; argv[argc]; argc++)
     265           4 :         p = stpcpy (p, argv[argc]);
     266             :     }
     267           2 :   return buffer;
     268             : }
     269             : 
     270             : 
     271             : /* Concatenate the string S1 with all the following strings up to a
     272             :    NULL.  Returns a malloced buffer or dies on malloc error.  */
     273             : char *
     274           2 : xstrconcat (const char *s1, ...)
     275             : {
     276             :   va_list arg_ptr;
     277             :   char *result;
     278             : 
     279           2 :   if (!s1)
     280           0 :     result = xstrdup ("");
     281             :   else
     282             :     {
     283           2 :       va_start (arg_ptr, s1);
     284           2 :       result = do_strconcat (s1, arg_ptr);
     285           2 :       va_end (arg_ptr);
     286             :     }
     287           2 :   return result;
     288             : }
     289             : 

Generated by: LCOV version 1.11