config.c

   1 /*
   2  * These are very basic config file routines for the main module of CNTLM
   3  *
   4  * CNTLM is free software; you can redistribute it and/or modify it under the
   5  * terms of the GNU General Public License as published by the Free Software
   6  * Foundation; either version 2 of the License, or (at your option) any later
   7  * version.
   8  *
   9  * CNTLM is distributed in the hope that it will be useful, but WITHOUT ANY
  10  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  11  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  12  * details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
  16  * St, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * Copyright (c) 2007 David Kubicek
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26
  27 #include "globals.h"
  28 #include "config.h"
  29 #include "utils.h"
  30
  31 /*
  32 static const char *globals[] = {
  33         "Allow",
  34         "Deny",
  35         "Gateway",
  36         "Listen",
  37         "SOCKS5Proxy",
  38         "SOCKS5User",
  39         "NTLMToBasic",
  40         "Tunnel" };
  41 */
  42
  43 config_t config_open(const char *fname) {
  44         config_t rc;
  45         FILE *fp;
  46         char *buf, *tmp, *key, *value;
  47         char section[MINIBUF_SIZE] = "global";
  48         int i, j, slen, len, quote;
  49
  50         //printf("sizeof = %d\n", sizeof(globals) / sizeof(char *));
  51
  52         fp = fopen(fname, "r");
  53         if (!fp)
  54                 return NULL;
  55
  56         buf = new(BUFSIZE);
  57         rc = (config_t)new(sizeof(struct config_s));
  58         rc->options = NULL;
  59
  60         while (!feof(fp)) {
  61                 quote = 0;
  62                 tmp = fgets(buf, BUFSIZE, fp);
  63                 if (!tmp)
  64                         break;
  65
  66                 len = MIN(BUFSIZE, strlen(buf));
  67                 if (!len || feof(fp))
  68                         continue;
  69
  70                 /*
  71                  * Find first non-empty character
  72                  */
  73                 for (i = j = 0; j < len && isspace(buf[j]); ++j);
  74
  75                 /*
  76                  * Comment?
  77                  */
  78                 if (j >= len || buf[j] == '#' || buf[j] == ';')
  79                         continue;
  80
  81                 /*
  82                  * Find end of keyword
  83                  */
  84                 for (i = j; j < len && isalnum(buf[j]); ++j);
  85
  86                 /*
  87                  * Malformed?
  88                  */
  89                 if (j >= len)
  90                         continue;
  91
  92                 /*
  93                  * Is it a section?
  94                  */
  95                 if (buf[j] == '[') {
  96                         for (++j; j < len && isspace(buf[j]); ++j);
  97                         for (slen = j; j < len && j-slen < MINIBUF_SIZE-1 && buf[j] != ']' && !isspace(buf[j]); ++j);
  98                         if (j-slen > 0) {
  99                                 strlcpy(section, buf+slen, j-slen+1);
 100                         }
 101                         continue;
 102                 }
 103
 104                 /*
 105                  * It's an OK keyword
 106                  */
 107                 key = substr(buf, i, j-i);
 108
 109                 /*
 110                  * Find next non-empty character
 111                  */
 112                 for (i = j; j < len && isspace(buf[j]); ++j);
 113                 if (j >= len || buf[j] == '#' || buf[j] == ';')
 114                         continue;
 115
 116                 /*
 117                  * Is value quoted?
 118                  */
 119                 if (buf[j] == '"') {
 120                         quote = 1;
 121                         for (i = ++j; j < len && buf[i] != '"'; ++i);
 122                         if (i >= len)
 123                                 continue;
 124                 } else
 125                         i = len;
 126
 127                 /*
 128                  * Get value as quoted or until EOL/comment
 129                  */
 130                 value = substr(buf, j, i-j);
 131                 if (!quote) {
 132                         i = strcspn(value, "#");
 133                         if (i != strlen(value))
 134                                 value[i] = 0;
 135                         trimr(value);
 136                 }
 137
 138                 if (debug)
 139                         printf("section: %s, %s = '%s'\n", section, key, value);
 140                 rc->options = hlist_add(rc->options, key, value, HLIST_NOALLOC, HLIST_NOALLOC);
 141         }
 142
 143         free(buf);
 144         fclose(fp);
 145
 146         return rc;
 147 }
 148
 149 void config_set(config_t cf, char *option, char *value) {
 150         cf->options = hlist_mod(cf->options, option, value, 1);
 151 }
 152
 153 char *config_pop(config_t cf, const char *option) {
 154         char *tmp;
 155
 156         tmp = hlist_get(cf->options, option);
 157         if (tmp) {
 158                 tmp = strdup(tmp);
 159                 cf->options = hlist_del(cf->options, option);
 160         }
 161
 162         return tmp;
 163 }
 164
 165 int config_count(config_t cf) {
 166         return hlist_count(cf->options);
 167 }
 168
 169 void config_close(config_t cf) {
 170         if (cf == NULL)
 171                 return;
 172
 173         cf->options = hlist_free(cf->options);
 174         free(cf);
 175 }