changes for base64 to work in multiline instances
[asterisk/asterisk.git] / include / asterisk / utils.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  * \brief Utility functions
21  */
22
23 #ifndef _ASTERISK_UTILS_H
24 #define _ASTERISK_UTILS_H
25
26 #include "asterisk/compat.h"
27
28 #include <stdlib.h>
29 #include <netinet/in.h>
30 #include <arpa/inet.h>  /* we want to override inet_ntoa */
31 #include <netdb.h>
32 #include <limits.h>
33
34 #include "asterisk/lock.h"
35 #include "asterisk/time.h"
36 #include "asterisk/strings.h"
37 #include "asterisk/logger.h"
38
39 /*! \note
40  \verbatim
41    Note:
42    It is very important to use only unsigned variables to hold
43    bit flags, as otherwise you can fall prey to the compiler's
44    sign-extension antics if you try to use the top two bits in
45    your variable.
46
47    The flag macros below use a set of compiler tricks to verify
48    that the caller is using an "unsigned int" variable to hold
49    the flags, and nothing else. If the caller uses any other
50    type of variable, a warning message similar to this:
51
52    warning: comparison of distinct pointer types lacks cast
53    will be generated.
54
55    The "dummy" variable below is used to make these comparisons.
56
57    Also note that at -O2 or above, this type-safety checking
58    does _not_ produce any additional object code at all.
59  \endverbatim
60 */
61
62 extern unsigned int __unsigned_int_flags_dummy;
63
64 #define ast_test_flag(p,flag)           ({ \
65                                         typeof ((p)->flags) __p = (p)->flags; \
66                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
67                                         (void) (&__p == &__x); \
68                                         ((p)->flags & (flag)); \
69                                         })
70
71 #define ast_set_flag(p,flag)            do { \
72                                         typeof ((p)->flags) __p = (p)->flags; \
73                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
74                                         (void) (&__p == &__x); \
75                                         ((p)->flags |= (flag)); \
76                                         } while(0)
77
78 #define ast_clear_flag(p,flag)          do { \
79                                         typeof ((p)->flags) __p = (p)->flags; \
80                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
81                                         (void) (&__p == &__x); \
82                                         ((p)->flags &= ~(flag)); \
83                                         } while(0)
84
85 #define ast_copy_flags(dest,src,flagz)  do { \
86                                         typeof ((dest)->flags) __d = (dest)->flags; \
87                                         typeof ((src)->flags) __s = (src)->flags; \
88                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
89                                         (void) (&__d == &__x); \
90                                         (void) (&__s == &__x); \
91                                         (dest)->flags &= ~(flagz); \
92                                         (dest)->flags |= ((src)->flags & (flagz)); \
93                                         } while (0)
94
95 #define ast_set2_flag(p,value,flag)     do { \
96                                         typeof ((p)->flags) __p = (p)->flags; \
97                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
98                                         (void) (&__p == &__x); \
99                                         if (value) \
100                                                 (p)->flags |= (flag); \
101                                         else \
102                                                 (p)->flags &= ~(flag); \
103                                         } while (0)
104
105 #define ast_set_flags_to(p,flag,value)  do { \
106                                         typeof ((p)->flags) __p = (p)->flags; \
107                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
108                                         (void) (&__p == &__x); \
109                                         (p)->flags &= ~(flag); \
110                                         (p)->flags |= (value); \
111                                         } while (0)
112
113 /* Non-type checking variations for non-unsigned int flags.  You
114    should only use non-unsigned int flags where required by 
115    protocol etc and if you know what you're doing :)  */
116 #define ast_test_flag_nonstd(p,flag)            ({ \
117                                         ((p)->flags & (flag)); \
118                                         })
119
120 #define ast_set_flag_nonstd(p,flag)             do { \
121                                         ((p)->flags |= (flag)); \
122                                         } while(0)
123
124 #define ast_clear_flag_nonstd(p,flag)           do { \
125                                         ((p)->flags &= ~(flag)); \
126                                         } while(0)
127
128 #define ast_copy_flags_nonstd(dest,src,flagz)   do { \
129                                         (dest)->flags &= ~(flagz); \
130                                         (dest)->flags |= ((src)->flags & (flagz)); \
131                                         } while (0)
132
133 #define ast_set2_flag_nonstd(p,value,flag)      do { \
134                                         if (value) \
135                                                 (p)->flags |= (flag); \
136                                         else \
137                                                 (p)->flags &= ~(flag); \
138                                         } while (0)
139
140 #define AST_FLAGS_ALL UINT_MAX
141
142 struct ast_flags {
143         unsigned int flags;
144 };
145
146 struct ast_hostent {
147         struct hostent hp;
148         char buf[1024];
149 };
150
151 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp);
152
153 /* ast_md5_hash 
154         \brief Produces MD5 hash based on input string */
155 void ast_md5_hash(char *output, char *input);
156 /* ast_sha1_hash
157         \brief Produces SHA1 hash based on input string */
158 void ast_sha1_hash(char *output, char *input);
159
160 int ast_base64encode_full(char *dst, const unsigned char *src, int srclen, int max, int linebreaks);
161 int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max);
162 int ast_base64decode(unsigned char *dst, const char *src, int max);
163
164 /*! ast_uri_encode
165         \brief Turn text string to URI-encoded %XX version 
166         At this point, we're converting from ISO-8859-x (8-bit), not UTF8
167         as in the SIP protocol spec 
168         If doreserved == 1 we will convert reserved characters also.
169         RFC 2396, section 2.4
170         outbuf needs to have more memory allocated than the instring
171         to have room for the expansion. Every char that is converted
172         is replaced by three ASCII characters.
173         \param string   String to be converted
174         \param outbuf   Resulting encoded string
175         \param buflen   Size of output buffer
176         \param doreserved       Convert reserved characters
177 */
178
179 char *ast_uri_encode(const char *string, char *outbuf, int buflen, int doreserved);
180
181 /*!     \brief Decode URI, URN, URL (overwrite string)
182         \param s        String to be decoded 
183  */
184 void ast_uri_decode(char *s);
185
186 static force_inline void ast_slinear_saturated_add(short *input, short *value)
187 {
188         int res;
189
190         res = (int) *input + *value;
191         if (res > 32767)
192                 *input = 32767;
193         else if (res < -32767)
194                 *input = -32767;
195         else
196                 *input = (short) res;
197 }
198         
199 static force_inline void ast_slinear_saturated_multiply(short *input, short *value)
200 {
201         int res;
202
203         res = (int) *input * *value;
204         if (res > 32767)
205                 *input = 32767;
206         else if (res < -32767)
207                 *input = -32767;
208         else
209                 *input = (short) res;
210 }
211
212 static force_inline void ast_slinear_saturated_divide(short *input, short *value)
213 {
214         *input /= *value;
215 }
216
217 int test_for_thread_safety(void);
218
219 const char *ast_inet_ntoa(char *buf, int bufsiz, struct in_addr ia);
220
221 #ifdef inet_ntoa
222 #undef inet_ntoa
223 #endif
224 #define inet_ntoa __dont__use__inet_ntoa__use__ast_inet_ntoa__instead__
225
226 int ast_utils_init(void);
227 int ast_wait_for_input(int fd, int ms);
228
229 /*! ast_carefulwrite
230         \brief Try to write string, but wait no more than ms milliseconds
231         before timing out.
232
233         \note If you are calling ast_carefulwrite, it is assumed that you are calling
234         it on a file descriptor that _DOES_ have NONBLOCK set.  This way,
235         there is only one system call made to do a write, unless we actually
236         have a need to wait.  This way, we get better performance.
237 */
238 int ast_carefulwrite(int fd, char *s, int len, int timeoutms);
239
240 /*! Compares the source address and port of two sockaddr_in */
241 static force_inline int inaddrcmp(const struct sockaddr_in *sin1, const struct sockaddr_in *sin2)
242 {
243         return ((sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) 
244                 || (sin1->sin_port != sin2->sin_port));
245 }
246
247 #define AST_STACKSIZE 256 * 1024
248
249 void ast_register_thread(char *name);
250 void ast_unregister_thread(void *id);
251
252 #define ast_pthread_create(a,b,c,d) ast_pthread_create_stack(a,b,c,d,0, \
253          __FILE__, __FUNCTION__, __LINE__, #c)
254 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize,
255         const char *file, const char *caller, int line, const char *start_fn);
256
257 /*!
258         \brief Process a string to find and replace characters
259         \param start The string to analyze
260         \param find The character to find
261         \param replace_with The character that will replace the one we are looking for
262 */
263 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with);
264
265 #ifndef HAVE_GETLOADAVG
266 int getloadavg(double *list, int nelem);
267 #endif
268
269 #ifdef linux
270 #define ast_random random
271 #else
272 long int ast_random(void);
273 #endif
274
275 #ifndef __AST_DEBUG_MALLOC
276
277 /*!
278   \brief A wrapper for malloc()
279
280   ast_malloc() is a wrapper for malloc() that will generate an Asterisk log
281   message in the case that the allocation fails.
282
283   The argument and return value are the same as malloc()
284 */
285 #define ast_malloc(len) \
286         _ast_malloc((len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
287
288 AST_INLINE_API(
289 void * __attribute__((malloc)) _ast_malloc(size_t len, const char *file, int lineno, const char *func),
290 {
291         void *p;
292
293         p = malloc(len);
294
295         if (!p)
296                 ast_log(LOG_ERROR, "Memory Allocation Failure - '%d' bytes in function %s at line %d of %s\n", (int)len, func, lineno, file);
297
298         return p;
299 }
300 )
301
302 /*!
303   \brief A wrapper for calloc()
304
305   ast_calloc() is a wrapper for calloc() that will generate an Asterisk log
306   message in the case that the allocation fails.
307
308   The arguments and return value are the same as calloc()
309 */
310 #define ast_calloc(num, len) \
311         _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
312
313 AST_INLINE_API(
314 void * __attribute__((malloc)) _ast_calloc(size_t num, size_t len, const char *file, int lineno, const char *func),
315 {
316         void *p;
317
318         p = calloc(num, len);
319
320         if (!p)
321                 ast_log(LOG_ERROR, "Memory Allocation Failure - '%d' bytes in function %s at line %d of %s\n", (int)len, func, lineno, file);
322
323         return p;
324 }
325 )
326
327 /*!
328   \brief A wrapper for realloc()
329
330   ast_realloc() is a wrapper for realloc() that will generate an Asterisk log
331   message in the case that the allocation fails.
332
333   The arguments and return value are the same as realloc()
334 */
335 #define ast_realloc(p, len) \
336         _ast_realloc((p), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
337
338 AST_INLINE_API(
339 void * __attribute__((malloc)) _ast_realloc(void *p, size_t len, const char *file, int lineno, const char *func),
340 {
341         void *newp;
342
343         newp = realloc(p, len);
344
345         if (!newp)
346                 ast_log(LOG_ERROR, "Memory Allocation Failure - '%d' bytes in function %s at line %d of %s\n", (int)len, func, lineno, file);
347
348         return newp;
349 }
350 )
351
352 /*!
353   \brief A wrapper for strdup()
354
355   ast_strdup() is a wrapper for strdup() that will generate an Asterisk log
356   message in the case that the allocation fails.
357
358   ast_strdup(), unlike strdup(), can safely accept a NULL argument. If a NULL
359   argument is provided, ast_strdup will return NULL without generating any
360   kind of error log message.
361
362   The argument and return value are the same as strdup()
363 */
364 #define ast_strdup(str) \
365         _ast_strdup((str), __FILE__, __LINE__, __PRETTY_FUNCTION__)
366
367 AST_INLINE_API(
368 char * __attribute__((malloc)) _ast_strdup(const char *str, const char *file, int lineno, const char *func),
369 {
370         char *newstr = NULL;
371
372         if (str) {
373                 newstr = strdup(str);
374
375                 if (!newstr)
376                         ast_log(LOG_ERROR, "Memory Allocation Failure - Could not duplicate '%s' in function %s at line %d of %s\n", str, func, lineno, file);
377         }
378
379         return newstr;
380 }
381 )
382
383 /*!
384   \brief A wrapper for strndup()
385
386   ast_strndup() is a wrapper for strndup() that will generate an Asterisk log
387   message in the case that the allocation fails.
388
389   ast_strndup(), unlike strndup(), can safely accept a NULL argument for the
390   string to duplicate. If a NULL argument is provided, ast_strdup will return  
391   NULL without generating any kind of error log message.
392
393   The arguments and return value are the same as strndup()
394 */
395 #define ast_strndup(str, len) \
396         _ast_strndup((str), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
397
398 AST_INLINE_API(
399 char * __attribute__((malloc)) _ast_strndup(const char *str, size_t len, const char *file, int lineno, const char *func),
400 {
401         char *newstr = NULL;
402
403         if (str) {
404                 newstr = strndup(str, len);
405
406                 if (!newstr)
407                         ast_log(LOG_ERROR, "Memory Allocation Failure - Could not duplicate '%d' bytes of '%s' in function %s at line %d of %s\n", (int)len, str, func, lineno, file);
408         }
409
410         return newstr;
411 }
412 )
413
414 #else
415
416 /* If astmm is in use, let it handle these.  Otherwise, it will report that
417    all allocations are coming from this header file */
418
419 #define ast_malloc(a)           malloc(a)
420 #define ast_calloc(a,b)         calloc(a,b)
421 #define ast_realloc(a,b)        realloc(a,b)
422 #define ast_strdup(a)           strdup(a)
423 #define ast_strndup(a,b)        strndup(a,b)
424
425 #endif /* AST_DEBUG_MALLOC */
426
427 #if !defined(ast_strdupa) && defined(__GNUC__)
428 /*!
429   \brief duplicate a string in memory from the stack
430   \param s The string to duplicate
431
432   This macro will duplicate the given string.  It returns a pointer to the stack
433   allocatted memory for the new string.
434 */
435 #define ast_strdupa(s)                                                    \
436         (__extension__                                                    \
437         ({                                                                \
438                 const char *__old = (s);                                  \
439                 size_t __len = strlen(__old) + 1;                         \
440                 char *__new = __builtin_alloca(__len);                    \
441                 memcpy (__new, __old, __len);                             \
442                 __new;                                                    \
443         }))
444 #endif
445
446 #endif /* _ASTERISK_UTILS_H */