usr/src/lib/libsecdb/common/secdb.c

   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 *
  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
  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
  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  *
 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  *
 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
 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
 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                         free(data[i].value);
 245                         data[i].value = _strdup_null(value);
 246                         return (0);
 247                 }
 248         }
 249         return (1);
 250 }
 251
 252 kva_t  *
 253 _kva_dup(kva_t *old_kva)
 254 {
 255         int     i;
 256         int     size;
 257         kv_t    *old_data;
 258         kv_t    *new_data;
 259         kva_t   *nkva = NULL;
 260
 261         if (old_kva == NULL) {
 262                 return (NULL);
 263         }
 264         old_data = old_kva->data;
 265         size = old_kva->length;
 266         if ((nkva = _new_kva(size)) == NULL) {
 267                 return (NULL);
 268         }
 269         new_data = nkva->data;
 270         nkva->length = old_kva->length;
 271         for (i = 0; i < nkva->length; i++) {
 272                 new_data[i].key = _strdup_null(old_data[i].key);
 273                 new_data[i].value = _strdup_null(old_data[i].value);
 274         }
 275
 276         return (nkva);
 277 }
 278
 279 static void
 280 strip_spaces(char **valuep)
 281 {
 282         char *p, *start;
 283
 284         /* Find first non-white space character and return pointer to it */
 285         for (p = *valuep; *p != '\0' && isspace((unsigned char)*p); p++)
 286                 ;
 287
 288         *valuep = start = p;
 289
 290         if (*p == '\0')
 291                 return;
 292
 293         p = p + strlen(p) - 1;
 294
 295         /* Remove trailing spaces */
 296         while (p > start && isspace((unsigned char)*p))
 297                 p--;
 298
 299         p[1] = '\0';
 300 }
 301
 302 char *
 303 _do_unescape(char *src)
 304 {
 305         char *tmp = NULL;
 306         char *dst = NULL;
 307
 308         if (src == NULL) {
 309                 dst = _strdup_null(src);
 310         } else {
 311                 strip_spaces(&src);
 312                 tmp = _unescape(src, "=;:,\\");
 313                 dst = (tmp == NULL) ? _strdup_null(src) : tmp;
 314         }
 315
 316         return (dst);
 317 }
 318
 319
 320 /*
 321  * Some utilities for handling comma-separated lists.
 322  */
 323 char *
 324 _argv_to_csl(char **strings)
 325 {
 326         int len = 0;
 327         int i = 0;
 328         char *newstr = NULL;
 329
 330         if (strings == NULL)
 331                 return (NULL);
 332         for (i = 0; strings[i] != NULL; i++) {
 333                 len += strlen(strings[i]) + 1;
 334         }
 335         if ((len > 0) && ((newstr = (char *)malloc(len + 1)) != NULL)) {
 336                 (void) memset(newstr, 0, len);
 337                 for (i = 0; strings[i] != NULL; i++) {
 338                         (void) strcat(newstr, strings[i]);
 339                         (void) strcat(newstr, ",");
 340                 }
 341                 newstr[len-1] = '\0';
 342                 return (newstr);
 343         } else
 344                 return (NULL);
 345 }
 346
 347
 348 char **
 349 _csl_to_argv(char *csl)
 350 {
 351         int len = 0;
 352         int ncommas = 0;
 353         int i = 0;
 354         char **spc = NULL;
 355         char *copy = NULL;
 356         char *pc;
 357         char *lasts = NULL;
 358
 359         len = strlen(csl);
 360         for (i = 0; i < len; i++) {
 361                 if (csl[i] == ',')
 362                         ncommas++;
 363         }
 364         if ((spc = (char **)malloc((ncommas + 2) * sizeof (char *))) == NULL) {
 365                 return (NULL);
 366         }
 367         copy = strdup(csl);
 368         for (pc = strtok_r(copy, ",", &lasts), i = 0; pc != NULL;
 369             pc = strtok_r(NULL, ",", &lasts), i++) {
 370                 spc[i] = strdup(pc);
 371         }
 372         spc[i] = NULL;
 373         free(copy);
 374         return (spc);
 375 }
 376
 377
 378 void
 379 _free_argv(char **p_argv)
 380 {
 381         char **p_a;
 382
 383         for (p_a = p_argv; *p_a != NULL; p_a++)
 384                 free(*p_a);
 385         free(p_argv);
 386 }
 387
 388
 389 #ifdef DEBUG
 390 void
 391 print_kva(kva_t *kva)
 392 {
 393         int     i;
 394         kv_t    *data;
 395
 396         if (kva == NULL) {
 397                 (void) printf("  (empty)\n");
 398                 return;
 399         }
 400         data = kva->data;
 401         for (i = 0; i < kva->length; i++) {
 402                 (void) printf("  %s = %s\n",
 403                     data[i].key != NULL ? data[i].key : "NULL",
 404                     data[i].value != NULL ? data[i].value : "NULL");
 405         }
 406 }
 407 #endif  /* DEBUG */