sbin/mount_portal/conf.c

   1 /*      $NetBSD: conf.c,v 1.11 2005/02/09 13:57:57 xtraeme Exp $        */
   2
   3 /*
   4  * Copyright (c) 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software donated to Berkeley by
   8  * Jan-Simon Pendry.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  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  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  *      from: Id: conf.c,v 1.2 1992/05/27 07:09:27 jsp Exp
  35  *      @(#)conf.c      8.2 (Berkeley) 3/27/94
  36  */
  37
  38 #include <sys/cdefs.h>
  39 #ifndef lint
  40 __RCSID("$NetBSD: conf.c,v 1.11 2005/02/09 13:57:57 xtraeme Exp $");
  41 #endif /* not lint */
  42
  43 #include <sys/types.h>
  44 #include <sys/param.h>
  45 #include <sys/syslog.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <unistd.h>
  49 #include <string.h>
  50 #include <errno.h>
  51 #include <limits.h>
  52 #include <regex.h>
  53
  54 #include "portald.h"
  55
  56 #define ALLOC(ty)       (xmalloc(sizeof(ty)))
  57
  58 typedef struct path path;
  59 struct path {
  60         qelem p_q;              /* 2-way linked list */
  61         int p_lno;              /* Line number of this record */
  62         char *p_args;           /* copy of arg string (malloc) */
  63         char *p_key;            /* Pathname to match (also p_argv[0]) */
  64         regex_t p_re;           /* RE to match against pathname (malloc) */
  65         int p_use_re;           /* true if entry is RE */
  66         int p_argc;             /* number of elements in arg string */
  67         char **p_argv;          /* argv[] pointers into arg string (malloc) */
  68 };
  69
  70 static  void    ins_que(qelem *, qelem *);
  71 static  path   *palloc(char *, int, const char *);
  72 static  void    pfree(path *);
  73 static  int     pinsert(path *, qelem *);
  74 static  void    preplace(qelem *, qelem *);
  75 static  void    readfp(qelem *, FILE *, const char *);
  76 static  void    rem_que(qelem *);
  77 static  void   *xmalloc(size_t);
  78
  79 /*
  80  * Add an element to a 2-way list,
  81  * just after (pred)
  82  */
  83 static void
  84 ins_que(qelem *elem, qelem *pred)
  85 {
  86         qelem *p = pred->q_forw;
  87         elem->q_back = pred;
  88         elem->q_forw = p;
  89         pred->q_forw = elem;
  90         p->q_back = elem;
  91 }
  92
  93 /*
  94  * Remove an element from a 2-way list
  95  */
  96 static void
  97 rem_que(qelem *elem)
  98 {
  99         qelem *p = elem->q_forw;
 100         qelem *p2 = elem->q_back;
 101         p2->q_forw = p;
 102         p->q_back = p2;
 103 }
 104
 105 /*
 106  * Error checking malloc
 107  */
 108 static void *
 109 xmalloc(size_t siz)
 110 {
 111         void *p = malloc(siz);
 112         if (p)
 113                 return (p);
 114         syslog(LOG_ERR, "malloc: failed to get %lu bytes", (u_long)siz);
 115         exit(1);
 116 }
 117
 118 /*
 119  * Insert the path in the list.
 120  * If there is already an element with the same key then
 121  * the *second* one is ignored (return 0).  If the key is
 122  * not found then the path is added to the end of the list
 123  * and 1 is returned.
 124  */
 125 static int
 126 pinsert(path *p0, qelem *q0)
 127 {
 128         qelem *q;
 129
 130         if (p0->p_argc == 0)
 131                 return (0);
 132
 133         for (q = q0->q_forw; q != q0; q = q->q_forw) {
 134                 path *p = (path *) q;
 135                 if (strcmp(p->p_key, p0->p_key) == 0)
 136                         return (0);
 137         }
 138         ins_que(&p0->p_q, q0->q_back);
 139         return (1);
 140
 141 }
 142
 143 static path *
 144 palloc(char *cline, int lno, const char *conf_file)
 145 {
 146         int c, errcode;
 147         char *s;
 148         char *key;
 149         path *p;
 150         char **ap;
 151
 152         /*
 153          * Implement comment chars
 154          */
 155         s = strchr(cline, '#');
 156         if (s)
 157                 *s = 0;
 158
 159         /*
 160          * Do a pass through the string to count the number
 161          * of arguments
 162          */
 163         c = 0;
 164         key = strdup(cline);
 165         for (s = key; s != NULL; ) {
 166                 char *val;
 167                 while ((val = strsep(&s, " \t\n")) != NULL && *val == '\0')
 168                         ;
 169                 if (val)
 170                         c++;
 171         }
 172         c++;
 173         free(key);
 174
 175         if (c <= 1)
 176                 return (0);
 177
 178         /*
 179          * Now do another pass and generate a new path structure
 180          */
 181         p = ALLOC(path);
 182         p->p_argc = 0;
 183         p->p_argv = xmalloc(c * sizeof(char *));
 184         p->p_args = strdup(cline);
 185         ap = p->p_argv;
 186         for (s = p->p_args; s != NULL; ) {
 187                 char *val;
 188                 while ((val = strsep(&s, " \t\n")) != NULL && *val == '\0')
 189                         ;
 190                 if (val) {
 191                         *ap++ = val;
 192                         p->p_argc++;
 193                 }
 194         }
 195         *ap = 0;
 196
 197 #ifdef DEBUG
 198         for (c = 0; c < p->p_argc; c++)
 199                 printf("%sv[%d] = %s\n", c?"\t":"", c, p->p_argv[c]);
 200 #endif
 201
 202         p->p_key = p->p_argv[0];
 203         p->p_use_re = 0;
 204         if (strpbrk(p->p_key, RE_CHARS)) {
 205                 errcode = regcomp(&p->p_re, p->p_key, REG_EXTENDED|REG_NOSUB);
 206                 if (errcode == 0)
 207                         p->p_use_re = 1;
 208                 else {
 209                         char buf[200];
 210                         regerror(errcode, &p->p_re, buf, sizeof(buf));
 211
 212                         syslog(LOG_WARNING, "%s, line %d: regcomp \"%s\": %s",
 213                           conf_file, p->p_lno, p->p_key, buf);
 214                 }
 215         }
 216         p->p_lno = lno;
 217
 218         return (p);
 219 }
 220
 221 /*
 222  * Free a path structure
 223  */
 224 static void
 225 pfree(path *p)
 226 {
 227         free(p->p_args);
 228         free((char *) p->p_argv);
 229         if (p->p_use_re)
 230                 regfree(&p->p_re);
 231         free((char *) p);
 232 }
 233
 234 /*
 235  * Discard all currently held path structures on q0.
 236  * and add all the ones on xq.
 237  */
 238 static void
 239 preplace(qelem *q0, qelem *xq)
 240 {
 241         /*
 242          * While the list is not empty,
 243          * take the first element off the list
 244          * and free it.
 245          */
 246         while (q0->q_forw != q0) {
 247                 qelem *q = q0->q_forw;
 248                 rem_que(q);
 249                 pfree((path *) q);
 250         }
 251         while (xq->q_forw != xq) {
 252                 qelem *q = xq->q_forw;
 253                 rem_que(q);
 254                 ins_que(q, q0);
 255         }
 256 }
 257
 258 /*
 259  * Read the lines from the configuration file and
 260  * add them to the list of paths.
 261  */
 262 static void
 263 readfp(qelem *q0, FILE *fp, const char *conf_file)
 264 {
 265         char cline[LINE_MAX];
 266         int nread = 0;
 267         qelem q;
 268
 269         /*
 270          * Make a new empty list.
 271          */
 272         q.q_forw = q.q_back = &q;
 273
 274         /*
 275          * Read the lines from the configuration file.
 276          */
 277         while (fgets(cline, sizeof(cline), fp)) {
 278                 path *p = palloc(cline, nread+1, conf_file);
 279                 if (p && !pinsert(p, &q))
 280                         pfree(p);
 281                 nread++;
 282         }
 283
 284         /*
 285          * If some records were read, then throw
 286          * away the old list and replace with the
 287          * new one.
 288          */
 289         if (nread)
 290                 preplace(q0, &q);
 291 }
 292
 293 /*
 294  * Read the configuration file (conf) and replace
 295  * the existing path list with the new version.
 296  * If the file is not readable, then no changes take place
 297  */
 298 int
 299 conf_read(qelem *q, const char *conf)
 300 {
 301         FILE *fp = fopen(conf, "r");
 302         int sverrno;
 303         if (fp) {
 304                 readfp(q, fp, conf);
 305                 (void) fclose(fp);
 306                 return 0;
 307         } else {
 308                 sverrno = errno;
 309                 syslog(LOG_WARNING, "open config file \"%s\": %m", conf);
 310                 errno = sverrno;
 311                 return -1;
 312         }
 313 }
 314
 315
 316 char **
 317 conf_match(qelem *q0, char *key)
 318 {
 319         qelem *q;
 320
 321         for (q = q0->q_forw; q != q0; q = q->q_forw) {
 322                 path *p = (path *) q;
 323                 if (p->p_use_re) {
 324                         if (regexec(&p->p_re, key, 0, NULL, 0) == 0)
 325                                 return (p->p_argv+1);
 326                 } else {
 327                         if (strncmp(p->p_key, key, strlen(p->p_key)) == 0)
 328                                 return (p->p_argv+1);
 329                 }
 330         }
 331
 332         return (0);
 333 }