Asterisk - The Open Source Telephony Project  GIT-master-1b41629
strings.c
Go to the documentation of this file.
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  */
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 
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)
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 }
int ast_strings_match(const char *left, const char *op, const char *right)
Compares 2 strings using realtime-style operators.
Definition: strings.c:248
int ast_vector_string_split(struct ast_vector_string *dest, const char *input, const char *delim, int flags, int(*excludes_cmp)(const char *s1, const char *s2))
Append a string vector by splitting a string.
Definition: strings.c:393
Asterisk main include file. File version handling, generic pbx functions.
String manipulation functions.
The arg parameter is a search key, but is not an object.
Definition: astobj2.h:1105
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
#define ast_str_make_space(buf, new_len)
Definition: strings.h:780
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition: strings.h:714
int ast_str_container_add(struct ao2_container *str_container, const char *add)
Adds a string to a string container allocated by ast_str_container_alloc.
Definition: strings.c:206
#define AST_VECTOR_APPEND(vec, elem)
Append an element to a vector, growing the vector if needed.
Definition: vector.h:256
if(!yyg->yy_init)
Definition: ast_expr2f.c:868
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition: strings.h:1091
#define ao2_alloc_options(data_size, destructor_fn, options)
Definition: astobj2.h:406
#define ast_assert(a)
Definition: utils.h:710
#define ast_str_alloca(init_len)
Definition: strings.h:800
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:243
#define NULL
Definition: resample.c:96
struct ao2_container * ast_str_container_alloc_options(enum ao2_alloc_opts opts, int buckets)
Allocates a hash container for bare strings.
Definition: strings.c:201
static int input(yyscan_t yyscanner)
Definition: ast_expr2f.c:1584
int ast_str_set(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Set a dynamic string using variable arguments.
Definition: strings.h:1065
The arg parameter is a partial search key similar to OBJ_SEARCH_KEY.
Definition: astobj2.h:1120
char * ast_strip(char *s)
Strip leading/trailing whitespace from a string.
Definition: strings.h:219
#define ao2_ref(o, delta)
Definition: astobj2.h:464
void ast_str_container_remove(struct ao2_container *str_container, const char *remove)
Removes a string from a string container allocated by ast_str_container_alloc.
Definition: strings.c:222
long int ast_random(void)
Definition: main/utils.c:2064
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:300
static int str_cmp(void *lhs, void *rhs, int flags)
Definition: strings.c:187
Core PBX routines and definitions.
static int str_sort(const void *lhs, const void *rhs, int flags)
Definition: strings.c:178
void ast_log_safe(int level, const char *file, int line, const char *function, const char *fmt,...)
Used for sending a log message with protection against recursion.
Definition: logger.c:2110
ao2_alloc_opts
Options available when allocating an ao2 object.
Definition: astobj2.h:363
#define ao2_container_alloc_hash(ao2_options, container_options, n_buckets, hash_fn, sort_fn, cmp_fn)
Definition: astobj2.h:1310
The descriptor of a dynamic string XXX storage will be optimized later if needed We use the ts field ...
Definition: strings.h:584
int _ast_str_make_space(struct ast_str **buf, size_t new_len, const char *file, int lineno, const char *function)
Definition: strings.h:779
#define ast_strlen_zero(a)
Definition: muted.c:73
#define ast_free(a)
Definition: astmm.h:182
static int regex(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
Definition: func_strings.c:948
Vector container support.
#define ao2_find(container, arg, flags)
Definition: astobj2.h:1756
#define AST_VECTOR_GET_CMP(vec, value, cmp)
Get an element from a vector that matches the given comparison.
Definition: vector.h:733
char * ast_generate_random_string(char *buf, size_t size)
Create a pseudo-random string of a fixed length.
Definition: strings.c:227
char * ast_read_line_from_buffer(char **buffer)
Read lines from a string buffer.
Definition: strings.c:372
int ast_strings_equal(const char *str1, const char *str2)
Compare strings for equality checking for NULL.
Definition: strings.c:239
char * strsep(char **str, const char *delims)
size_t __AST_STR_LEN
Definition: strings.h:585
int __ast_str_helper(struct ast_str **buf, ssize_t max_len, int append, const char *fmt, va_list ap, const char *file, int lineno, const char *function)
Core functionality of ast_str_(set|append)_va.
Definition: strings.c:55
#define LOG_VERBOSE
Definition: logger.h:296
Generic container type.
Search option field mask.
Definition: astobj2.h:1076
char * __ast_str_helper2(struct ast_str **buf, ssize_t maxlen, const char *src, size_t maxsrc, int append, int escapecommas)
Definition: strings.c:129
static int str_hash(const void *obj, const int flags)
Definition: strings.c:173
static force_inline int attribute_pure ast_str_hash(const char *str)
Compute a hash value on a string.
Definition: strings.h:1206
#define ao2_link(container, obj)
Definition: astobj2.h:1549