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 #include <string.h>
00031
00032 #include "asterisk/lock.h"
00033 #include "asterisk/time.h"
00034 #include "asterisk/logger.h"
00035 #include "asterisk/localtime.h"
00036 #include "asterisk/stringfields.h"
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061 extern unsigned int __unsigned_int_flags_dummy;
00062
00063 #define ast_test_flag(p,flag) ({ \
00064 typeof ((p)->flags) __p = (p)->flags; \
00065 typeof (__unsigned_int_flags_dummy) __x = 0; \
00066 (void) (&__p == &__x); \
00067 ((p)->flags & (flag)); \
00068 })
00069
00070 #define ast_set_flag(p,flag) do { \
00071 typeof ((p)->flags) __p = (p)->flags; \
00072 typeof (__unsigned_int_flags_dummy) __x = 0; \
00073 (void) (&__p == &__x); \
00074 ((p)->flags |= (flag)); \
00075 } while(0)
00076
00077 #define ast_clear_flag(p,flag) do { \
00078 typeof ((p)->flags) __p = (p)->flags; \
00079 typeof (__unsigned_int_flags_dummy) __x = 0; \
00080 (void) (&__p == &__x); \
00081 ((p)->flags &= ~(flag)); \
00082 } while(0)
00083
00084 #define ast_copy_flags(dest,src,flagz) do { \
00085 typeof ((dest)->flags) __d = (dest)->flags; \
00086 typeof ((src)->flags) __s = (src)->flags; \
00087 typeof (__unsigned_int_flags_dummy) __x = 0; \
00088 (void) (&__d == &__x); \
00089 (void) (&__s == &__x); \
00090 (dest)->flags &= ~(flagz); \
00091 (dest)->flags |= ((src)->flags & (flagz)); \
00092 } while (0)
00093
00094 #define ast_set2_flag(p,value,flag) do { \
00095 typeof ((p)->flags) __p = (p)->flags; \
00096 typeof (__unsigned_int_flags_dummy) __x = 0; \
00097 (void) (&__p == &__x); \
00098 if (value) \
00099 (p)->flags |= (flag); \
00100 else \
00101 (p)->flags &= ~(flag); \
00102 } while (0)
00103
00104 #define ast_set_flags_to(p,flag,value) do { \
00105 typeof ((p)->flags) __p = (p)->flags; \
00106 typeof (__unsigned_int_flags_dummy) __x = 0; \
00107 (void) (&__p == &__x); \
00108 (p)->flags &= ~(flag); \
00109 (p)->flags |= (value); \
00110 } while (0)
00111
00112
00113
00114
00115
00116
00117
00118 extern uint64_t __unsigned_int_flags_dummy64;
00119
00120 #define ast_test_flag64(p,flag) ({ \
00121 typeof ((p)->flags) __p = (p)->flags; \
00122 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00123 (void) (&__p == &__x); \
00124 ((p)->flags & (flag)); \
00125 })
00126
00127 #define ast_set_flag64(p,flag) do { \
00128 typeof ((p)->flags) __p = (p)->flags; \
00129 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00130 (void) (&__p == &__x); \
00131 ((p)->flags |= (flag)); \
00132 } while(0)
00133
00134 #define ast_clear_flag64(p,flag) do { \
00135 typeof ((p)->flags) __p = (p)->flags; \
00136 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00137 (void) (&__p == &__x); \
00138 ((p)->flags &= ~(flag)); \
00139 } while(0)
00140
00141 #define ast_copy_flags64(dest,src,flagz) do { \
00142 typeof ((dest)->flags) __d = (dest)->flags; \
00143 typeof ((src)->flags) __s = (src)->flags; \
00144 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00145 (void) (&__d == &__x); \
00146 (void) (&__s == &__x); \
00147 (dest)->flags &= ~(flagz); \
00148 (dest)->flags |= ((src)->flags & (flagz)); \
00149 } while (0)
00150
00151 #define ast_set2_flag64(p,value,flag) do { \
00152 typeof ((p)->flags) __p = (p)->flags; \
00153 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00154 (void) (&__p == &__x); \
00155 if (value) \
00156 (p)->flags |= (flag); \
00157 else \
00158 (p)->flags &= ~(flag); \
00159 } while (0)
00160
00161 #define ast_set_flags_to64(p,flag,value) do { \
00162 typeof ((p)->flags) __p = (p)->flags; \
00163 typeof (__unsigned_int_flags_dummy64) __x = 0; \
00164 (void) (&__p == &__x); \
00165 (p)->flags &= ~(flag); \
00166 (p)->flags |= (value); \
00167 } while (0)
00168
00169
00170
00171
00172
00173 #define ast_test_flag_nonstd(p,flag) \
00174 ((p)->flags & (flag))
00175
00176 #define ast_set_flag_nonstd(p,flag) do { \
00177 ((p)->flags |= (flag)); \
00178 } while(0)
00179
00180 #define ast_clear_flag_nonstd(p,flag) do { \
00181 ((p)->flags &= ~(flag)); \
00182 } while(0)
00183
00184 #define ast_copy_flags_nonstd(dest,src,flagz) do { \
00185 (dest)->flags &= ~(flagz); \
00186 (dest)->flags |= ((src)->flags & (flagz)); \
00187 } while (0)
00188
00189 #define ast_set2_flag_nonstd(p,value,flag) do { \
00190 if (value) \
00191 (p)->flags |= (flag); \
00192 else \
00193 (p)->flags &= ~(flag); \
00194 } while (0)
00195
00196 #define AST_FLAGS_ALL UINT_MAX
00197
00198
00199
00200 struct ast_flags {
00201 unsigned int flags;
00202 };
00203
00204
00205
00206 struct ast_flags64 {
00207 uint64_t flags;
00208 };
00209
00210 struct ast_hostent {
00211 struct hostent hp;
00212 char buf[1024];
00213 };
00214
00215
00216 struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp);
00217
00218
00219 void ast_md5_hash(char *output, const char *input);
00220
00221 void ast_sha1_hash(char *output, const char *input);
00222
00223 int ast_base64encode_full(char *dst, const unsigned char *src, int srclen, int max, int linebreaks);
00224
00225 #undef MIN
00226 #define MIN(a, b) ({ typeof(a) __a = (a); typeof(b) __b = (b); ((__a > __b) ? __b : __a);})
00227 #undef MAX
00228 #define MAX(a, b) ({ typeof(a) __a = (a); typeof(b) __b = (b); ((__a < __b) ? __b : __a);})
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238 int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max);
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249 int ast_base64decode(unsigned char *dst, const char *src, int max);
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269 char *ast_uri_encode(const char *string, char *outbuf, int buflen, int do_special_char);
00270
00271
00272
00273
00274 void ast_uri_decode(char *s);
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288 int ast_xml_escape(const char *string, char *outbuf, size_t buflen);
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301 char *ast_escape_quoted(const char *string, char *outbuf, int buflen);
00302
00303
00304
00305
00306
00307
00308
00309
00310 void ast_unescape_quoted(char *quote_str);
00311
00312 static force_inline void ast_slinear_saturated_add(short *input, short *value)
00313 {
00314 int res;
00315
00316 res = (int) *input + *value;
00317 if (res > 32767)
00318 *input = 32767;
00319 else if (res < -32768)
00320 *input = -32768;
00321 else
00322 *input = (short) res;
00323 }
00324
00325 static force_inline void ast_slinear_saturated_subtract(short *input, short *value)
00326 {
00327 int res;
00328
00329 res = (int) *input - *value;
00330 if (res > 32767)
00331 *input = 32767;
00332 else if (res < -32768)
00333 *input = -32768;
00334 else
00335 *input = (short) res;
00336 }
00337
00338 static force_inline void ast_slinear_saturated_multiply(short *input, short *value)
00339 {
00340 int res;
00341
00342 res = (int) *input * *value;
00343 if (res > 32767)
00344 *input = 32767;
00345 else if (res < -32768)
00346 *input = -32768;
00347 else
00348 *input = (short) res;
00349 }
00350
00351 static force_inline void ast_slinear_saturated_divide(short *input, short *value)
00352 {
00353 *input /= *value;
00354 }
00355
00356 #ifdef localtime_r
00357 #undef localtime_r
00358 #endif
00359 #define localtime_r __dont_use_localtime_r_use_ast_localtime_instead__
00360
00361 int ast_utils_init(void);
00362 int ast_wait_for_input(int fd, int ms);
00363 int ast_wait_for_output(int fd, int ms);
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374 int ast_carefulwrite(int fd, char *s, int len, int timeoutms);
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393 int ast_careful_fwrite(FILE *f, int fd, const char *s, size_t len, int timeoutms);
00394
00395
00396
00397
00398
00399 #define AST_STACKSIZE (((sizeof(void *) * 8 * 8) - 16) * 1024)
00400
00401 #if defined(LOW_MEMORY)
00402 #define AST_BACKGROUND_STACKSIZE (((sizeof(void *) * 8 * 2) - 16) * 1024)
00403 #else
00404 #define AST_BACKGROUND_STACKSIZE AST_STACKSIZE
00405 #endif
00406
00407 void ast_register_thread(char *name);
00408 void ast_unregister_thread(void *id);
00409
00410 int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *),
00411 void *data, size_t stacksize, const char *file, const char *caller,
00412 int line, const char *start_fn);
00413
00414 int ast_pthread_create_detached_stack(pthread_t *thread, pthread_attr_t *attr, void*(*start_routine)(void *),
00415 void *data, size_t stacksize, const char *file, const char *caller,
00416 int line, const char *start_fn);
00417
00418 #define ast_pthread_create(a, b, c, d) \
00419 ast_pthread_create_stack(a, b, c, d, \
00420 0, __FILE__, __FUNCTION__, __LINE__, #c)
00421
00422 #define ast_pthread_create_detached(a, b, c, d) \
00423 ast_pthread_create_detached_stack(a, b, c, d, \
00424 0, __FILE__, __FUNCTION__, __LINE__, #c)
00425
00426 #define ast_pthread_create_background(a, b, c, d) \
00427 ast_pthread_create_stack(a, b, c, d, \
00428 AST_BACKGROUND_STACKSIZE, \
00429 __FILE__, __FUNCTION__, __LINE__, #c)
00430
00431 #define ast_pthread_create_detached_background(a, b, c, d) \
00432 ast_pthread_create_detached_stack(a, b, c, d, \
00433 AST_BACKGROUND_STACKSIZE, \
00434 __FILE__, __FUNCTION__, __LINE__, #c)
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with);
00445
00446 long int ast_random(void);
00447
00448
00449 #ifndef __AST_DEBUG_MALLOC
00450 #define ast_std_malloc malloc
00451 #define ast_std_calloc calloc
00452 #define ast_std_realloc realloc
00453 #define ast_std_free free
00454
00455
00456
00457
00458
00459
00460
00461 #define ast_free free
00462 #define ast_free_ptr ast_free
00463
00464 #define MALLOC_FAILURE_MSG \
00465 ast_log(LOG_ERROR, "Memory Allocation Failure in function %s at line %d of %s\n", func, lineno, file);
00466
00467
00468
00469
00470
00471
00472
00473
00474 #define ast_malloc(len) \
00475 _ast_malloc((len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00476
00477 AST_INLINE_API(
00478 void * attribute_malloc _ast_malloc(size_t len, const char *file, int lineno, const char *func),
00479 {
00480 void *p;
00481
00482 if (!(p = malloc(len)))
00483 MALLOC_FAILURE_MSG;
00484
00485 return p;
00486 }
00487 )
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497 #define ast_calloc(num, len) \
00498 _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00499
00500 AST_INLINE_API(
00501 void * attribute_malloc _ast_calloc(size_t num, size_t len, const char *file, int lineno, const char *func),
00502 {
00503 void *p;
00504
00505 if (!(p = calloc(num, len)))
00506 MALLOC_FAILURE_MSG;
00507
00508 return p;
00509 }
00510 )
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522 #define ast_calloc_cache(num, len) \
00523 _ast_calloc((num), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533 #define ast_realloc(p, len) \
00534 _ast_realloc((p), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00535
00536 AST_INLINE_API(
00537 void * attribute_malloc _ast_realloc(void *p, size_t len, const char *file, int lineno, const char *func),
00538 {
00539 void *newp;
00540
00541 if (!(newp = realloc(p, len)))
00542 MALLOC_FAILURE_MSG;
00543
00544 return newp;
00545 }
00546 )
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560 #define ast_strdup(str) \
00561 _ast_strdup((str), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00562
00563 AST_INLINE_API(
00564 char * attribute_malloc _ast_strdup(const char *str, const char *file, int lineno, const char *func),
00565 {
00566 char *newstr = NULL;
00567
00568 if (str) {
00569 if (!(newstr = strdup(str)))
00570 MALLOC_FAILURE_MSG;
00571 }
00572
00573 return newstr;
00574 }
00575 )
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589 #define ast_strndup(str, len) \
00590 _ast_strndup((str), (len), __FILE__, __LINE__, __PRETTY_FUNCTION__)
00591
00592 AST_INLINE_API(
00593 char * attribute_malloc _ast_strndup(const char *str, size_t len, const char *file, int lineno, const char *func),
00594 {
00595 char *newstr = NULL;
00596
00597 if (str) {
00598 if (!(newstr = strndup(str, len)))
00599 MALLOC_FAILURE_MSG;
00600 }
00601
00602 return newstr;
00603 }
00604 )
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614 #define ast_asprintf(ret, fmt, ...) \
00615 _ast_asprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, __VA_ARGS__)
00616
00617 int __attribute__((format(printf, 5, 6)))
00618 _ast_asprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, ...);
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628 #define ast_vasprintf(ret, fmt, ap) \
00629 _ast_vasprintf((ret), __FILE__, __LINE__, __PRETTY_FUNCTION__, (fmt), (ap))
00630
00631 AST_INLINE_API(
00632 __attribute__((format(printf, 5, 0)))
00633 int _ast_vasprintf(char **ret, const char *file, int lineno, const char *func, const char *fmt, va_list ap),
00634 {
00635 int res;
00636
00637 if ((res = vasprintf(ret, fmt, ap)) == -1)
00638 MALLOC_FAILURE_MSG;
00639
00640 return res;
00641 }
00642 )
00643
00644 #endif
00645
00646
00647
00648
00649
00650
00651
00652
00653 #define ast_alloca(size) __builtin_alloca(size)
00654
00655 #if !defined(ast_strdupa) && defined(__GNUC__)
00656
00657
00658
00659
00660
00661
00662
00663 #define ast_strdupa(s) \
00664 (__extension__ \
00665 ({ \
00666 const char *__old = (s); \
00667 size_t __len = strlen(__old) + 1; \
00668 char *__new = __builtin_alloca(__len); \
00669 memcpy (__new, __old, __len); \
00670 __new; \
00671 }))
00672 #endif
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687 void ast_enable_packet_fragmentation(int sock);
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697 int ast_mkdir(const char *path, int mode);
00698
00699 #define ARRAY_LEN(a) (size_t) (sizeof(a) / sizeof(0[a]))
00700
00701
00702
00703 struct ast_http_digest {
00704 AST_DECLARE_STRING_FIELDS(
00705 AST_STRING_FIELD(username);
00706 AST_STRING_FIELD(nonce);
00707 AST_STRING_FIELD(uri);
00708 AST_STRING_FIELD(realm);
00709 AST_STRING_FIELD(domain);
00710 AST_STRING_FIELD(response);
00711 AST_STRING_FIELD(cnonce);
00712 AST_STRING_FIELD(opaque);
00713 AST_STRING_FIELD(nc);
00714 );
00715 int qop;
00716 };
00717
00718
00719
00720
00721
00722
00723
00724
00725 int ast_parse_digest(const char *digest, struct ast_http_digest *d, int request, int pedantic);
00726
00727
00728 #ifdef AST_DEVMODE
00729 void __ast_assert_failed(int condition, const char *condition_str, const char *file, int line, const char *function);
00730 #define ast_assert(a) _ast_assert(a, # a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
00731 static void force_inline _ast_assert(int condition, const char *condition_str, const char *file, int line, const char *function)
00732 {
00733 if (__builtin_expect(!condition, 1)) {
00734 __ast_assert_failed(condition, condition_str, file, line, function);
00735 }
00736 }
00737 #else
00738 #define ast_assert(a)
00739 #endif
00740
00741
00742
00743
00744
00745
00746
00747
00748 void ast_do_crash(void);
00749
00750 #include "asterisk/strings.h"
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760 #define ast_alignof(type) __alignof__(type)
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780 #define ast_align_for(offset, type) (((offset + __alignof__(type) - 1) / __alignof__(type)) * __alignof__(type))
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803 #define ast_make_room_for(offset, type) (((offset + (2 * __alignof__(type) - 1)) / __alignof__(type)) * __alignof__(type))
00804
00805
00806
00807
00808 struct ast_eid {
00809 unsigned char eid[6];
00810 } __attribute__((__packed__));
00811
00812
00813
00814
00815
00816
00817
00818 extern struct ast_eid ast_eid_default;
00819
00820
00821
00822
00823
00824 void ast_set_default_eid(struct ast_eid *eid);
00825
00826
00827
00828
00829
00830 char *ast_eid_to_str(char *s, int maxlen, struct ast_eid *eid);
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841 int ast_str_to_eid(struct ast_eid *eid, const char *s);
00842
00843
00844
00845
00846
00847
00848
00849 int ast_eid_cmp(const struct ast_eid *eid1, const struct ast_eid *eid2);
00850
00851
00852
00853
00854
00855
00856
00857
00858 int ast_get_tid(void);
00859
00860
00861
00862
00863
00864
00865
00866
00867 char *ast_utils_which(const char *binary, char *fullpath, size_t fullpath_size);
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915 #define RAII_VAR(vartype, varname, initval, dtor) \
00916 \
00917 auto void _dtor_ ## varname (vartype * v); \
00918 void _dtor_ ## varname (vartype * v) { dtor(*v); } \
00919 vartype varname __attribute__((cleanup(_dtor_ ## varname))) = (initval)
00920
00921 #endif