2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 2005
5 Copyright (C) Jelmer Vernooij 2005
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "util_strlist.h"
31 * @brief String list manipulation
35 build an empty (only NULL terminated) list of strings (for expansion with str_list_add() etc)
37 _PUBLIC_
char **str_list_make_empty(TALLOC_CTX
*mem_ctx
)
41 ret
= talloc_array(mem_ctx
, char *, 1);
52 place the only element 'entry' into a new, NULL terminated string list
54 _PUBLIC_
char **str_list_make_single(TALLOC_CTX
*mem_ctx
, const char *entry
)
58 ret
= talloc_array(mem_ctx
, char *, 2);
63 ret
[0] = talloc_strdup(ret
, entry
);
74 build a null terminated list of strings from a input string and a
75 separator list. The separator list must contain characters less than
76 or equal to 0x2f for this to work correctly on multi-byte strings
78 _PUBLIC_
char **str_list_make(TALLOC_CTX
*mem_ctx
, const char *string
, const char *sep
)
87 ret
= talloc_array(mem_ctx
, char *, 1);
92 while (string
&& *string
) {
93 size_t len
= strcspn(string
, sep
);
97 string
+= strspn(string
, sep
);
101 ret2
= talloc_realloc(mem_ctx
, ret
, char *,
109 ret
[num_elements
] = talloc_strndup(ret
, string
, len
);
110 if (ret
[num_elements
] == NULL
) {
119 ret
[num_elements
] = NULL
;
125 * build a null terminated list of strings from an argv-like input string
126 * Entries are separated by spaces and can be enclosed by quotes.
127 * Does NOT support escaping
129 _PUBLIC_
char **str_list_make_shell(TALLOC_CTX
*mem_ctx
, const char *string
, const char *sep
)
131 int num_elements
= 0;
134 ret
= talloc_array(mem_ctx
, char *, 1);
142 while (string
&& *string
) {
143 size_t len
= strcspn(string
, sep
);
148 string
+= strspn(string
, sep
);
152 if (*string
== '\"') {
154 len
= strcspn(string
, "\"");
155 element
= talloc_strndup(ret
, string
, len
);
158 element
= talloc_strndup(ret
, string
, len
);
162 if (element
== NULL
) {
167 ret2
= talloc_realloc(mem_ctx
, ret
, char *, num_elements
+2);
174 ret
[num_elements
] = element
;
179 ret
[num_elements
] = NULL
;
186 * join a list back to one string
188 _PUBLIC_
char *str_list_join(TALLOC_CTX
*mem_ctx
, const char **list
, char separator
)
194 return talloc_strdup(mem_ctx
, "");
196 ret
= talloc_strdup(mem_ctx
, list
[0]);
198 for (i
= 1; list
[i
]; i
++) {
199 ret
= talloc_asprintf_append_buffer(ret
, "%c%s", separator
, list
[i
]);
205 /** join a list back to one (shell-like) string; entries
206 * separated by spaces, using quotes where necessary */
207 _PUBLIC_
char *str_list_join_shell(TALLOC_CTX
*mem_ctx
, const char **list
, char sep
)
213 return talloc_strdup(mem_ctx
, "");
215 if (strchr(list
[0], ' ') || strlen(list
[0]) == 0)
216 ret
= talloc_asprintf(mem_ctx
, "\"%s\"", list
[0]);
218 ret
= talloc_strdup(mem_ctx
, list
[0]);
220 for (i
= 1; list
[i
]; i
++) {
221 if (strchr(list
[i
], ' ') || strlen(list
[i
]) == 0)
222 ret
= talloc_asprintf_append_buffer(ret
, "%c\"%s\"", sep
, list
[i
]);
224 ret
= talloc_asprintf_append_buffer(ret
, "%c%s", sep
, list
[i
]);
231 return the number of elements in a string list
233 _PUBLIC_
size_t str_list_length(const char * const *list
)
236 for (ret
=0;list
&& list
[ret
];ret
++) /* noop */ ;
244 _PUBLIC_
char **str_list_copy(TALLOC_CTX
*mem_ctx
, const char **list
)
252 ret
= talloc_array(mem_ctx
, char *, str_list_length(list
)+1);
256 for (i
=0;list
&& list
[i
];i
++) {
257 ret
[i
] = talloc_strdup(ret
, list
[i
]);
258 if (ret
[i
] == NULL
) {
268 Return true if all the elements of the list match exactly.
270 _PUBLIC_
bool str_list_equal(const char * const *list1
,
271 const char * const *list2
)
275 if (list1
== NULL
|| list2
== NULL
) {
276 return (list1
== list2
);
279 for (i
=0;list1
[i
] && list2
[i
];i
++) {
280 if (strcmp(list1
[i
], list2
[i
]) != 0) {
284 if (list1
[i
] || list2
[i
]) {
292 add an entry to a string list
294 _PUBLIC_
const char **str_list_add(const char **list
, const char *s
)
296 size_t len
= str_list_length(list
);
299 ret
= talloc_realloc(NULL
, list
, const char *, len
+2);
300 if (ret
== NULL
) return NULL
;
302 ret
[len
] = talloc_strdup(ret
, s
);
303 if (ret
[len
] == NULL
) return NULL
;
311 remove an entry from a string list
313 _PUBLIC_
void str_list_remove(const char **list
, const char *s
)
317 for (i
=0;list
[i
];i
++) {
318 if (strcmp(list
[i
], s
) == 0) break;
320 if (!list
[i
]) return;
329 return true if a string is in a list
331 _PUBLIC_
bool str_list_check(const char **list
, const char *s
)
335 for (i
=0; list
!= NULL
&& list
[i
] != NULL
; i
++) {
336 if (strcmp(list
[i
], s
) == 0) return true;
342 return true if a string is in a list, case insensitively
344 _PUBLIC_
bool str_list_check_ci(const char **list
, const char *s
)
348 for (i
=0; list
!= NULL
&& list
[i
] != NULL
; i
++) {
349 if (strcasecmp(list
[i
], s
) == 0) return true;
356 append one list to another - expanding list1
358 _PUBLIC_
const char **str_list_append(const char **list1
,
359 const char * const *list2
)
361 size_t len1
= str_list_length(list1
);
362 size_t len2
= str_list_length(list2
);
366 ret
= talloc_realloc(NULL
, list1
, const char *, len1
+len2
+1);
367 if (ret
== NULL
) return NULL
;
369 for (i
=len1
;i
<len1
+len2
;i
++) {
370 ret
[i
] = talloc_strdup(ret
, list2
[i
-len1
]);
371 if (ret
[i
] == NULL
) {
380 static int list_cmp(const char **el1
, const char **el2
)
382 return strcmp(*el1
, *el2
);
386 return a list that only contains the unique elements of a list,
387 removing any duplicates
389 _PUBLIC_
const char **str_list_unique(const char **list
)
391 size_t len
= str_list_length(list
);
397 list2
= (const char **)talloc_memdup(list
, list
,
398 sizeof(list
[0])*(len
+1));
399 TYPESAFE_QSORT(list2
, len
, list_cmp
);
401 for (i
=j
=1;i
<len
;i
++) {
402 if (strcmp(list2
[i
], list
[j
-1]) != 0) {
408 list
= talloc_realloc(NULL
, list
, const char *, j
+ 1);
414 very useful when debugging complex list related code
416 _PUBLIC_
void str_list_show(const char **list
)
420 for (i
=0;list
&& list
[i
];i
++) {
421 DEBUG(0,("\"%s\", ", list
[i
]));
429 append one list to another - expanding list1
430 this assumes the elements of list2 are const pointers, so we can re-use them
432 _PUBLIC_
const char **str_list_append_const(const char **list1
,
435 size_t len1
= str_list_length(list1
);
436 size_t len2
= str_list_length(list2
);
440 ret
= talloc_realloc(NULL
, list1
, const char *, len1
+len2
+1);
441 if (ret
== NULL
) return NULL
;
443 for (i
=len1
;i
<len1
+len2
;i
++) {
444 ret
[i
] = list2
[i
-len1
];
452 * Add a string to an array of strings.
454 * num should be a pointer to an integer that holds the current
455 * number of elements in strings. It will be updated by this function.
457 _PUBLIC_
bool add_string_to_array(TALLOC_CTX
*mem_ctx
,
458 const char *str
, const char ***strings
, size_t *num
)
460 char *dup_str
= talloc_strdup(mem_ctx
, str
);
462 *strings
= talloc_realloc(mem_ctx
,
464 const char *, ((*num
)+1));
466 if ((*strings
== NULL
) || (dup_str
== NULL
)) {
471 (*strings
)[*num
] = dup_str
;
478 add an entry to a string list
479 this assumes s will not change
481 _PUBLIC_
const char **str_list_add_const(const char **list
, const char *s
)
483 size_t len
= str_list_length(list
);
486 ret
= talloc_realloc(NULL
, list
, const char *, len
+2);
487 if (ret
== NULL
) return NULL
;
497 this assumes list will not change
499 _PUBLIC_
const char **str_list_copy_const(TALLOC_CTX
*mem_ctx
,
508 ret
= talloc_array(mem_ctx
, const char *, str_list_length(list
)+1);
512 for (i
=0;list
&& list
[i
];i
++) {