00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef _ASTERISK_UTILS_H
00024 #define _ASTERISK_UTILS_H
00025
00026 #include "asterisk/network.h"
00027
00028 #include <time.h>
00029 #include <unistd.h>
00030
00031 #include "asterisk/lock.h"
00032 #include "asterisk/time.h"
00033 #include "asterisk/logger.h"
00034 #include "asterisk/localtime.h"
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059 extern unsigned int __unsigned_int_flags_dummy;
00060
00061 #define ast_test_flag(p,flag) ({ \
00062 typeof ((p)->flags) __p = (p)->flags; \
00063 typeof (__unsigned_int_flags_dummy) __x = 0; \
00064 (void) (&__p == &__x); \
00065 ((p)->flags & (flag)); \
00066 })
00067
00068 #define ast_set_flag(p,flag) do { \
00069 typeof ((p)->flags) __p = (p)->flags; \
00070 typeof (__unsigned_int_flags_dummy) __x = 0; \
00071 (void) (&__p == &__x); \
00072 ((p)->flags |= (flag)); \
00073 } while(0)
00074
00075 #define ast_clear_flag(p,flag) do { \
00076 typeof ((p)->flags) __p = (p)->flags; \
00077 typeof (__unsigned_int_flags_dummy) __x = 0; \
00078 (void) (&__p == &__x); \
00079 ((p)->flags &= ~(flag)); \
00080 } while(0)
00081
00082 #define ast_copy_flags(dest,src,flagz) do { \
00083 typeof ((dest)->flags) __d = (dest)->flags; \
00084 typeof ((src)->flags) __s = (src)->flags; \
00085 typeof (__unsigned_int_flags_dummy) __x = 0; \
00086 (void) (&__d == &__x); \
00087 (void) (&__s == &__x); \
00088 (dest)->flags &= ~(flagz); \
00089 (dest)->flags |= ((src)->flags & (flagz)); \
00090 } while (0)
00091
00092 #define ast_set2_flag(p,value,flag) do { \
00093 typeof ((p)->flags) __p = (p)->flags; \
00094 typeof (__unsigned_int_flags_dummy) __x = 0; \
00095 (void) (&__p == &__x); \
00096 if (value) \
00097 (p)->flags |= (flag); \
00098 else \
00099 (p)->flags &= ~(flag); \
00100 } while (0)
00101
00102 #define ast_set_flags_to(p,flag,value) do { \
00103 typeof ((p)->flags) __p = (p)->flags; \
00104 typeof (__unsigned_int_flags_dummy) __x = 0; \
00105 (void) (&__p == &__x); \
00106 (p)->flags &= ~(flag); \
00107 (p)->flags |= (value); \
00108 } while (0)
00109
00110
00111
00112
00113
00114
00115
00116 extern uint64_t __unsigned_int_flags_dummy64;
00117
00118 #define ast_test_flag64(p,flag) ({ \
00119 typeof ((p)->flags) __p = (p)->flags; \
00120 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00121 (void) (&__p == &__x); \
00122 ((p)->flags & (flag)); \
00123 })
00124
00125 #define ast_set_flag64(p,flag) do { \
00126 typeof ((p)->flags) __p = (p)->flags; \
00127 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00128 (void) (&__p == &__x); \
00129 ((p)->flags |= (flag)); \
00130 } while(0)
00131
00132 #define ast_clear_flag64(p,flag) do { \
00133 typeof ((p)->flags) __p = (p)->flags; \
00134 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00135 (void) (&__p == &__x); \
00136 ((p)->flags &= ~(flag)); \
00137 } while(0)
00138
00139 #define ast_copy_flags64(dest,src,flagz) do { \
00140 typeof ((dest)->flags) __d = (dest)->flags; \
00141 typeof ((src)->flags) __s = (src)->flags; \
00142 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00143 (void) (&__d == &__x); \
00144 (void) (&__s == &__x); \
00145 (dest)->flags &= ~(flagz); \
00146 (dest)->flags |= ((src)->flags & (flagz)); \
00147 } while (0)
00148
00149 #define ast_set2_flag64(p,value,flag) do { \
00150 typeof ((p)->flags) __p = (p)->flags; \
00151 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00152 (void) (&__p == &__x); \
00153 if (value) \
00154 (p)->flags |= (flag); \
00155 else \
00156 (p)->flags &= ~(flag); \
00157 } while (0)
00158
00159 #define ast_set_flags_to64(p,flag,value) do { \
00160 typeof ((p)->flags) __p = (p)->flags; \
00161 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00162 (void) (&__p == &__x); \
00163 (p)->flags &= ~(flag); \
00164 (p)->flags |= (value); \
00165 } while (0)
00166
00167
00168
00169
00170
00171 #define ast_test_flag_nonstd(p,flag) \
00172 ((p)->flags & (flag))
00173
00174 #define ast_set_flag_nonstd(p,flag) do { \
00175 ((p)->flags |= (flag)); \
00176 } while(0)
00177
00178 #define ast_clear_flag_nonstd(p,flag) do { \
00179 ((p)->flags &= ~(flag)); \
00180 } while(0)
00181
00182 #define ast_copy_flags_nonstd(dest,src,flagz) do { \
00183 (dest)->flags &= ~(flagz); \
00184 (dest)->flags |= ((src)->flags & (flagz)); \
00185 } while (0)
00186
00187 #define ast_set2_flag_nonstd(p,value,flag) do { \
00188 if (value) \
00189 (p)->flags |= (flag); \
00190 else \
00191 (p)->flags &= ~(flag); \
00192 } while (0)
00193
00194 #define AST_FLAGS_ALL UINT_MAX
00195
00196
00197
00198 struct ast_flags {
00199 unsigned int flags;
00200 };
00201
00202
00203
00204 struct ast_flags64 {
00205 uint64_t flags;
00206 };
00207
00208 struct ast_hostent {
00209 struct hostent hp;
00210 char buf[1024];
00211 };
00212
00213
00214 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp);
00215
00216
00217 void ast_md5_hash(char *output, char *input);
00218
00219 void ast_sha1_hash(char *output, char *input);
00220
00221 int ast_base64encode_full(char *dst, const unsigned char *src, int srclen, int max, int linebreaks);
00222
00223 #undef MIN
00224 #define MIN(a, b) ({ typeof(a) __a = (a); typeof(b) __b = (b); ((__a > __b) ? __b : __a);})
00225 #undef MAX
00226 #define MAX(a, b) ({ typeof(a) __a = (a); typeof(b) __b = (b); ((__a < __b) ? __b : __a);})
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236 int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max);
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247 int ast_base64decode(unsigned char *dst, const char *src, int max);
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264 char *ast_uri_encode(const char *string, char *outbuf, int buflen, int doreserved);
00265
00266
00267
00268
00269 void ast_uri_decode(char *s);
00270
00271 static force_inline void ast_slinear_saturated_add(short *input, short *value)
00272 {
00273 int res;
00274
00275 res = (int) *input + *value;
00276 if (res > 32767)
00277 *input = 32767;
00278 else if (res < -32767)
00279 *input = -32767;
00280 else
00281 *input = (short) res;
00282 }
00283
00284 static force_inline void ast_slinear_saturated_subtract(short *input, short *value)
00285 {
00286 int res;
00287
00288 res = (int) *input - *value;
00289 if (res > 32767)
00290 *input = 32767;
00291 else if (res < -32767)
00292 *input = -32767;
00293 else
00294 *input = (short) res;
00295 }
00296
00297 static force_inline void ast_slinear_saturated_multiply(short *input, short *value)
00298 {
00299 int res;
00300
00301 res = (int) *input * *value;
00302 if (res > 32767)
00303 *input = 32767;
00304 else if (res < -32767)
00305 *input = -32767;
00306 else
00307 *input = (short) res;
00308 }
00309
00310 static force_inline void ast_slinear_saturated_divide(short *input, short *value)
00311 {
00312 *input /= *value;
00313 }
00314
00315 #ifdef localtime_r
00316 #undef localtime_r
00317 #endif
00318 #define localtime_r __dont_use_localtime_r_use_ast_localtime_instead__
00319
00320 int ast_utils_init(void);
00321 int ast_wait_for_input(int fd, int ms);
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332 int ast_carefulwrite(int fd, char *s, int len, int timeoutms);
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351 int ast_careful_fwrite(FILE *f, int fd, const char *s, size_t len, int timeoutms);
00352
00353
00354
00355
00356
00357 #define AST_STACKSIZE (((sizeof(void *) * 8 * 8) - 16) * 1024)
00358
00359 #if defined(LOW_MEMORY)
00360 #define AST_BACKGROUND_STACKSIZE (((sizeof(void *) * 8 * 2) - 16) * 1024)
00361 #else
00362 #define AST_BACKGROUND_STACKSIZE AST_STACKSIZE
00363 #endif
00364
00365 void ast_register_thread(char *name);
00366 void ast_unregister_thread(void *id);
00367
00368 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
00369 void *data, size_t stacksize, const char *file, const char *caller,
00370 int line, const char *start_fn);
00371
00372 int ast_pthread_create_detached_stack(pthread_t *thread, pthread_attr_t *attr, void*(*start_routine)(void *),
00373 void *data, size_t stacksize, const char *file, const char *caller,
00374 int line, const char *start_fn);
00375
00376 #define ast_pthread_create(a, b, c, d) \
00377 ast_pthread_create_stack(a, b, c, d, \
00378 0, __FILE__, __FUNCTION__, __LINE__, #c)
00379
00380 #define ast_pthread_create_detached(a, b, c, d) \
00381 ast_pthread_create_detached_stack(a, b, c, d, \
00382 0, __FILE__, __FUNCTION__, __LINE__, #c)
00383
00384 #define ast_pthread_create_background(a, b, c, d) \
00385 ast_pthread_create_stack(a, b, c, d, \
00386 AST_BACKGROUND_STACKSIZE, \
00387 __FILE__, __FUNCTION__, __LINE__, #c)
00388
00389 #define ast_pthread_create_detached_background(a, b, c, d) \
00390 ast_pthread_create_detached_stack(a, b, c, d, \
00391 AST_BACKGROUND_STACKSIZE, \
00392 __FILE__, __FUNCTION__, __LINE__, #c)
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with);
00403
00404 long int ast_random(void);
00405
00406
00407
00408
00409
00410
00411
00412
00413 #ifdef __AST_DEBUG_MALLOC
00414 static void ast_free_ptr(void *ptr) attribute_unused;
00415 static void ast_free_ptr(void *ptr)
00416 {
00417 ast_free(ptr);
00418 }
00419 #else
00420 #define ast_free free
00421 #define ast_free_ptr ast_free
00422 #endif
00423
00424 #ifndef __AST_DEBUG_MALLOC
00425
00426 #define MALLOC_FAILURE_MSG \
00427 ast_log(LOG_ERROR, "Memory Allocation Failure in function %s at line %d of %s\n", func, lineno, file);
00428
00429
00430
00431
00432
00433
00434
00435
00436 #define ast_malloc(len) \
00437 _ast_malloc((len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00438
00439 AST_INLINE_API(
00440 void * attribute_malloc _ast_malloc(size_t len, const char *file, int lineno, const char *func),
00441 {
00442 void *p;
00443
00444 if (!(p = malloc(len)))
00445 MALLOC_FAILURE_MSG;
00446
00447 return p;
00448 }
00449 )
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459 #define ast_calloc(num, len) \
00460 _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00461
00462 AST_INLINE_API(
00463 void * attribute_malloc _ast_calloc(size_t num, size_t len, const char *file, int lineno, const char *func),
00464 {
00465 void *p;
00466
00467 if (!(p = calloc(num, len)))
00468 MALLOC_FAILURE_MSG;
00469
00470 return p;
00471 }
00472 )
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484 #define ast_calloc_cache(num, len) \
00485 _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495 #define ast_realloc(p, len) \
00496 _ast_realloc((p), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00497
00498 AST_INLINE_API(
00499 void * attribute_malloc _ast_realloc(void *p, size_t len, const char *file, int lineno, const char *func),
00500 {
00501 void *newp;
00502
00503 if (!(newp = realloc(p, len)))
00504 MALLOC_FAILURE_MSG;
00505
00506 return newp;
00507 }
00508 )
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522 #define ast_strdup(str) \
00523 _ast_strdup((str), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00524
00525 AST_INLINE_API(
00526 char * attribute_malloc _ast_strdup(const char *str, const char *file, int lineno, const char *func),
00527 {
00528 char *newstr = NULL;
00529
00530 if (str) {
00531 if (!(newstr = strdup(str)))
00532 MALLOC_FAILURE_MSG;
00533 }
00534
00535 return newstr;
00536 }
00537 )
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551 #define ast_strndup(str, len) \
00552 _ast_strndup((str), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00553
00554 AST_INLINE_API(
00555 char * attribute_malloc _ast_strndup(const char *str, size_t len, const char *file, int lineno, const char *func),
00556 {
00557 char *newstr = NULL;
00558
00559 if (str) {
00560 if (!(newstr = strndup(str, len)))
00561 MALLOC_FAILURE_MSG;
00562 }
00563
00564 return newstr;
00565 }
00566 )
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576 #define ast_asprintf(ret, fmt, ...) \
00577 _ast_asprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, __VA_ARGS__)
00578
00579 int __attribute__((format(printf, 5, 6)))
00580 _ast_asprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, ...);
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590 #define ast_vasprintf(ret, fmt, ap) \
00591 _ast_vasprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, (fmt), (ap))
00592
00593 AST_INLINE_API(
00594 __attribute__((format(printf, 5, 0)))
00595 int _ast_vasprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, va_list ap),
00596 {
00597 int res;
00598
00599 if ((res = vasprintf(ret, fmt, ap)) == -1)
00600 MALLOC_FAILURE_MSG;
00601
00602 return res;
00603 }
00604 )
00605
00606 #endif
00607
00608 #if !defined(ast_strdupa) && defined(__GNUC__)
00609
00610
00611
00612
00613
00614
00615
00616 #define ast_strdupa(s) \
00617 (__extension__ \
00618 ({ \
00619 const char *__old = (s); \
00620 size_t __len = strlen(__old) + 1; \
00621 char *__new = __builtin_alloca(__len); \
00622 memcpy (__new, __old, __len); \
00623 __new; \
00624 }))
00625 #endif
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640 void ast_enable_packet_fragmentation(int sock);
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650 int ast_mkdir(const char *path, int mode);
00651
00652 #define ARRAY_LEN(a) (sizeof(a) / sizeof(0[a]))
00653
00654 #ifdef AST_DEVMODE
00655 #define ast_assert(a) _ast_assert(a, # a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
00656 static void force_inline _ast_assert(int condition, const char *condition_str,
00657 const char *file, int line, const char *function)
00658 {
00659 if (__builtin_expect(!condition, 1)) {
00660
00661
00662 ast_log(__LOG_ERROR, file, line, function, "FRACK!, Failed assertion %s (%d)\n",
00663 condition_str, condition);
00664 fprintf(stderr, "FRACK!, Failed assertion %s (%d) at line %d in %s of %s\n",
00665 condition_str, condition, line, function, file);
00666
00667
00668 usleep(1);
00669 #ifdef DO_CRASH
00670 abort();
00671
00672
00673 *((int*)0)=0;
00674 #endif
00675 }
00676 }
00677 #else
00678 #define ast_assert(a)
00679 #endif
00680
00681 #include "asterisk/strings.h"
00682
00683
00684
00685
00686 struct ast_eid {
00687 unsigned char eid[6];
00688 } __attribute__((__packed__));
00689
00690
00691
00692
00693
00694
00695
00696 extern struct ast_eid ast_eid_default;
00697
00698
00699
00700
00701
00702 void ast_set_default_eid(struct ast_eid *eid);
00703
00704
00705
00706
00707
00708 char *ast_eid_to_str(char *s, int maxlen, struct ast_eid *eid);
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719 int ast_str_to_eid(struct ast_eid *eid, const char *s);
00720
00721
00722
00723
00724
00725
00726
00727 int ast_eid_cmp(const struct ast_eid *eid1, const struct ast_eid *eid2);
00728
00729
00730
00731
00732
00733
00734
00735
00736 char *ast_utils_which(const char *binary, char *fullpath, size_t fullpath_size);
00737
00738 #endif