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 24 : 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 :
|
