Remove ASTERISK_REGISTER_FILE.
[asterisk/asterisk.git] / main / strings.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2008, Digium, Inc.
5  *
6  * Tilghman Lesher <tlesher@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  *
21  * \brief String manipulation API
22  *
23  * \author Tilghman Lesher <tilghman@digium.com>
24  */
25
26 /*** MAKEOPTS
27 <category name="MENUSELECT_CFLAGS" displayname="Compiler Flags" positive_output="yes">
28         <member name="DEBUG_OPAQUE" displayname="Change ast_str internals to detect improper usage" touch_on_change="include/asterisk/strings.h">
29                 <defaultenabled>yes</defaultenabled>
30         </member>
31 </category>
32  ***/
33
34 /*** MODULEINFO
35         <support_level>core</support_level>
36  ***/
37
38 #include "asterisk.h"
39
40 #include <regex.h>
41 #include "asterisk/strings.h"
42 #include "asterisk/pbx.h"
43
44 /*!
45  * core handler for dynamic strings.
46  * This is not meant to be called directly, but rather through the
47  * various wrapper macros
48  *      ast_str_set(...)
49  *      ast_str_append(...)
50  *      ast_str_set_va(...)
51  *      ast_str_append_va(...)
52  */
53
54 #ifdef __AST_DEBUG_MALLOC
55 int __ast_debug_str_helper(struct ast_str **buf, ssize_t max_len,
56         int append, const char *fmt, va_list ap, const char *file, int lineno, const char *function)
57 #else
58 int __ast_str_helper(struct ast_str **buf, ssize_t max_len,
59         int append, const char *fmt, va_list ap)
60 #endif
61 {
62         int res;
63         int added;
64         int need;
65         int offset = (append && (*buf)->__AST_STR_LEN) ? (*buf)->__AST_STR_USED : 0;
66         va_list aq;
67
68         if (max_len < 0) {
69                 max_len = (*buf)->__AST_STR_LEN;        /* don't exceed the allocated space */
70         }
71
72         do {
73                 va_copy(aq, ap);
74                 res = vsnprintf((*buf)->__AST_STR_STR + offset, (*buf)->__AST_STR_LEN - offset, fmt, aq);
75                 va_end(aq);
76
77                 if (res < 0) {
78                         /*
79                          * vsnprintf write to string failed.
80                          * I don't think this is possible with a memory buffer.
81                          */
82                         res = AST_DYNSTR_BUILD_FAILED;
83                         added = 0;
84                         break;
85                 }
86
87                 /*
88                  * vsnprintf returns how much space we used or would need.
89                  * Remember that vsnprintf does not count the nil terminator
90                  * so we must add 1.
91                  */
92                 added = res;
93                 need = offset + added + 1;
94                 if (need <= (*buf)->__AST_STR_LEN
95                         || (max_len && max_len <= (*buf)->__AST_STR_LEN)) {
96                         /*
97                          * There was enough room for the string or we are not
98                          * allowed to try growing the string buffer.
99                          */
100                         break;
101                 }
102
103                 /* Reallocate the buffer and try again. */
104                 if (max_len == 0) {
105                         /* unbounded, give more room for next time */
106                         need += 16 + need / 4;
107                 } else if (max_len < need) {
108                         /* truncate as needed */
109                         need = max_len;
110                 }
111
112                 if (
113 #ifdef __AST_DEBUG_MALLOC
114                         _ast_str_make_space(buf, need, file, lineno, function)
115 #else
116                         ast_str_make_space(buf, need)
117 #endif
118                         ) {
119                         ast_log_safe(LOG_VERBOSE, "failed to extend from %d to %d\n",
120                                 (int) (*buf)->__AST_STR_LEN, need);
121
122                         res = AST_DYNSTR_BUILD_FAILED;
123                         break;
124                 }
125         } while (1);
126
127         /* Update space used, keep in mind truncation may be necessary. */
128         (*buf)->__AST_STR_USED = ((*buf)->__AST_STR_LEN <= offset + added)
129                 ? (*buf)->__AST_STR_LEN - 1
130                 : offset + added;
131
132         /* Ensure that the string is terminated. */
133         (*buf)->__AST_STR_STR[(*buf)->__AST_STR_USED] = '\0';
134
135         return res;
136 }
137
138 char *__ast_str_helper2(struct ast_str **buf, ssize_t maxlen, const char *src, size_t maxsrc, int append, int escapecommas)
139 {
140         int dynamic = 0;
141         char *ptr = append ? &((*buf)->__AST_STR_STR[(*buf)->__AST_STR_USED]) : (*buf)->__AST_STR_STR;
142
143         if (maxlen < 1) {
144                 if (maxlen == 0) {
145                         dynamic = 1;
146                 }
147                 maxlen = (*buf)->__AST_STR_LEN;
148         }
149
150         while (*src && maxsrc && maxlen && (!escapecommas || (maxlen - 1))) {
151                 if (escapecommas && (*src == '\\' || *src == ',')) {
152                         *ptr++ = '\\';
153                         maxlen--;
154                         (*buf)->__AST_STR_USED++;
155                 }
156                 *ptr++ = *src++;
157                 maxsrc--;
158                 maxlen--;
159                 (*buf)->__AST_STR_USED++;
160
161                 if ((ptr >= (*buf)->__AST_STR_STR + (*buf)->__AST_STR_LEN - 3) ||
162                         (dynamic && (!maxlen || (escapecommas && !(maxlen - 1))))) {
163                         char *oldbase = (*buf)->__AST_STR_STR;
164                         size_t old = (*buf)->__AST_STR_LEN;
165                         if (ast_str_make_space(buf, (*buf)->__AST_STR_LEN * 2)) {
166                                 /* If the buffer can't be extended, end it. */
167                                 break;
168                         }
169                         /* What we extended the buffer by */
170                         maxlen = old;
171
172                         ptr += (*buf)->__AST_STR_STR - oldbase;
173                 }
174         }
175         if (__builtin_expect(!maxlen, 0)) {
176                 ptr--;
177         }
178         *ptr = '\0';
179         return (*buf)->__AST_STR_STR;
180 }
181
182 static int str_hash(const void *obj, const int flags)
183 {
184         return ast_str_hash(obj);
185 }
186
187 static int str_cmp(void *lhs, void *rhs, int flags)
188 {
189         return strcmp(lhs, rhs) ? 0 : CMP_MATCH;
190 }
191
192 //struct ao2_container *ast_str_container_alloc_options(enum ao2_container_opts opts, int buckets)
193 struct ao2_container *ast_str_container_alloc_options(enum ao2_alloc_opts opts, int buckets)
194 {
195         return ao2_container_alloc_options(opts, buckets, str_hash, str_cmp);
196 }
197
198 int ast_str_container_add(struct ao2_container *str_container, const char *add)
199 {
200         char *ao2_add;
201
202         /* The ao2_add object is immutable so it doesn't need a lock of its own. */
203         ao2_add = ao2_alloc_options(strlen(add) + 1, NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
204         if (!ao2_add) {
205                 return -1;
206         }
207         strcpy(ao2_add, add);/* Safe */
208
209         ao2_link(str_container, ao2_add);
210         ao2_ref(ao2_add, -1);
211         return 0;
212 }
213
214 void ast_str_container_remove(struct ao2_container *str_container, const char *remove)
215 {
216         ao2_find(str_container, remove, OBJ_SEARCH_KEY | OBJ_NODATA | OBJ_UNLINK);
217 }
218
219 char *ast_generate_random_string(char *buf, size_t size)
220 {
221         int i;
222
223         for (i = 0; i < size - 1; ++i) {
224                 buf[i] = 'a' + (ast_random() % 26);
225         }
226         buf[i] = '\0';
227
228         return buf;
229 }
230
231 int ast_strings_match(const char *left, const char *op, const char *right)
232 {
233         char *internal_op = (char *)op;
234         char *internal_right = (char *)right;
235         double left_num;
236         double right_num;
237         int scan_numeric = 0;
238
239         if (!(left && right)) {
240                 return 0;
241         }
242
243         if (ast_strlen_zero(op)) {
244                 if (ast_strlen_zero(left) && ast_strlen_zero(right)) {
245                         return 1;
246                 }
247
248                 if (strlen(right) >= 2 && right[0] == '/' && right[strlen(right) - 1] == '/') {
249                         internal_op = "regex";
250                         internal_right = ast_strdupa(right);
251                         /* strip the leading and trailing '/' */
252                         internal_right++;
253                         internal_right[strlen(internal_right) - 1] = '\0';
254                         goto regex;
255                 } else {
256                         internal_op = "=";
257                         goto equals;
258                 }
259         }
260
261         if (!strcasecmp(op, "like")) {
262                 char *tok;
263                 struct ast_str *buffer = ast_str_alloca(128);
264
265                 if (!strchr(right, '%')) {
266                         return !strcmp(left, right);
267                 } else {
268                         internal_op = "regex";
269                         internal_right = ast_strdupa(right);
270                         tok = strsep(&internal_right, "%");
271                         ast_str_set(&buffer, 0, "^%s", tok);
272
273                         while ((tok = strsep(&internal_right, "%"))) {
274                                 ast_str_append(&buffer, 0, ".*%s", tok);
275                         }
276                         ast_str_append(&buffer, 0, "%s", "$");
277
278                         internal_right = ast_str_buffer(buffer);
279                         /* fall through to regex */
280                 }
281         }
282
283 regex:
284         if (!strcasecmp(internal_op, "regex")) {
285                 regex_t expression;
286                 int rc;
287
288                 if (regcomp(&expression, internal_right, REG_EXTENDED | REG_NOSUB)) {
289                         return 0;
290                 }
291
292                 rc = regexec(&expression, left, 0, NULL, 0);
293                 regfree(&expression);
294                 return !rc;
295         }
296
297 equals:
298         scan_numeric = (sscanf(left, "%lf", &left_num) && sscanf(internal_right, "%lf", &right_num));
299
300         if (internal_op[0] == '=') {
301                 if (ast_strlen_zero(left) && ast_strlen_zero(internal_right)) {
302                         return 1;
303                 }
304
305                 if (scan_numeric) {
306                         return (left_num == right_num);
307                 } else {
308                         return (!strcmp(left, internal_right));
309                 }
310         }
311
312         if (internal_op[0] == '!' && internal_op[1] == '=') {
313                 if (scan_numeric) {
314                         return (left_num != right_num);
315                 } else {
316                         return !!strcmp(left, internal_right);
317                 }
318         }
319
320         if (internal_op[0] == '<') {
321                 if (scan_numeric) {
322                         if (internal_op[1] == '=') {
323                                 return (left_num <= right_num);
324                         } else {
325                                 return (left_num < right_num);
326                         }
327                 } else {
328                         if (internal_op[1] == '=') {
329                                 return strcmp(left, internal_right) <= 0;
330                         } else {
331                                 return strcmp(left, internal_right) < 0;
332                         }
333                 }
334         }
335
336         if (internal_op[0] == '>') {
337                 if (scan_numeric) {
338                         if (internal_op[1] == '=') {
339                                 return (left_num >= right_num);
340                         } else {
341                                 return (left_num > right_num);
342                         }
343                 } else {
344                         if (internal_op[1] == '=') {
345                                 return strcmp(left, internal_right) >= 0;
346                         } else {
347                                 return strcmp(left, internal_right) > 0;
348                         }
349                 }
350         }
351
352         return 0;
353 }
354
355