Make crypto loading optional
[asterisk/asterisk.git] / include / asterisk / utils.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, 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 /*
20  * Utility functions
21  */
22
23 #ifndef _ASTERISK_UTILS_H
24 #define _ASTERISK_UTILS_H
25
26 #include "asterisk/compat.h"
27
28 #include <netinet/in.h>
29 #include <arpa/inet.h>  /* we want to override inet_ntoa */
30 #include <netdb.h>
31 #include <limits.h>
32
33 #include "asterisk/lock.h"
34 #include "asterisk/time.h"
35 #include "asterisk/strings.h"
36
37 /* Note:
38    It is very important to use only unsigned variables to hold
39    bit flags, as otherwise you can fall prey to the compiler's
40    sign-extension antics if you try to use the top two bits in
41    your variable.
42
43    The flag macros below use a set of compiler tricks to verify
44    that the caller is using an "unsigned int" variable to hold
45    the flags, and nothing else. If the caller uses any other
46    type of variable, a warning message similar to this:
47
48    warning: comparison of distinct pointer types lacks cast
49
50    will be generated.
51
52    The "dummy" variable below is used to make these comparisons.
53
54    Also note that at -O2 or above, this type-safety checking
55    does _not_ produce any additional object code at all.
56 */
57
58 extern unsigned int __unsigned_int_flags_dummy;
59
60 #define ast_test_flag(p,flag)           ({ \
61                                         typeof ((p)->flags) __p = (p)->flags; \
62                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
63                                         (void) (&__p == &__x); \
64                                         ((p)->flags & (flag)); \
65                                         })
66
67 #define ast_set_flag(p,flag)            do { \
68                                         typeof ((p)->flags) __p = (p)->flags; \
69                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
70                                         (void) (&__p == &__x); \
71                                         ((p)->flags |= (flag)); \
72                                         } while(0)
73
74 #define ast_clear_flag(p,flag)          do { \
75                                         typeof ((p)->flags) __p = (p)->flags; \
76                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
77                                         (void) (&__p == &__x); \
78                                         ((p)->flags &= ~(flag)); \
79                                         } while(0)
80
81 #define ast_copy_flags(dest,src,flagz)  do { \
82                                         typeof ((dest)->flags) __d = (dest)->flags; \
83                                         typeof ((src)->flags) __s = (src)->flags; \
84                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
85                                         (void) (&__d == &__x); \
86                                         (void) (&__s == &__x); \
87                                         (dest)->flags &= ~(flagz); \
88                                         (dest)->flags |= ((src)->flags & (flagz)); \
89                                         } while (0)
90
91 #define ast_set2_flag(p,value,flag)     do { \
92                                         typeof ((p)->flags) __p = (p)->flags; \
93                                         typeof (__unsigned_int_flags_dummy) __x = 0; \
94                                         (void) (&__p == &__x); \
95                                         if (value) \
96                                                 (p)->flags |= (flag); \
97                                         else \
98                                                 (p)->flags &= ~(flag); \
99                                         } while (0)
100
101 /* Non-type checking variations for non-unsigned int flags.  You
102    should only use non-unsigned int flags where required by 
103    protocol etc and if you know what you're doing :)  */
104 #define ast_test_flag_nonstd(p,flag)            ({ \
105                                         ((p)->flags & (flag)); \
106                                         })
107
108 #define ast_set_flag_nonstd(p,flag)             do { \
109                                         ((p)->flags |= (flag)); \
110                                         } while(0)
111
112 #define ast_clear_flag_nonstd(p,flag)           do { \
113                                         ((p)->flags &= ~(flag)); \
114                                         } while(0)
115
116 #define ast_copy_flags_nonstd(dest,src,flagz)   do { \
117                                         (dest)->flags &= ~(flagz); \
118                                         (dest)->flags |= ((src)->flags & (flagz)); \
119                                         } while (0)
120
121 #define ast_set2_flag_nonstd(p,value,flag)      do { \
122                                         if (value) \
123                                                 (p)->flags |= (flag); \
124                                         else \
125                                                 (p)->flags &= ~(flag); \
126                                         } while (0)
127
128 #define AST_FLAGS_ALL UINT_MAX
129
130 struct ast_flags {
131         unsigned int flags;
132 };
133
134 struct ast_hostent {
135         struct hostent hp;
136         char buf[1024];
137 };
138
139 extern struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp);
140
141 /* ast_md5_hash 
142         \brief Produces MD5 hash based on input string */
143 extern void ast_md5_hash(char *output, char *input);
144
145 extern int ast_base64encode(char *dst, unsigned char *src, int srclen, int max);
146 extern int ast_base64decode(unsigned char *dst, char *src, int max);
147
148 /*! ast_uri_encode
149         \brief Turn text string to URI-encoded %XX version 
150         At this point, we're converting from ISO-8859-x (8-bit), not UTF8
151         as in the SIP protocol spec 
152         If doreserved == 1 we will convert reserved characters also.
153         RFC 2396, section 2.4
154         outbuf needs to have more memory allocated than the instring
155         to have room for the expansion. Every char that is converted
156         is replaced by three ASCII characters.
157         \param string   String to be converted
158         \param outbuf   Resulting encoded string
159         \param buflen   Size of output buffer
160         \param doreserved       Convert reserved characters
161 */
162
163 char *ast_uri_encode(char *string, char *outbuf, int buflen, int doreserved);
164
165 /*!     \brief Decode URI, URN, URL (overwrite string)
166         \param s        String to be decoded 
167  */
168 void ast_uri_decode(char *s);
169         
170
171 extern int test_for_thread_safety(void);
172
173 extern const char *ast_inet_ntoa(char *buf, int bufsiz, struct in_addr ia);
174
175 #ifdef inet_ntoa
176 #undef inet_ntoa
177 #endif
178 #define inet_ntoa __dont__use__inet_ntoa__use__ast_inet_ntoa__instead__
179
180 extern int ast_utils_init(void);
181 extern int ast_wait_for_input(int fd, int ms);
182
183 /*! Compares the source address and port of two sockaddr_in */
184 static inline int inaddrcmp(const struct sockaddr_in *sin1, const struct sockaddr_in *sin2)
185 {
186         return ((sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) 
187                 || (sin1->sin_port != sin2->sin_port));
188 }
189
190 #define AST_STACKSIZE 256 * 1024
191 #define ast_pthread_create(a,b,c,d) ast_pthread_create_stack(a,b,c,d,0)
192 extern int ast_pthread_create_stack(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *data, size_t stacksize);
193
194 /*!
195         \brief Process a string to find and replace characters
196         \param start The string to analyze
197         \param find The character to find
198         \param replace_with The character that will replace the one we are looking for
199 */
200 char *ast_process_quotes_and_slashes(char *start, char find, char replace_with);
201
202 #endif /* _ASTERISK_UTILS_H */