sys/dev/vinum/vinumparser.c

   1 /*-
   2  * Copyright (c) 1997, 1998
   3  *      Nan Yang Computer Services Limited.  All rights reserved.
   4  *
   5  *  This software is distributed under the so-called ``Berkeley
   6  *  License'':
   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  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by Nan Yang Computer
  19  *      Services Limited.
  20  * 4. Neither the name of the Company nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * This software is provided ``as is'', and any express or implied
  25  * warranties, including, but not limited to, the implied warranties of
  26  * merchantability and fitness for a particular purpose are disclaimed.
  27  * In no event shall the company or contributors be liable for any
  28  * direct, indirect, incidental, special, exemplary, or consequential
  29  * damages (including, but not limited to, procurement of substitute
  30  * goods or services; loss of use, data, or profits; or business
  31  * interruption) however caused and on any theory of liability, whether
  32  * in contract, strict liability, or tort (including negligence or
  33  * otherwise) arising in any way out of the use of this software, even if
  34  * advised of the possibility of such damage.
  35  *
  36  * $Id: vinumparser.c,v 1.21 2000/12/20 03:44:13 grog Exp grog $
  37  * $FreeBSD$
  38  */
  39
  40 /*
  41  * This file contains the parser for the configuration routines.  It's used
  42  * both in the kernel and in the user interface program, thus the separate file.
  43  */
  44
  45 /*
  46  * Go through a text and split up into text tokens.  These are either non-blank
  47  * sequences, or any sequence (except \0) enclosed in ' or ".  Embedded ' or
  48  * " characters may be escaped by \, which otherwise has no special meaning.
  49  *
  50  * Delimit by following with a \0, and return pointers to the starts at token [].
  51  * Return the number of tokens found as the return value.
  52  *
  53  * This method has the restriction that a closing " or ' must be followed by
  54  * grey space.
  55  *
  56  * Error conditions are end of line before end of quote, or no space after
  57  * a closing quote.  In this case, tokenize() returns -1.
  58  */
  59
  60 #include <sys/param.h>
  61 #include <dev/vinum/vinumkw.h>
  62 #ifdef _KERNEL
  63 #include <sys/systm.h>
  64 #include <sys/conf.h>
  65 #include <machine/setjmp.h>
  66 /* All this mess for a single struct definition */
  67 #include <sys/uio.h>
  68 #include <sys/namei.h>
  69 #include <sys/mount.h>
  70
  71 #include <dev/vinum/vinumvar.h>
  72 #include <dev/vinum/vinumio.h>
  73 #include <dev/vinum/vinumext.h>
  74 #define iswhite(c) ((c == ' ') || (c == '\t'))              /* check for white space */
  75 #else /* userland */
  76 #include <ctype.h>
  77 #include <errno.h>
  78 #include <fcntl.h>
  79 #define iswhite isspace                                     /* use the ctype macro */
  80 #endif
  81
  82 /* enum keyword is defined in vinumvar.h */
  83
  84 #define keypair(x) { #x, kw_##x }                           /* create pair "foo", kw_foo */
  85 #define flagkeypair(x) { "-"#x, kw_##x }                    /* create pair "-foo", kw_foo */
  86 #define KEYWORDSET(x) {sizeof (x) / sizeof (struct _keywords), x}
  87
  88 /* Normal keywords.  These are all the words that vinum knows. */
  89 struct _keywords keywords[] =
  90 {keypair(drive),
  91     keypair(partition),
  92     keypair(sd),
  93     keypair(subdisk),
  94     keypair(plex),
  95     keypair(volume),
  96     keypair(vol),
  97     keypair(setupstate),
  98     keypair(readpol),
  99     keypair(org),
 100     keypair(name),
 101     keypair(writethrough),
 102     keypair(writeback),
 103     keypair(raw),
 104     keypair(device),
 105     keypair(concat),
 106     keypair(raid4),
 107     keypair(raid5),
 108     keypair(striped),
 109     keypair(plexoffset),
 110     keypair(driveoffset),
 111     keypair(length),
 112     keypair(len),
 113     keypair(size),
 114     keypair(state),
 115     keypair(round),
 116     keypair(prefer),
 117     keypair(rename),
 118     keypair(detached),
 119 #ifndef _KERNEL                                             /* for vinum(8) only */
 120 #ifdef VINUMDEBUG
 121     keypair(debug),
 122 #endif
 123     keypair(stripe),
 124     keypair(mirror),
 125 #endif
 126     keypair(attach),
 127     keypair(detach),
 128     keypair(printconfig),
 129     keypair(saveconfig),
 130     keypair(replace),
 131     keypair(create),
 132     keypair(read),
 133     keypair(modify),
 134     keypair(list),
 135     keypair(l),
 136     keypair(ld),
 137     keypair(ls),
 138     keypair(lp),
 139     keypair(lv),
 140     keypair(info),
 141     keypair(set),
 142     keypair(rm),
 143     keypair(mv),
 144     keypair(move),
 145     keypair(init),
 146     keypair(label),
 147     keypair(resetconfig),
 148     keypair(start),
 149     keypair(stop),
 150     keypair(makedev),
 151     keypair(help),
 152     keypair(quit),
 153     keypair(setdaemon),
 154     keypair(getdaemon),
 155     keypair(max),
 156     keypair(replace),
 157     keypair(readpol),
 158     keypair(resetstats),
 159     keypair(setstate),
 160     keypair(checkparity),
 161     keypair(rebuildparity),
 162     keypair(dumpconfig),
 163     keypair(retryerrors)
 164 };
 165 struct keywordset keyword_set = KEYWORDSET(keywords);
 166
 167 #ifndef _KERNEL
 168 struct _keywords flag_keywords[] =
 169 {flagkeypair(f),
 170     flagkeypair(d),
 171     flagkeypair(v),
 172     flagkeypair(s),
 173     flagkeypair(r),
 174     flagkeypair(w)
 175 };
 176 struct keywordset flag_set = KEYWORDSET(flag_keywords);
 177
 178 #endif
 179
 180 /*
 181  * Take a blank separated list of tokens and turn it into a list of
 182  * individual nul-delimited strings.  Build a list of pointers at
 183  * token, which must have enough space for the tokens.  Return the
 184  * number of tokens, or -1 on error (typically a missing string
 185  * delimiter).
 186  */
 187 int
 188 tokenize(char *cptr, char *token[], int maxtoken)
 189 {
 190     char delim;                                             /* delimiter for searching for the partner */
 191     int tokennr;                                            /* index of this token */
 192
 193     for (tokennr = 0; tokennr < maxtoken;) {
 194         while (iswhite(*cptr))
 195             cptr++;                                         /* skip initial white space */
 196         if ((*cptr == '\0') || (*cptr == '\n') || (*cptr == '#')) /* end of line */
 197             return tokennr;                                 /* return number of tokens found */
 198         delim = *cptr;
 199         token[tokennr] = cptr;                              /* point to it */
 200         tokennr++;                                          /* one more */
 201         if (tokennr == maxtoken)                            /* run off the end? */
 202             return tokennr;
 203         if ((delim == '\'') || (delim == '"')) {            /* delimitered */
 204             for (;;) {
 205                 cptr++;
 206                 if ((*cptr == delim) && (cptr[-1] != '\\')) { /* found the partner */
 207                     cptr++;                                 /* move on past */
 208                     if (!iswhite(*cptr))                    /* error, no space after closing quote */
 209                         return -1;
 210                     *cptr++ = '\0';                         /* delimit */
 211                 } else if ((*cptr == '\0') || (*cptr == '\n')) /* end of line */
 212                     return -1;
 213             }
 214         } else {                                            /* not quoted */
 215             while ((*cptr != '\0') && (!iswhite(*cptr)) && (*cptr != '\n'))
 216                 cptr++;
 217             if (*cptr != '\0')                              /* not end of the line, */
 218                 *cptr++ = '\0';                             /* delimit and move to the next */
 219         }
 220     }
 221     return maxtoken;                                        /* can't get here */
 222 }
 223
 224 /* Find a keyword and return an index */
 225 enum keyword
 226 get_keyword(char *name, struct keywordset *keywordset)
 227 {
 228     int i;
 229     struct _keywords *keywords = keywordset->k;             /* point to the keywords */
 230     if (name != NULL) {                                     /* parameter exists */
 231         for (i = 0; i < keywordset->size; i++)
 232             if (!strcmp(name, keywords[i].name))
 233                 return (enum keyword) keywords[i].keyword;
 234     }
 235     return kw_invalid_keyword;
 236 }