etc/cnid_dbd/db_param.c

   1 /*
   2  * $Id: db_param.c,v 1.9 2009-11-23 19:04:14 franklahm Exp $
   3  *
   4  * Copyright (C) Joerg Lenneis 2003
   5  * Copyright (c) Frank Lahm 2009
   6  * All Rights Reserved.  See COPYING.
   7  */
   8
   9 #ifdef HAVE_CONFIG_H
  10 #include "config.h"
  11 #endif /* HAVE_CONFIG_H */
  12
  13 #include <unistd.h>
  14 #include <string.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <errno.h>
  18 #include <sys/param.h>
  19 #include <sys/un.h>
  20 #include <sys/select.h>
  21 #include <atalk/logger.h>
  22
  23 #include "db_param.h"
  24
  25 #define DB_PARAM_FN       "db_param"
  26 #define MAXKEYLEN         64
  27
  28 #define DEFAULT_LOGFILE_AUTOREMOVE 1
  29 #define DEFAULT_CACHESIZE          (8 * 1024) /* KB, so 8 MB */
  30 #define DEFAULT_MAXLOCKS           5000
  31 #define DEFAULT_MAXLOCKOBJS        5000
  32 #define DEFAULT_FLUSH_FREQUENCY    1000
  33 #define DEFAULT_FLUSH_INTERVAL     1800
  34 #define DEFAULT_USOCK_FILE         "usock"
  35 #define DEFAULT_FD_TABLE_SIZE      512
  36 #define DEFAULT_IDLE_TIMEOUT       (10 * 60)
  37
  38 static struct db_param params;
  39 static int parse_err;
  40
  41 static size_t usock_maxlen(void)
  42 {
  43     struct sockaddr_un addr;
  44     return sizeof(addr.sun_path) - 1;
  45 }
  46
  47 static int make_pathname(char *path, char *dir, char *fn, size_t maxlen)
  48 {
  49     size_t len;
  50
  51     if (fn[0] != '/') {
  52         len = strlen(dir);
  53         if (len + 1 + strlen(fn) > maxlen)
  54             return -1;
  55         strcpy(path, dir);
  56         if (path[len - 1] != '/')
  57             strcat(path, "/");
  58         strcat(path, fn);
  59     } else {
  60         if (strlen(fn) > maxlen)
  61             return -1;
  62         strcpy(path, fn);
  63     }
  64     return 0;
  65 }
  66
  67 static void default_params(struct db_param *dbp, char *dir)
  68 {
  69     dbp->logfile_autoremove  = DEFAULT_LOGFILE_AUTOREMOVE;
  70     dbp->cachesize           = DEFAULT_CACHESIZE;
  71     dbp->maxlocks            = DEFAULT_MAXLOCKS;
  72     dbp->maxlockobjs         = DEFAULT_MAXLOCKOBJS;
  73     dbp->flush_frequency     = DEFAULT_FLUSH_FREQUENCY;
  74     dbp->flush_interval      = DEFAULT_FLUSH_INTERVAL;
  75     if (make_pathname(dbp->usock_file, dir, DEFAULT_USOCK_FILE, usock_maxlen()) < 0) {
  76         /* Not an error yet, it might be set in the config file */
  77         dbp->usock_file[0] = '\0';
  78     }
  79     dbp->fd_table_size       = DEFAULT_FD_TABLE_SIZE;
  80     if ( dbp->fd_table_size > FD_SETSIZE -1)
  81         dbp->fd_table_size = FD_SETSIZE -1;
  82     dbp->idle_timeout        = DEFAULT_IDLE_TIMEOUT;
  83
  84     return;
  85 }
  86
  87 static int parse_int(char *val)
  88 {
  89     char *tmp;
  90     int   result = 0;
  91
  92     result = strtol(val, &tmp, 10);
  93     if (tmp[0] != '\0') {
  94         LOG(log_error, logtype_cnid, "invalid characters in token %s", val);
  95         parse_err++;
  96     }
  97     return result;
  98 }
  99
 100
 101 /* TODO: This configuration file reading routine is neither very robust (%s
 102    buffer overflow) nor elegant, we need to add support for whitespace in
 103    filenames as well. */
 104
 105 struct db_param *db_param_read(char *dir, enum identity id)
 106 {
 107     FILE *fp;
 108     static char key[MAXKEYLEN + 1];
 109     static char val[MAXPATHLEN + 1];
 110     static char pfn[MAXPATHLEN + 1];
 111     int    items;
 112
 113     default_params(&params, dir);
 114     params.dir = dir;
 115
 116     if (make_pathname(pfn, dir, DB_PARAM_FN, MAXPATHLEN) < 0) {
 117         LOG(log_error, logtype_cnid, "Parameter filename too long");
 118         return NULL;
 119     }
 120
 121     if ((fp = fopen(pfn, "r")) == NULL) {
 122         if (errno == ENOENT) {
 123             if (strlen(params.usock_file) == 0) {
 124                 LOG(log_error, logtype_cnid, "default usock filename too long");
 125                 return NULL;
 126             } else {
 127                 return &params;
 128             }
 129         } else {
 130             LOG(log_error, logtype_cnid, "error opening %s: %s", pfn, strerror(errno));
 131             return NULL;
 132         }
 133     }
 134     parse_err = 0;
 135
 136     while ((items = fscanf(fp, " %s %s", key, val)) != EOF) {
 137         if (items != 2) {
 138             LOG(log_error, logtype_cnid, "error parsing config file");
 139             parse_err++;
 140             break;
 141         }
 142
 143         /* Config for both cnid_meta and dbd */
 144         if (! strcmp(key, "usock_file")) {
 145             if (make_pathname(params.usock_file, dir, val, usock_maxlen()) < 0) {
 146                 LOG(log_error, logtype_cnid, "usock filename %s too long", val);
 147                 parse_err++;
 148             } else
 149                 LOG(log_info, logtype_cnid, "db_param: setting UNIX domain socket filename to %s", params.usock_file);
 150         }
 151
 152         /* Config for cnid_metad only */
 153         if ( id == METAD ) {
 154             /* Currently empty */
 155         }
 156
 157         /* Config for dbd only */
 158         else if (id == CNID_DBD ) {
 159             if (! strcmp(key, "fd_table_size")) {
 160                 params.fd_table_size = parse_int(val);
 161                 LOG(log_info, logtype_cnid, "db_param: setting max number of concurrent afpd connections per volume (fd_table_size) to %d", params.fd_table_size);
 162             } else if (! strcmp(key, "logfile_autoremove")) {
 163                 params.logfile_autoremove = parse_int(val);
 164                 LOG(log_info, logtype_cnid, "db_param: setting logfile_autoremove to %d", params.logfile_autoremove);
 165             } else if (! strcmp(key, "cachesize")) {
 166                 params.cachesize = parse_int(val);
 167                 LOG(log_info, logtype_cnid, "db_param: setting cachesize to %d", params.cachesize);
 168             } else if (! strcmp(key, "maxlocks")) {
 169                 params.maxlocks = parse_int(val);
 170                 LOG(log_info, logtype_cnid, "db_param: setting maxlocks to %d", params.maxlocks);
 171             } else if (! strcmp(key, "maxlockobjs")) {
 172                 params.maxlockobjs = parse_int(val);
 173                 LOG(log_info, logtype_cnid, "db_param: setting maxlockobjs to %d", params.maxlockobjs);
 174             } else if (! strcmp(key, "flush_frequency")) {
 175                 params.flush_frequency = parse_int(val);
 176                 LOG(log_info, logtype_cnid, "db_param: setting flush_frequency to %d", params.flush_frequency);
 177             } else if (! strcmp(key, "flush_interval")) {
 178                 params.flush_interval = parse_int(val);
 179                 LOG(log_info, logtype_cnid, "db_param: setting flush_interval to %d", params.flush_interval);
 180             } else if (! strcmp(key, "idle_timeout")) {
 181                 params.idle_timeout = parse_int(val);
 182                 LOG(log_info, logtype_cnid, "db_param: setting idle timeout to %d", params.idle_timeout);
 183             }
 184         }
 185         if (parse_err)
 186             break;
 187     }
 188
 189     if (strlen(params.usock_file) == 0) {
 190         LOG(log_error, logtype_cnid, "default usock filename too long");
 191         parse_err++;
 192     }
 193
 194     fclose(fp);
 195     if (! parse_err) {
 196         /* sanity checks */
 197         if (params.flush_frequency <= 0)
 198             params.flush_frequency = 86400;
 199
 200         if (params.flush_interval <= 0)
 201             params.flush_interval = 1000000;
 202
 203         if (params.fd_table_size <= 2)
 204             params.fd_table_size = 32;
 205
 206         if (params.idle_timeout <= 0)
 207             params.idle_timeout = 86400;
 208
 209         return &params;
 210     }
 211     else
 212         return NULL;
 213 }
 214
 215
 216