lib/libutil/property.c

   1 /*
   2  *
   3  * Simple property list handling code.
   4  *
   5  * Copyright (c) 1998
   6  *      Jordan Hubbard.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer,
  13  *    verbatim and that no modifications are made prior to this
  14  *    point in the file.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR HIS PETS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, LIFE OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  * $FreeBSD: src/lib/libutil/property.c,v 1.5.6.1 2000/11/22 03:49:49 murray Exp $
  32  * $DragonFly: src/lib/libutil/property.c,v 1.3 2005/03/04 05:31:11 cpressey Exp $
  33  *
  34  */
  35
  36 #include <sys/types.h>
  37
  38 #include <ctype.h>
  39 #include <err.h>
  40 #include <stdlib.h>
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <unistd.h>
  44
  45 #include "libutil.h"
  46
  47 static properties
  48 property_alloc(char *name, char *value)
  49 {
  50     properties n;
  51
  52     n = (properties)malloc(sizeof(struct _property));
  53     n->next = NULL;
  54     n->name = name ? strdup(name) : NULL;
  55     n->value = value ? strdup(value) : NULL;
  56     return n;
  57 }
  58
  59 properties
  60 properties_read(int fd)
  61 {
  62     properties head, ptr;
  63     char hold_n[PROPERTY_MAX_NAME + 1];
  64     char hold_v[PROPERTY_MAX_VALUE + 1];
  65     char buf[BUFSIZ * 4];
  66     int bp, n, v, max;
  67     enum { LOOK, COMMENT, NAME, VALUE, MVALUE, COMMIT, FILL, STOP } state;
  68     int ch = 0, blevel = 0;
  69
  70     n = v = bp = max = 0;
  71     head = ptr = NULL;
  72     state = LOOK;
  73     while (state != STOP) {
  74         if (state != COMMIT) {
  75             if (bp == max)
  76                 state = FILL;
  77             else
  78                 ch = buf[bp++];
  79         }
  80         switch(state) {
  81         case FILL:
  82             if ((max = read(fd, buf, sizeof buf)) <= 0) {
  83                 state = STOP;
  84                 break;
  85             }
  86             else {
  87                 state = LOOK;
  88                 ch = buf[0];
  89                 bp = 1;
  90             }
  91             /* Fall through deliberately since we already have a character and state == LOOK */
  92
  93         case LOOK:
  94             if (isspace(ch))
  95                 continue;
  96             /* Allow shell or lisp style comments */
  97             else if (ch == '#' || ch == ';') {
  98                 state = COMMENT;
  99                 continue;
 100             }
 101             else if (isalnum(ch) || ch == '_') {
 102                 if (n >= PROPERTY_MAX_NAME) {
 103                     n = 0;
 104                     state = COMMENT;
 105                 }
 106                 else {
 107                     hold_n[n++] = ch;
 108                     state = NAME;
 109                 }
 110             }
 111             else
 112                 state = COMMENT;        /* Ignore the rest of the line */
 113             break;
 114
 115         case COMMENT:
 116             if (ch == '\n')
 117                 state = LOOK;
 118             break;
 119
 120         case NAME:
 121             if (ch == '\n' || !ch) {
 122                 hold_n[n] = '\0';
 123                 hold_v[0] = '\0';
 124                 v = n = 0;
 125                 state = COMMIT;
 126             }
 127             else if (isspace(ch))
 128                 continue;
 129             else if (ch == '=') {
 130                 hold_n[n] = '\0';
 131                 v = n = 0;
 132                 state = VALUE;
 133             }
 134             else
 135                 hold_n[n++] = ch;
 136             break;
 137
 138         case VALUE:
 139             if (v == 0 && ch == '\n') {
 140                 hold_v[v] = '\0';
 141                 v = n = 0;
 142                 state = COMMIT;
 143             }
 144             else if (v == 0 && isspace(ch))
 145                 continue;
 146             else if (ch == '{') {
 147                 state = MVALUE;
 148                 ++blevel;
 149             }
 150             else if (ch == '\n' || !ch) {
 151                 hold_v[v] = '\0';
 152                 v = n = 0;
 153                 state = COMMIT;
 154             }
 155             else {
 156                 if (v >= PROPERTY_MAX_VALUE) {
 157                     state = COMMENT;
 158                     v = n = 0;
 159                     break;
 160                 }
 161                 else
 162                     hold_v[v++] = ch;
 163             }
 164             break;
 165
 166         case MVALUE:
 167             /* multiline value */
 168             if (v >= PROPERTY_MAX_VALUE) {
 169                 warn("properties_read: value exceeds max length");
 170                 state = COMMENT;
 171                 n = v = 0;
 172             }
 173             else if (ch == '}' && !--blevel) {
 174                 hold_v[v] = '\0';
 175                 v = n = 0;
 176                 state = COMMIT;
 177             }
 178             else {
 179                 hold_v[v++] = ch;
 180                 if (ch == '{')
 181                     ++blevel;
 182             }
 183             break;
 184
 185         case COMMIT:
 186             if (!head)
 187                 head = ptr = property_alloc(hold_n, hold_v);
 188             else {
 189                 ptr->next = property_alloc(hold_n, hold_v);
 190                 ptr = ptr->next;
 191             }
 192             state = LOOK;
 193             v = n = 0;
 194             break;
 195
 196         case STOP:
 197             /* we don't handle this here, but this prevents warnings */
 198             break;
 199         }
 200     }
 201     return head;
 202 }
 203
 204 char *
 205 property_find(properties list, const char *name)
 206 {
 207     if (!list || !name || !name[0])
 208         return NULL;
 209     while (list) {
 210         if (!strcmp(list->name, name))
 211             return list->value;
 212         list = list->next;
 213     }
 214     return NULL;
 215 }
 216
 217 void
 218 properties_free(properties list)
 219 {
 220     properties tmp;
 221
 222     while (list) {
 223         tmp = list->next;
 224         if (list->name)
 225             free(list->name);
 226         if (list->value)
 227             free(list->value);
 228         free(list);
 229         list = tmp;
 230     }
 231 }