ad96df249889ef9f4047e2738767ef67cf938d91
[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 #include "asterisk/vector.h"
44
45 /*!
46  * core handler for dynamic strings.
47  * This is not meant to be called directly, but rather through the
48  * various wrapper macros
49  *      ast_str_set(...)
50  *      ast_str_append(...)
51  *      ast_str_set_va(...)
52  *      ast_str_append_va(...)
53  */
54
55 #ifdef __AST_DEBUG_MALLOC
56 int __ast_debug_str_helper(struct ast_str **buf, ssize_t max_len,
57         int append, const char *fmt, va_list ap, const char *file, int lineno, const char *function)
58 #else
59 int __ast_str_helper(struct ast_str **buf, ssize_t max_len,
60         int append, const char *fmt, va_list ap)
61 #endif
62 {
63         int res;
64         int added;
65         int need;
66         int offset = (append && (*buf)->__AST_STR_LEN) ? (*buf)->__AST_STR_USED : 0;
67         va_list aq;
68
69         if (max_len < 0) {
70                 max_len = (*buf)->__AST_STR_LEN;        /* don't exceed the allocated space */
71         }
72
73         do {
74                 va_copy(aq, ap);
75                 res = vsnprintf((*buf)->__AST_STR_STR + offset, (*buf)->__AST_STR_LEN - offset, fmt, aq);
76                 va_end(aq);
77
78                 if (res < 0) {
79                         /*
80                          * vsnprintf write to string failed.
81                          * I don't think this is possible with a memory buffer.
82                          */
83                         res = AST_DYNSTR_BUILD_FAILED;
84                         added = 0;
85                         break;
86                 }
87
88                 /*
89                  * vsnprintf returns how much space we used or would need.
90                  * Remember that vsnprintf does not count the nil terminator
91                  * so we must add 1.
92                  */
93                 added = res;
94                 need = offset + added + 1;
95                 if (need <= (*buf)->__AST_STR_LEN
96                         || (max_len && max_len <= (*buf)->__AST_STR_LEN)) {
97                         /*
98                          * There was enough room for the string or we are not
99                          * allowed to try growing the string buffer.
100                          */
101                         break;
102                 }
103
104                 /* Reallocate the buffer and try again. */
105                 if (max_len == 0) {
106                         /* unbounded, give more room for next time */
107                         need += 16 + need / 4;
108                 } else if (max_len < need) {
109                         /* truncate as needed */
110                         need = max_len;
111                 }
112
113                 if (
114 #ifdef __AST_DEBUG_MALLOC
115                         _ast_str_make_space(buf, need, file, lineno, function)
116 #else
117                         ast_str_make_space(buf, need)
118 #endif
119                         ) {
120                         ast_log_safe(LOG_VERBOSE, "failed to extend from %d to %d\n",
121                                 (int) (*buf)->__AST_STR_LEN, need);
122
123                         res = AST_DYNSTR_BUILD_FAILED;
124                         break;
125                 }
126         } while (1);
127
128         /* Update space used, keep in mind truncation may be necessary. */
129         (*buf)->__AST_STR_USED = ((*buf)->__AST_STR_LEN <= offset + added)
130                 ? (*buf)->__AST_STR_LEN - 1
131                 : offset + added;
132
133         /* Ensure that the string is terminated. */
134         (*buf)->__AST_STR_STR[(*buf)->__AST_STR_USED] = '\0';
135
136         return res;
137 }
138
139 char *__ast_str_helper2(struct ast_str **buf, ssize_t maxlen, const char *src, size_t maxsrc, int append, int escapecommas)
140 {
141         int dynamic = 0;
142         char *ptr = append ? &((*buf)->__AST_STR_STR[(*buf)->__AST_STR_USED]) : (*buf)->__AST_STR_STR;
143
144         if (maxlen < 1) {
145                 if (maxlen == 0) {
146                         dynamic = 1;
147                 }
148                 maxlen = (*buf)->__AST_STR_LEN;
149         }
150
151         while (*src && maxsrc && maxlen && (!escapecommas || (maxlen - 1))) {
152                 if (escapecommas && (*src == '\\' || *src == ',')) {
153                         *ptr++ = '\\';
154                         maxlen--;
155                         (*buf)->__AST_STR_USED++;
156                 }
157                 *ptr++ = *src++;
158                 maxsrc--;
159                 maxlen--;
160                 (*buf)->__AST_STR_USED++;
161
162                 if ((ptr >= (*buf)->__AST_STR_STR + (*buf)->__AST_STR_LEN - 3) ||
163                         (dynamic && (!maxlen || (escapecommas && !(maxlen - 1))))) {
164                         char *oldbase = (*buf)->__AST_STR_STR;
165                         size_t old = (*buf)->__AST_STR_LEN;
166                         if (ast_str_make_space(buf, (*buf)->__AST_STR_LEN * 2)) {
167                                 /* If the buffer can't be extended, end it. */
168                                 break;
169                         }
170                         /* What we extended the buffer by */
171                         maxlen = old;
172
173                         ptr += (*buf)->__AST_STR_STR - oldbase;
174                 }
175         }
176         if (__builtin_expect(!maxlen, 0)) {
177                 ptr--;
178         }
179         *ptr = '\0';
180         return (*buf)->__AST_STR_STR;
181 }
182
183 static int str_hash(const void *obj, const int flags)
184 {
185         return ast_str_hash(obj);
186 }
187
188 static int str_sort(const void *lhs, const void *rhs, int flags)
189 {
190         if ((flags & OBJ_SEARCH_MASK) == OBJ_SEARCH_PARTIAL_KEY) {
191                 return strncmp(lhs, rhs, strlen(rhs));
192         } else {
193                 return strcmp(lhs, rhs);
194         }
195 }
196
197 static int str_cmp(void *lhs, void *rhs, int flags)
198 {
199         int cmp = 0;
200
201         if ((flags & OBJ_SEARCH_MASK) == OBJ_SEARCH_PARTIAL_KEY) {
202                 cmp = strncmp(lhs, rhs, strlen(rhs));
203         } else {
204                 cmp = strcmp(lhs, rhs);
205         }
206
207         return cmp ? 0 : CMP_MATCH;
208 }
209
210 //struct ao2_container *ast_str_container_alloc_options(enum ao2_container_opts opts, int buckets)
211 struct ao2_container *ast_str_container_alloc_options(enum ao2_alloc_opts opts, int buckets)
212 {
213         return ao2_container_alloc_hash(opts, 0, buckets, str_hash, str_sort, str_cmp);
214 }
215
216 int ast_str_container_add(struct ao2_container *str_container, const char *add)
217 {
218         char *ao2_add;
219
220         /* The ao2_add object is immutable so it doesn't need a lock of its own. */
221         ao2_add = ao2_alloc_options(strlen(add) + 1, NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
222         if (!ao2_add) {
223                 return -1;
224         }
225         strcpy(ao2_add, add);/* Safe */
226
227         ao2_link(str_container, ao2_add);
228         ao2_ref(ao2_add, -1);
229         return 0;
230 }
231
232 void ast_str_container_remove(struct ao2_container *str_container, const char *remove)
233 {
234         ao2_find(str_container, remove, OBJ_SEARCH_KEY | OBJ_NODATA | OBJ_UNLINK);
235 }
236
237 char *ast_generate_random_string(char *buf, size_t size)
238 {
239         int i;
240
241         for (i = 0; i < size - 1; ++i) {
242                 buf[i] = 'a' + (ast_random() % 26);
243         }
244         buf[i] = '\0';
245
246         return buf;
247 }
248
249 int ast_strings_match(const char *left, const char *op, const char *right)
250 {
251         char *internal_op = (char *)op;
252         char *internal_right = (char *)right;
253         double left_num;
254         double right_num;
255         int scan_numeric = 0;
256
257         if (!(left && right)) {
258                 return 0;
259         }
260
261         if (ast_strlen_zero(op)) {
262                 if (ast_strlen_zero(left) && ast_strlen_zero(right)) {
263                         return 1;
264                 }
265
266                 if (strlen(right) >= 2 && right[0] == '/' && right[strlen(right) - 1] == '/') {
267                         internal_op = "regex";
268                         internal_right = ast_strdupa(right);
269                         /* strip the leading and trailing '/' */
270                         internal_right++;
271                         internal_right[strlen(internal_right) - 1] = '\0';
272                         goto regex;
273                 } else {
274                         internal_op = "=";
275                         goto equals;
276                 }
277         }
278
279         if (!strcasecmp(op, "like")) {
280                 char *tok;
281                 struct ast_str *buffer = ast_str_alloca(128);
282
283                 if (!strchr(right, '%')) {
284                         return !strcmp(left, right);
285                 } else {
286                         internal_op = "regex";
287                         internal_right = ast_strdupa(right);
288                         tok = strsep(&internal_right, "%");
289                         ast_str_set(&buffer, 0, "^%s", tok);
290
291                         while ((tok = strsep(&internal_right, "%"))) {
292                                 ast_str_append(&buffer, 0, ".*%s", tok);
293                         }
294                         ast_str_append(&buffer, 0, "%s", "$");
295
296                         internal_right = ast_str_buffer(buffer);
297                         /* fall through to regex */
298                 }
299         }
300
301 regex:
302         if (!strcasecmp(internal_op, "regex")) {
303                 regex_t expression;
304                 int rc;
305
306                 if (regcomp(&expression, internal_right, REG_EXTENDED | REG_NOSUB)) {
307                         return 0;
308                 }
309
310                 rc = regexec(&expression, left, 0, NULL, 0);
311                 regfree(&expression);
312                 return !rc;
313         }
314
315 equals:
316         scan_numeric = (sscanf(left, "%lf", &left_num) > 0 && sscanf(internal_right, "%lf", &right_num) > 0);
317
318         if (internal_op[0] == '=') {
319                 if (ast_strlen_zero(left) && ast_strlen_zero(internal_right)) {
320                         return 1;
321                 }
322
323                 if (scan_numeric) {
324                         return (left_num == right_num);
325                 } else {
326                         return (!strcmp(left, internal_right));
327                 }
328         }
329
330         if (internal_op[0] == '!' && internal_op[1] == '=') {
331                 if (scan_numeric) {
332                         return (left_num != right_num);
333                 } else {
334                         return !!strcmp(left, internal_right);
335                 }
336         }
337
338         if (internal_op[0] == '<') {
339                 if (scan_numeric) {
340                         if (internal_op[1] == '=') {
341                                 return (left_num <= right_num);
342                         } else {
343                                 return (left_num < right_num);
344                         }
345                 } else {
346                         if (internal_op[1] == '=') {
347                                 return strcmp(left, internal_right) <= 0;
348                         } else {
349                                 return strcmp(left, internal_right) < 0;
350                         }
351                 }
352         }
353
354         if (internal_op[0] == '>') {
355                 if (scan_numeric) {
356                         if (internal_op[1] == '=') {
357                                 return (left_num >= right_num);
358                         } else {
359                                 return (left_num > right_num);
360                         }
361                 } else {
362                         if (internal_op[1] == '=') {
363                                 return strcmp(left, internal_right) >= 0;
364                         } else {
365                                 return strcmp(left, internal_right) > 0;
366                         }
367                 }
368         }
369
370         return 0;
371 }
372
373 char *ast_read_line_from_buffer(char **buffer)
374 {
375         char *start = *buffer;
376
377         if (!buffer || !*buffer || *(*buffer) == '\0') {
378                 return NULL;
379         }
380
381         while (*(*buffer) && *(*buffer) != '\n' ) {
382                 (*buffer)++;
383         }
384
385         *(*buffer) = '\0';
386         if (*(*buffer - 1) == '\r') {
387                 *(*buffer - 1) = '\0';
388         }
389         (*buffer)++;
390
391         return start;
392 }
393
394 int ast_vector_string_split(struct ast_vector_string *dest,
395         const char *input, const char *delim, int flags,
396         int (*excludes_cmp)(const char *s1, const char *s2))
397 {
398         char *buf;
399         char *cur;
400         int no_trim = flags & AST_VECTOR_STRING_SPLIT_NO_TRIM;
401         int allow_empty = flags & AST_VECTOR_STRING_SPLIT_ALLOW_EMPTY;
402
403         ast_assert(dest != NULL);
404         ast_assert(!ast_strlen_zero(delim));
405
406         if (ast_strlen_zero(input)) {
407                 return 0;
408         }
409
410         buf = ast_strdupa(input);
411         while ((cur = strsep(&buf, delim))) {
412                 if (!no_trim) {
413                         cur = ast_strip(cur);
414                 }
415
416                 if (!allow_empty && ast_strlen_zero(cur)) {
417                         continue;
418                 }
419
420                 if (excludes_cmp && AST_VECTOR_GET_CMP(dest, cur, !excludes_cmp)) {
421                         continue;
422                 }
423
424                 cur = ast_strdup(cur);
425                 if (!cur || AST_VECTOR_APPEND(dest, cur)) {
426                         ast_free(cur);
427
428                         return -1;
429                 }
430         }
431
432         return 0;
433 }