1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <strings.h>
29 #include <secdb.h>
30 #include <ctype.h>
31
32 /* From libnsl */
33 extern char *_strdup_null(char *);
34 extern char *_strtok_escape(char *, char *, char **);
35 extern char *_strpbrk_escape(char *, char *);
36 extern char *_unescape(char *, char *);
37
38 char *_do_unescape(char *);
39
40
41 /*
42 * kva_match(): Given a key-value array and a key, return a pointer to the
43 * value that matches the key.
44 */
45 char *
kva_match(kva_t * kva,char * key)46 kva_match(kva_t *kva, char *key)
47 {
48 int i;
49 kv_t *data;
50
51 if (kva == NULL || key == NULL) {
52 return (NULL);
53 }
54 data = kva->data;
55 for (i = 0; i < kva->length; i++) {
56 if (strcmp(data[i].key, key) == 0) {
57 return (data[i].value);
58 }
59 }
60
61 return (NULL);
62 }
63
64 /*
65 * _kva_free(): Free up memory.
66 */
67 void
_kva_free(kva_t * kva)68 _kva_free(kva_t *kva)
69 {
70 int i;
71 kv_t *data;
72
73 if (kva == NULL) {
74 return;
75 }
76 data = kva->data;
77 for (i = 0; i < kva->length; i++) {
78 if (data[i].key != NULL) {
79 free(data[i].key);
80 data[i].key = NULL;
81 }
82 if (data[i].value != NULL) {
83 free(data[i].value);
84 data[i].value = NULL;
85 }
86 }
87 free(kva->data);
88 free(kva);
89 }
90
91 /*
92 * _kva_free_value(): Free up memory (value) for all the occurrences of
93 * the given key.
94 */
95 void
_kva_free_value(kva_t * kva,char * key)96 _kva_free_value(kva_t *kva, char *key)
97 {
98 int ctr;
99 kv_t *data;
100
101 if (kva == NULL) {
102 return;
103 }
104
105 ctr = kva->length;
106 data = kva->data;
107
108 while (ctr--) {
109 if (strcmp(data->key, key) == 0 && data->value != NULL) {
110 free(data->value);
111 data->value = NULL;
112 }
113 data++;
114 }
115 }
116
117 /*
118 * new_kva(): Allocate a key-value array.
119 */
120 kva_t *
_new_kva(int size)121 _new_kva(int size)
122 {
123 kva_t *new_kva;
124
125 if ((new_kva = (kva_t *)calloc(1, sizeof (kva_t))) == NULL) {
126 return (NULL);
127 }
128 if ((new_kva->data = (kv_t *)calloc(1, (size*sizeof (kv_t)))) == NULL) {
129 free(new_kva);
130 return (NULL);
131 }
132
133 return (new_kva);
134 }
135
136 /*
137 * _str2kva(): Given a string (s) of key-value pairs, separated by delimeter
138 * (del), place the values into the key value array (nkva).
139 */
140 kva_t *
_str2kva(char * s,char * ass,char * del)141 _str2kva(char *s, char *ass, char *del)
142 {
143 int n = 0;
144 int m;
145 int size = KV_ADD_KEYS;
146 char *buf;
147 char *p;
148 char *pair;
149 char *key;
150 char *last_pair;
151 char *last_key;
152 kv_t *data;
153 kva_t *nkva;
154
155 if (s == NULL ||
156 ass == NULL ||
157 del == NULL ||
158 *s == '\0' ||
159 *s == '\n' ||
160 (strlen(s) <= 1)) {
161 return (NULL);
162 }
163 p = s;
164 while ((p = _strpbrk_escape(p, ass)) != NULL) {
165 n++;
166 p++;
167 }
168 if (n > size) {
169 m = n/size;
170 if (n%size) {
171 ++m;
172 }
173 size = m * KV_ADD_KEYS;
174 }
175 if ((nkva = _new_kva(size)) == NULL) {
176 return (NULL);
177 }
178 data = nkva->data;
179 nkva->length = 0;
180 if ((buf = strdup(s)) == NULL) {
181 return (NULL);
182 }
183 pair = _strtok_escape(buf, del, &last_pair);
184 do {
185 key = _strtok_escape(pair, ass, &last_key);
186 if (key != NULL) {
187 data[nkva->length].key = _do_unescape(key);
188 data[nkva->length].value = _do_unescape(last_key);
189 nkva->length++;
190 }
191 } while ((pair = _strtok_escape(NULL, del, &last_pair)) != NULL);
192 free(buf);
193 return (nkva);
194 }
195
196 /*
197 * _kva2str(): Given an array of key-value pairs, place them into a string
198 * (buf). Use delimeter (del) to separate pairs. Use assignment character
199 * (ass) to separate keys and values.
200 *
201 * Return Values: 0 Success 1 Buffer too small
202 */
203 int
_kva2str(kva_t * kva,char * buf,int buflen,char * ass,char * del)204 _kva2str(kva_t *kva, char *buf, int buflen, char *ass, char *del)
205 {
206 int i;
207 int len;
208 int off = 0;
209 kv_t *data;
210
211 if (kva == NULL) {
212 return (0);
213 }
214
215 buf[0] = '\0';
216 data = kva->data;
217
218 for (i = 0; i < kva->length; i++) {
219 if (data[i].value != NULL) {
220 len = snprintf(buf + off, buflen - off, "%s%s%s%s",
221 data[i].key, ass, data[i].value, del);
222 if (len < 0 || len + off >= buflen) {
223 return (1);
224 }
225 off += len;
226 }
227 }
228
229 return (0);
230 }
231
232 int
_insert2kva(kva_t * kva,char * key,char * value)233 _insert2kva(kva_t *kva, char *key, char *value)
234 {
235 int i;
236 kv_t *data;
237
238 if (kva == NULL) {
239 return (0);
240 }
241 data = kva->data;
242 for (i = 0; i < kva->length; i++) {
243 if (strcmp(data[i].key, key) == 0) {
244 if (data[i].value != NULL)
245 free(data[i].value);
246 data[i].value = _strdup_null(value);
247 return (0);
248 }
249 }
250 return (1);
251 }
252
253 kva_t *
_kva_dup(kva_t * old_kva)254 _kva_dup(kva_t *old_kva)
255 {
256 int i;
257 int size;
258 kv_t *old_data;
259 kv_t *new_data;
260 kva_t *nkva = NULL;
261
262 if (old_kva == NULL) {
263 return (NULL);
264 }
265 old_data = old_kva->data;
266 size = old_kva->length;
267 if ((nkva = _new_kva(size)) == NULL) {
268 return (NULL);
269 }
270 new_data = nkva->data;
271 nkva->length = old_kva->length;
272 for (i = 0; i < nkva->length; i++) {
273 new_data[i].key = _strdup_null(old_data[i].key);
274 new_data[i].value = _strdup_null(old_data[i].value);
275 }
276
277 return (nkva);
278 }
279
280 static void
strip_spaces(char ** valuep)281 strip_spaces(char **valuep)
282 {
283 char *p, *start;
284
285 /* Find first non-white space character and return pointer to it */
286 for (p = *valuep; *p != '\0' && isspace((unsigned char)*p); p++)
287 ;
288
289 *valuep = start = p;
290
291 if (*p == '\0')
292 return;
293
294 p = p + strlen(p) - 1;
295
296 /* Remove trailing spaces */
297 while (p > start && isspace((unsigned char)*p))
298 p--;
299
300 p[1] = '\0';
301 }
302
303 char *
_do_unescape(char * src)304 _do_unescape(char *src)
305 {
306 char *tmp = NULL;
307 char *dst = NULL;
308
309 if (src == NULL) {
310 dst = _strdup_null(src);
311 } else {
312 strip_spaces(&src);
313 tmp = _unescape(src, "=;:,\\");
314 dst = (tmp == NULL) ? _strdup_null(src) : tmp;
315 }
316
317 return (dst);
318 }
319
320
321 /*
322 * Some utilities for handling comma-separated lists.
323 */
324 char *
_argv_to_csl(char ** strings)325 _argv_to_csl(char **strings)
326 {
327 int len = 0;
328 int i = 0;
329 char *newstr = NULL;
330
331 if (strings == NULL)
332 return (NULL);
333 for (i = 0; strings[i] != NULL; i++) {
334 len += strlen(strings[i]) + 1;
335 }
336 if ((len > 0) && ((newstr = (char *)malloc(len + 1)) != NULL)) {
337 (void) memset(newstr, 0, len);
338 for (i = 0; strings[i] != NULL; i++) {
339 (void) strcat(newstr, strings[i]);
340 (void) strcat(newstr, ",");
341 }
342 newstr[len-1] = NULL;
343 return (newstr);
344 } else
345 return (NULL);
346 }
347
348
349 char **
_csl_to_argv(char * csl)350 _csl_to_argv(char *csl)
351 {
352 int len = 0;
353 int ncommas = 0;
354 int i = 0;
355 char **spc = NULL;
356 char *copy = NULL;
357 char *pc;
358 char *lasts = NULL;
359
360 len = strlen(csl);
361 for (i = 0; i < len; i++) {
362 if (csl[i] == ',')
363 ncommas++;
364 }
365 if ((spc = (char **)malloc((ncommas + 2) * sizeof (char *))) == NULL) {
366 return (NULL);
367 }
368 copy = strdup(csl);
369 for (pc = strtok_r(copy, ",", &lasts), i = 0; pc != NULL;
370 pc = strtok_r(NULL, ",", &lasts), i++) {
371 spc[i] = strdup(pc);
372 }
373 spc[i] = NULL;
374 free(copy);
375 return (spc);
376 }
377
378
379 void
_free_argv(char ** p_argv)380 _free_argv(char **p_argv)
381 {
382 char **p_a;
383
384 for (p_a = p_argv; *p_a != NULL; p_a++)
385 free(*p_a);
386 free(p_argv);
387 }
388
389
390 #ifdef DEBUG
391 void
print_kva(kva_t * kva)392 print_kva(kva_t *kva)
393 {
394 int i;
395 kv_t *data;
396
397 if (kva == NULL) {
398 (void) printf(" (empty)\n");
399 return;
400 }
401 data = kva->data;
402 for (i = 0; i < kva->length; i++) {
403 (void) printf(" %s = %s\n",
404 data[i].key != NULL ? data[i].key : "NULL",
405 data[i].value != NULL ? data[i].value : "NULL");
406 }
407 }
408 #endif /* DEBUG */
409