src/conf.c

   1 /* Copyright (C) 2009-2014, Martin Johansson <martin@fatbob.nu>
   2    Copyright (C) 2005-2014, Thorvald Natvig <thorvald@natvig.com>
   3
   4    All rights reserved.
   5
   6    Redistribution and use in source and binary forms, with or without
   7    modification, are permitted provided that the following conditions
   8    are met:
   9
  10    - Redistributions of source code must retain the above copyright notice,
  11      this list of conditions and the following disclaimer.
  12    - Redistributions in binary form must reproduce the above copyright notice,
  13      this list of conditions and the following disclaimer in the documentation
  14      and/or other materials provided with the distribution.
  15    - Neither the name of the Developers nor the names of its contributors may
  16      be used to endorse or promote products derived from this software without
  17      specific prior written permission.
  18
  19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
  23    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30 */
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include <libconfig.h>
  36
  37 #include "types.h"
  38 #include "conf.h"
  39 #include "log.h"
  40
  41 static config_t configuration;
  42
  43 #define DEFAULT_WELCOME "Welcome to uMurmur!"
  44 #define DEFAULT_MAX_CLIENTS 10
  45 #define DEFAULT_MAX_BANDWIDTH 48000
  46 #define DEFAULT_BINDPORT 64738
  47 #define DEFAULT_BAN_LENGTH (60*60)
  48 #define DEFAULT_OPUS_THRESHOLD 100
  49
  50 const char defaultconfig[] = DEFAULT_CONFIG;
  51
  52 void Conf_init(const char *conffile)
  53 {
  54         config_init(&configuration);
  55         if (conffile == NULL)
  56                 conffile = defaultconfig;
  57         if (config_read_file(&configuration, conffile) != CONFIG_TRUE) {
  58                 Log_fatal("Error in config file %s line %d: %s", conffile,
  59                                   config_error_line(&configuration), config_error_text(&configuration));
  60         }
  61 }
  62
  63 bool_t Conf_ok(const char *conffile)
  64 {
  65         bool_t rc = true;
  66         config_init(&configuration);
  67         if (conffile == NULL)
  68                 conffile = defaultconfig;
  69         if (config_read_file(&configuration, conffile) != CONFIG_TRUE) {
  70                 fprintf(stderr, "Error in config file %s line %d: %s\n", conffile,
  71                         config_error_line(&configuration), config_error_text(&configuration));
  72                 rc = false;
  73         }
  74         config_destroy(&configuration);
  75         return rc;
  76 }
  77
  78 void Conf_deinit()
  79 {
  80         config_destroy(&configuration);
  81 }
  82
  83 const char *getStrConf(param_t param)
  84 {
  85         config_setting_t *setting = NULL;
  86         const char *strsetting = NULL;
  87
  88         switch (param) {
  89         case CERTIFICATE:
  90                 setting = config_lookup(&configuration, "certificate");
  91                 if (!setting)
  92                         return "/etc/umurmur/certificate.crt";
  93                 else {
  94                         if ((strsetting = config_setting_get_string(setting)) != NULL)
  95                                 return strsetting;
  96                         else
  97                                 return "/etc/umurmur/certificate.crt";
  98                 }
  99                 break;
 100         case KEY:
 101                 setting = config_lookup(&configuration, "private_key");
 102                 if (!setting)
 103                         return "/etc/umurmur/private_key.key";
 104                 else {
 105                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 106                                 return strsetting;
 107                         else
 108                                 return "/etc/umurmur/private_key.key";
 109                 }
 110                 break;
 111         case CAPATH:
 112                 setting = config_lookup(&configuration, "ca_path");
 113                 if (!setting)
 114                   return NULL;
 115                 else {
 116                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 117                                 return strsetting;
 118                         else
 119                                 return NULL;
 120                 }
 121                 break;
 122         case PASSPHRASE:
 123                 setting = config_lookup(&configuration, "password");
 124                 if (!setting)
 125                         return "";
 126                 else {
 127                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 128                                 return strsetting;
 129                         else
 130                                 return "";
 131                 }
 132                 break;
 133         case ADMIN_PASSPHRASE:
 134                 setting = config_lookup(&configuration, "admin_password");
 135                 if (!setting)
 136                         return "";
 137                 else {
 138                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 139                                 return strsetting;
 140                         else
 141                                 return "";
 142                 }
 143                 break;
 144         case BINDADDR:
 145                 setting = config_lookup(&configuration, "bindaddr");
 146                 if (!setting)
 147                         return NULL;
 148                 else {
 149                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 150                                 return strsetting;
 151                         else
 152                                 return NULL;
 153                 }
 154                 break;
 155         case BINDADDR6:
 156                 setting = config_lookup(&configuration, "bindaddr6");
 157                 if (!setting)
 158                         return NULL;
 159                 else {
 160                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 161                                 return strsetting;
 162                         else
 163                                 return NULL;
 164                 }
 165                 break;
 166         case WELCOMETEXT:
 167                 setting = config_lookup(&configuration, "welcometext");
 168                 if (!setting)
 169                         return DEFAULT_WELCOME;
 170                 else {
 171                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 172                                 return strsetting;
 173                         else
 174                         return DEFAULT_WELCOME;
 175                 }
 176                 break;
 177         case DEFAULT_CHANNEL:
 178                 setting = config_lookup(&configuration, "default_channel");
 179                 if (!setting)
 180                         return "";
 181                 else {
 182                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 183                                 return strsetting;
 184                         else
 185                         return "";
 186                 }
 187                 break;
 188         case USERNAME:
 189                 setting = config_lookup(&configuration, "username");
 190                 if (!setting)
 191                         return "";
 192                 else {
 193                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 194                                 return strsetting;
 195                         else
 196                         return "";
 197                 }
 198                 break;
 199         case GROUPNAME:
 200                 setting = config_lookup(&configuration, "groupname");
 201                 if (!setting)
 202                         return "";
 203                 else {
 204                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 205                                 return strsetting;
 206                         else
 207                         return "";
 208                 }
 209                 break;
 210         case LOGFILE:
 211                 setting = config_lookup(&configuration, "logfile");
 212                 if (!setting)
 213                         return NULL;
 214                 else {
 215                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 216                                 return strsetting;
 217                         else
 218                         return NULL;
 219                 }
 220                 break;
 221         case BANFILE:
 222                 setting = config_lookup(&configuration, "banfile");
 223                 if (!setting)
 224                         return NULL;
 225                 else {
 226                         if ((strsetting = config_setting_get_string(setting)) != NULL)
 227                                 return strsetting;
 228                         else
 229                         return NULL;
 230                 }
 231                 break;
 232         default:
 233                 doAssert(false);
 234                 break;
 235         }
 236         return NULL;
 237 }
 238
 239 int getIntConf(param_t param)
 240 {
 241         config_setting_t *setting = NULL;
 242
 243         switch (param) {
 244         case BINDPORT:
 245                 setting = config_lookup(&configuration, "bindport");
 246                 if (!setting)
 247                         return DEFAULT_BINDPORT;
 248                 else {
 249                         return config_setting_get_int(setting);
 250                 }
 251                 break;
 252         case BINDPORT6:
 253                 setting = config_lookup(&configuration, "bindport6");
 254                 if (!setting)
 255                         return DEFAULT_BINDPORT;
 256                 else {
 257                         return config_setting_get_int(setting);
 258                 }
 259                 break;
 260         case BAN_LENGTH:
 261                 setting = config_lookup(&configuration, "ban_length");
 262                 if (!setting)
 263                         return DEFAULT_BAN_LENGTH;
 264                 else {
 265                         return config_setting_get_int(setting);
 266                 }
 267                 break;
 268         case MAX_BANDWIDTH:
 269                 setting = config_lookup(&configuration, "max_bandwidth");
 270                 if (!setting)
 271                         return DEFAULT_MAX_BANDWIDTH;
 272                 else {
 273                         return config_setting_get_int(setting);
 274                 }
 275                 break;
 276         case MAX_CLIENTS:
 277                 setting = config_lookup(&configuration, "max_users");
 278                 if (!setting)
 279                         return DEFAULT_MAX_CLIENTS;
 280                 else {
 281                         return config_setting_get_int(setting);
 282                 }
 283                 break;
 284         case OPUS_THRESHOLD:
 285                 setting = config_lookup(&configuration, "opus_threshold");
 286                 if (!setting)
 287                         return DEFAULT_OPUS_THRESHOLD;
 288                 else {
 289                         return config_setting_get_int(setting);
 290                 }
 291                 break;
 292         default:
 293                 doAssert(false);
 294         }
 295 }
 296
 297 bool_t getBoolConf(param_t param)
 298 {
 299         config_setting_t *setting = NULL;
 300
 301         switch (param) {
 302         case ALLOW_TEXTMESSAGE:
 303                 setting = config_lookup(&configuration, "allow_textmessage");
 304                 if (!setting)
 305                         return true;
 306                 else
 307                         return config_setting_get_bool(setting);
 308                 break;
 309         case ENABLE_BAN:
 310                 setting = config_lookup(&configuration, "enable_ban");
 311                 if (!setting)
 312                         return false;
 313                 else
 314                         return config_setting_get_bool(setting);
 315                 break;
 316         case SYNC_BANFILE:
 317                 setting = config_lookup(&configuration, "sync_banfile");
 318                 if (!setting)
 319                         return false;
 320                 else
 321                         return config_setting_get_bool(setting);
 322                 break;
 323         default:
 324                 doAssert(false);
 325         }
 326 }
 327
 328 int Conf_getNextChannel(conf_channel_t *chdesc, int index)
 329 {
 330         config_setting_t *setting = NULL;
 331         int maxconfig = 64, ret = 0;
 332         char configstr[maxconfig];
 333
 334         ret = snprintf(configstr, maxconfig, "channels.[%d].name", index);
 335         setting = config_lookup(&configuration, configstr);
 336         if (ret >= maxconfig || ret < 0 || setting == NULL)
 337                 return -1; /* Required */
 338         chdesc->name =  config_setting_get_string(setting);
 339
 340         ret = snprintf(configstr, maxconfig, "channels.[%d].parent", index);
 341         setting = config_lookup(&configuration, configstr);
 342         if (ret >= maxconfig || ret < 0 || setting == NULL)
 343                 return -1; /* Required */
 344         chdesc->parent = config_setting_get_string(setting);
 345
 346         ret = snprintf(configstr, maxconfig, "channels.[%d].description", index);
 347         setting = config_lookup(&configuration, configstr);
 348         if (ret >= maxconfig || ret < 0 || setting == NULL) /* Optional */
 349                 chdesc->description = NULL;
 350         else
 351                 chdesc->description = config_setting_get_string(setting);
 352
 353         ret = snprintf(configstr, maxconfig, "channels.[%d].password", index);
 354         setting = config_lookup(&configuration, configstr);
 355         if (ret >= maxconfig || ret < 0 || setting == NULL) /* Optional */
 356                 chdesc->password = NULL;
 357         else
 358                 chdesc->password = config_setting_get_string(setting);
 359
 360         ret = snprintf(configstr, maxconfig, "channels.[%d].noenter", index);
 361         setting = config_lookup(&configuration, configstr);
 362         if (ret >= maxconfig || ret < 0 || setting == NULL) /* Optional */
 363                 chdesc->noenter = false;
 364         else
 365                 chdesc->noenter = config_setting_get_bool(setting);
 366
 367         ret = snprintf(configstr, maxconfig, "channels.[%d].silent", index);
 368         setting = config_lookup(&configuration, configstr);
 369         if (ret >= maxconfig || ret < 0 || setting == NULL) /* Optional */
 370                 chdesc->silent = false;
 371         else
 372                 chdesc->silent = config_setting_get_bool(setting);
 373
 374         ret = snprintf(configstr, maxconfig, "channels.[%d].position", index);
 375         setting = config_lookup(&configuration, configstr);
 376         if (ret >= maxconfig || ret < 0 || setting == NULL) /* Optional */
 377                 chdesc->position = 0;
 378         else
 379                 chdesc->position = config_setting_get_int(setting);
 380
 381         return 0;
 382 }
 383
 384 int Conf_getNextChannelLink(conf_channel_link_t *chlink, int index)
 385 {
 386         config_setting_t *setting = NULL;
 387         int maxconfig = 64, ret = 0;
 388         char configstr[maxconfig];
 389
 390         ret = snprintf(configstr, maxconfig, "channel_links.[%d].source", index);
 391         setting = config_lookup(&configuration, configstr);
 392         if (ret >= maxconfig || ret < 0 || setting == NULL)
 393                 return -1;
 394         chlink->source = config_setting_get_string(setting);
 395
 396         ret = snprintf(configstr, maxconfig, "channel_links.[%d].destination", index);
 397         setting = config_lookup(&configuration, configstr);
 398         if (ret >= maxconfig || ret < 0 || setting == NULL)
 399                 return -1;
 400         chlink->destination = config_setting_get_string(setting);
 401
 402         return 0;
 403 }