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