loadparm.c

   1 /* This is based on loadparm.c from Samba, written by Andrew Tridgell
   2    and Karl Auer */
   3
   4 /*
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20 /* some fixes
  21  *
  22  * Copyright (C) 2001, 2002 Martin Pool <mbp@samba.org>
  23  */
  24
  25 /*
  26  *  Load parameters.
  27  *
  28  *  This module provides suitable callback functions for the params
  29  *  module. It builds the internal table of service details which is
  30  *  then used by the rest of the server.
  31  *
  32  * To add a parameter:
  33  *
  34  * 1) add it to the global or service structure definition
  35  * 2) add it to the parm_table
  36  * 3) add it to the list of available functions (eg: using FN_GLOBAL_STRING())
  37  * 4) If it's a global then initialise it in init_globals. If a local
  38  *    (ie. service) parameter then initialise it in the sDefault structure
  39  *
  40  *
  41  * Notes:
  42  *   The configuration file is processed sequentially for speed. It is NOT
  43  *   accessed randomly as happens in 'real' Windows. For this reason, there
  44  *   is a fair bit of sequence-dependent code here - ie., code which assumes
  45  *   that certain things happen before others. In particular, the code which
  46  *   happens at the boundary between sections is delicately poised, so be
  47  *   careful!
  48  *
  49  */
  50
  51 /* TODO: Parameter to set debug level on server. */
  52
  53 #include "rsync.h"
  54 #define PTR_DIFF(p1,p2) ((ptrdiff_t)(((char *)(p1)) - (char *)(p2)))
  55 #define strequal(a,b) (strcasecmp(a,b)==0)
  56 #define BOOLSTR(b) ((b) ? "Yes" : "No")
  57 typedef char pstring[1024];
  58 #define pstrcpy(a,b) strlcpy(a,b,sizeof(pstring))
  59
  60 #ifndef LOG_DAEMON
  61 #define LOG_DAEMON 0
  62 #endif
  63
  64 /* the following are used by loadparm for option lists */
  65 typedef enum
  66 {
  67         P_BOOL,P_BOOLREV,P_CHAR,P_INTEGER,P_OCTAL,
  68         P_PATH,P_STRING,P_GSTRING,P_ENUM,P_SEP
  69 } parm_type;
  70
  71 typedef enum
  72 {
  73         P_LOCAL,P_GLOBAL,P_SEPARATOR,P_NONE
  74 } parm_class;
  75
  76 struct enum_list {
  77         int value;
  78         char *name;
  79 };
  80
  81 struct parm_struct
  82 {
  83         char *label;
  84         parm_type type;
  85         parm_class class;
  86         void *ptr;
  87         struct enum_list *enum_list;
  88         unsigned flags;
  89 };
  90
  91 #ifndef GLOBAL_NAME
  92 #define GLOBAL_NAME "global"
  93 #endif
  94
  95 /* some helpful bits */
  96 #define pSERVICE(i) ServicePtrs[i]
  97 #define iSERVICE(i) (*pSERVICE(i))
  98 #define LP_SNUM_OK(iService) (((iService) >= 0) && ((iService) < iNumServices))
  99
 100 /*
 101  * This structure describes global (ie., server-wide) parameters.
 102  */
 103 typedef struct
 104 {
 105         char *bind_address;
 106         char *motd_file;
 107         char *pid_file;
 108         char *socket_options;
 109
 110         int rsync_port;
 111 } global;
 112
 113 static global Globals;
 114
 115
 116 /*
 117  * This structure describes a single service.  Their order must match the
 118  * initializers below, which you can accomplish by keeping each sub-section
 119  * sorted.  (e.g. in vim, just visually select each subsection and use !sort.)
 120  */
 121 typedef struct
 122 {
 123         char *auth_users;
 124         char *comment;
 125         char *dont_compress;
 126         char *exclude;
 127         char *exclude_from;
 128         char *filter;
 129         char *gid;
 130         char *hosts_allow;
 131         char *hosts_deny;
 132         char *include;
 133         char *include_from;
 134         char *incoming_chmod;
 135         char *lock_file;
 136         char *log_file;
 137         char *log_format;
 138         char *name;
 139         char *outgoing_chmod;
 140         char *path;
 141         char *postxfer_exec;
 142         char *prexfer_exec;
 143         char *refuse_options;
 144         char *secrets_file;
 145         char *temp_dir;
 146         char *uid;
 147
 148         int max_connections;
 149         int max_verbosity;
 150         int syslog_facility;
 151         int timeout;
 152
 153         BOOL ignore_errors;
 154         BOOL ignore_nonreadable;
 155         BOOL list;
 156         BOOL munge_symlinks;
 157         BOOL read_only;
 158         BOOL strict_modes;
 159         BOOL transfer_logging;
 160         BOOL use_chroot;
 161         BOOL write_only;
 162 } service;
 163
 164
 165 /* This is a default service used to prime a services structure.  In order
 166  * to make these easy to keep sorted in the same way as the variables
 167  * above, use the variable name in the leading comment, including a
 168  * trailing ';' (to avoid a sorting problem with trailing digits). */
 169 static service sDefault =
 170 {
 171  /* auth_users; */              NULL,
 172  /* comment; */                 NULL,
 173  /* dont_compress; */           "*.gz *.tgz *.zip *.z *.rpm *.deb *.iso *.bz2 *.tbz",
 174  /* exclude; */                 NULL,
 175  /* exclude_from; */            NULL,
 176  /* filter; */                  NULL,
 177  /* gid; */                     NOBODY_GROUP,
 178  /* hosts_allow; */             NULL,
 179  /* hosts_deny; */              NULL,
 180  /* include; */                 NULL,
 181  /* include_from; */            NULL,
 182  /* incoming_chmod; */          NULL,
 183  /* lock_file; */               DEFAULT_LOCK_FILE,
 184  /* log_file; */                NULL,
 185  /* log_format; */              "%o %h [%a] %m (%u) %f %l",
 186  /* name; */                    NULL,
 187  /* outgoing_chmod; */          NULL,
 188  /* path; */                    NULL,
 189  /* postxfer_exec; */           NULL,
 190  /* prexfer_exec; */            NULL,
 191  /* refuse_options; */          NULL,
 192  /* secrets_file; */            NULL,
 193  /* temp_dir; */                NULL,
 194  /* uid; */                     NOBODY_USER,
 195
 196  /* max_connections; */         0,
 197  /* max_verbosity; */           1,
 198  /* syslog_facility; */         LOG_DAEMON,
 199  /* timeout; */                 0,
 200
 201  /* ignore_errors; */           False,
 202  /* ignore_nonreadable; */      False,
 203  /* list; */                    True,
 204  /* munge_symlinks; */          False,
 205  /* read_only; */               True,
 206  /* strict_modes; */            True,
 207  /* transfer_logging; */        False,
 208  /* use_chroot; */              True,
 209  /* write_only; */              False,
 210 };
 211
 212
 213
 214 /* local variables */
 215 static service **ServicePtrs = NULL;
 216 static int iNumServices = 0;
 217 static int iServiceIndex = 0;
 218 static BOOL bInGlobalSection = True;
 219
 220 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
 221
 222 static struct enum_list enum_facilities[] = {
 223 #ifdef LOG_AUTH
 224         { LOG_AUTH, "auth" },
 225 #endif
 226 #ifdef LOG_AUTHPRIV
 227         { LOG_AUTHPRIV, "authpriv" },
 228 #endif
 229 #ifdef LOG_CRON
 230         { LOG_CRON, "cron" },
 231 #endif
 232 #ifdef LOG_DAEMON
 233         { LOG_DAEMON, "daemon" },
 234 #endif
 235 #ifdef LOG_FTP
 236         { LOG_FTP, "ftp" },
 237 #endif
 238 #ifdef LOG_KERN
 239         { LOG_KERN, "kern" },
 240 #endif
 241 #ifdef LOG_LPR
 242         { LOG_LPR, "lpr" },
 243 #endif
 244 #ifdef LOG_MAIL
 245         { LOG_MAIL, "mail" },
 246 #endif
 247 #ifdef LOG_NEWS
 248         { LOG_NEWS, "news" },
 249 #endif
 250 #ifdef LOG_AUTH
 251         { LOG_AUTH, "security" },
 252 #endif
 253 #ifdef LOG_SYSLOG
 254         { LOG_SYSLOG, "syslog" },
 255 #endif
 256 #ifdef LOG_USER
 257         { LOG_USER, "user" },
 258 #endif
 259 #ifdef LOG_UUCP
 260         { LOG_UUCP, "uucp" },
 261 #endif
 262 #ifdef LOG_LOCAL0
 263         { LOG_LOCAL0, "local0" },
 264 #endif
 265 #ifdef LOG_LOCAL1
 266         { LOG_LOCAL1, "local1" },
 267 #endif
 268 #ifdef LOG_LOCAL2
 269         { LOG_LOCAL2, "local2" },
 270 #endif
 271 #ifdef LOG_LOCAL3
 272         { LOG_LOCAL3, "local3" },
 273 #endif
 274 #ifdef LOG_LOCAL4
 275         { LOG_LOCAL4, "local4" },
 276 #endif
 277 #ifdef LOG_LOCAL5
 278         { LOG_LOCAL5, "local5" },
 279 #endif
 280 #ifdef LOG_LOCAL6
 281         { LOG_LOCAL6, "local6" },
 282 #endif
 283 #ifdef LOG_LOCAL7
 284         { LOG_LOCAL7, "local7" },
 285 #endif
 286         { -1, NULL }};
 287
 288
 289 /* note that we do not initialise the defaults union - it is not allowed in ANSI C */
 290 static struct parm_struct parm_table[] =
 291 {
 292  {"address",           P_STRING, P_GLOBAL,&Globals.bind_address,       NULL,0},
 293  {"motd file",         P_STRING, P_GLOBAL,&Globals.motd_file,          NULL,0},
 294  {"pid file",          P_STRING, P_GLOBAL,&Globals.pid_file,           NULL,0},
 295  {"port",              P_INTEGER,P_GLOBAL,&Globals.rsync_port,         NULL,0},
 296  {"socket options",    P_STRING, P_GLOBAL,&Globals.socket_options,     NULL,0},
 297
 298  {"auth users",        P_STRING, P_LOCAL, &sDefault.auth_users,        NULL,0},
 299  {"comment",           P_STRING, P_LOCAL, &sDefault.comment,           NULL,0},
 300  {"dont compress",     P_STRING, P_LOCAL, &sDefault.dont_compress,     NULL,0},
 301  {"exclude from",      P_STRING, P_LOCAL, &sDefault.exclude_from,      NULL,0},
 302  {"exclude",           P_STRING, P_LOCAL, &sDefault.exclude,           NULL,0},
 303  {"filter",            P_STRING, P_LOCAL, &sDefault.filter,            NULL,0},
 304  {"gid",               P_STRING, P_LOCAL, &sDefault.gid,               NULL,0},
 305  {"hosts allow",       P_STRING, P_LOCAL, &sDefault.hosts_allow,       NULL,0},
 306  {"hosts deny",        P_STRING, P_LOCAL, &sDefault.hosts_deny,        NULL,0},
 307  {"ignore errors",     P_BOOL,   P_LOCAL, &sDefault.ignore_errors,     NULL,0},
 308  {"ignore nonreadable",P_BOOL,   P_LOCAL, &sDefault.ignore_nonreadable,NULL,0},
 309  {"include from",      P_STRING, P_LOCAL, &sDefault.include_from,      NULL,0},
 310  {"include",           P_STRING, P_LOCAL, &sDefault.include,           NULL,0},
 311  {"incoming chmod",    P_STRING, P_LOCAL, &sDefault.incoming_chmod,    NULL,0},
 312  {"list",              P_BOOL,   P_LOCAL, &sDefault.list,              NULL,0},
 313  {"lock file",         P_STRING, P_LOCAL, &sDefault.lock_file,         NULL,0},
 314  {"log file",          P_STRING, P_LOCAL, &sDefault.log_file,          NULL,0},
 315  {"log format",        P_STRING, P_LOCAL, &sDefault.log_format,        NULL,0},
 316  {"max connections",   P_INTEGER,P_LOCAL, &sDefault.max_connections,   NULL,0},
 317  {"max verbosity",     P_INTEGER,P_LOCAL, &sDefault.max_verbosity,     NULL,0},
 318  {"munge symlinks",    P_BOOL,   P_LOCAL, &sDefault.munge_symlinks,    NULL,0},
 319  {"name",              P_STRING, P_LOCAL, &sDefault.name,              NULL,0},
 320  {"outgoing chmod",    P_STRING, P_LOCAL, &sDefault.outgoing_chmod,    NULL,0},
 321  {"path",              P_PATH,   P_LOCAL, &sDefault.path,              NULL,0},
 322 #ifdef HAVE_PUTENV
 323  {"post-xfer exec",    P_STRING, P_LOCAL, &sDefault.postxfer_exec,     NULL,0},
 324  {"pre-xfer exec",     P_STRING, P_LOCAL, &sDefault.prexfer_exec,      NULL,0},
 325 #endif
 326  {"read only",         P_BOOL,   P_LOCAL, &sDefault.read_only,         NULL,0},
 327  {"refuse options",    P_STRING, P_LOCAL, &sDefault.refuse_options,    NULL,0},
 328  {"secrets file",      P_STRING, P_LOCAL, &sDefault.secrets_file,      NULL,0},
 329  {"strict modes",      P_BOOL,   P_LOCAL, &sDefault.strict_modes,      NULL,0},
 330  {"syslog facility",   P_ENUM,   P_LOCAL, &sDefault.syslog_facility,enum_facilities,0},
 331  {"temp dir",          P_PATH,   P_LOCAL, &sDefault.temp_dir,          NULL,0},
 332  {"timeout",           P_INTEGER,P_LOCAL, &sDefault.timeout,           NULL,0},
 333  {"transfer logging",  P_BOOL,   P_LOCAL, &sDefault.transfer_logging,  NULL,0},
 334  {"uid",               P_STRING, P_LOCAL, &sDefault.uid,               NULL,0},
 335  {"use chroot",        P_BOOL,   P_LOCAL, &sDefault.use_chroot,        NULL,0},
 336  {"write only",        P_BOOL,   P_LOCAL, &sDefault.write_only,        NULL,0},
 337  {NULL,                P_BOOL,   P_NONE,  NULL,                        NULL,0}
 338 };
 339
 340
 341 /***************************************************************************
 342 Initialise the global parameter structure.
 343 ***************************************************************************/
 344 static void init_globals(void)
 345 {
 346         memset(&Globals, 0, sizeof Globals);
 347 }
 348
 349 /***************************************************************************
 350 Initialise the sDefault parameter structure.
 351 ***************************************************************************/
 352 static void init_locals(void)
 353 {
 354 }
 355
 356
 357 /*
 358    In this section all the functions that are used to access the
 359    parameters from the rest of the program are defined
 360 */
 361
 362 #define FN_GLOBAL_STRING(fn_name,ptr) \
 363  char *fn_name(void) {return(*(char **)(ptr) ? *(char **)(ptr) : "");}
 364 #define FN_GLOBAL_BOOL(fn_name,ptr) \
 365  BOOL fn_name(void) {return(*(BOOL *)(ptr));}
 366 #define FN_GLOBAL_CHAR(fn_name,ptr) \
 367  char fn_name(void) {return(*(char *)(ptr));}
 368 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
 369  int fn_name(void) {return(*(int *)(ptr));}
 370
 371 #define FN_LOCAL_STRING(fn_name,val) \
 372  char *fn_name(int i) {return((LP_SNUM_OK(i)&&pSERVICE(i)->val)?pSERVICE(i)->val : (sDefault.val?sDefault.val:""));}
 373 #define FN_LOCAL_BOOL(fn_name,val) \
 374  BOOL fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
 375 #define FN_LOCAL_CHAR(fn_name,val) \
 376  char fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
 377 #define FN_LOCAL_INTEGER(fn_name,val) \
 378  int fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
 379
 380
 381 FN_GLOBAL_STRING(lp_bind_address, &Globals.bind_address)
 382 FN_GLOBAL_STRING(lp_motd_file, &Globals.motd_file)
 383 FN_GLOBAL_STRING(lp_pid_file, &Globals.pid_file)
 384 FN_GLOBAL_STRING(lp_socket_options, &Globals.socket_options)
 385
 386 FN_GLOBAL_INTEGER(lp_rsync_port, &Globals.rsync_port)
 387
 388 FN_LOCAL_STRING(lp_auth_users, auth_users)
 389 FN_LOCAL_STRING(lp_comment, comment)
 390 FN_LOCAL_STRING(lp_dont_compress, dont_compress)
 391 FN_LOCAL_STRING(lp_exclude, exclude)
 392 FN_LOCAL_STRING(lp_exclude_from, exclude_from)
 393 FN_LOCAL_STRING(lp_filter, filter)
 394 FN_LOCAL_STRING(lp_gid, gid)
 395 FN_LOCAL_STRING(lp_hosts_allow, hosts_allow)
 396 FN_LOCAL_STRING(lp_hosts_deny, hosts_deny)
 397 FN_LOCAL_STRING(lp_include, include)
 398 FN_LOCAL_STRING(lp_include_from, include_from)
 399 FN_LOCAL_STRING(lp_incoming_chmod, incoming_chmod)
 400 FN_LOCAL_STRING(lp_lock_file, lock_file)
 401 FN_LOCAL_STRING(lp_log_file, log_file)
 402 FN_LOCAL_STRING(lp_log_format, log_format)
 403 FN_LOCAL_STRING(lp_name, name)
 404 FN_LOCAL_STRING(lp_outgoing_chmod, outgoing_chmod)
 405 FN_LOCAL_STRING(lp_path, path)
 406 FN_LOCAL_STRING(lp_postxfer_exec, postxfer_exec)
 407 FN_LOCAL_STRING(lp_prexfer_exec, prexfer_exec)
 408 FN_LOCAL_STRING(lp_refuse_options, refuse_options)
 409 FN_LOCAL_STRING(lp_secrets_file, secrets_file)
 410 FN_LOCAL_INTEGER(lp_syslog_facility, syslog_facility)
 411 FN_LOCAL_STRING(lp_temp_dir, temp_dir)
 412 FN_LOCAL_STRING(lp_uid, uid)
 413
 414 FN_LOCAL_INTEGER(lp_max_connections, max_connections)
 415 FN_LOCAL_INTEGER(lp_max_verbosity, max_verbosity)
 416 FN_LOCAL_INTEGER(lp_timeout, timeout)
 417
 418 FN_LOCAL_BOOL(lp_ignore_errors, ignore_errors)
 419 FN_LOCAL_BOOL(lp_ignore_nonreadable, ignore_nonreadable)
 420 FN_LOCAL_BOOL(lp_list, list)
 421 FN_LOCAL_BOOL(lp_munge_symlinks, munge_symlinks)
 422 FN_LOCAL_BOOL(lp_read_only, read_only)
 423 FN_LOCAL_BOOL(lp_strict_modes, strict_modes)
 424 FN_LOCAL_BOOL(lp_transfer_logging, transfer_logging)
 425 FN_LOCAL_BOOL(lp_use_chroot, use_chroot)
 426 FN_LOCAL_BOOL(lp_write_only, write_only)
 427
 428 /* local prototypes */
 429 static int    strwicmp(char *psz1, char *psz2);
 430 static int    map_parameter(char *parmname);
 431 static BOOL   set_boolean(BOOL *pb, char *parmvalue);
 432 static int    getservicebyname(char *name, service *pserviceDest);
 433 static void   copy_service(service *pserviceDest, service *pserviceSource);
 434 static BOOL   do_parameter(char *parmname, char *parmvalue);
 435 static BOOL   do_section(char *sectionname);
 436
 437
 438 /***************************************************************************
 439 initialise a service to the defaults
 440 ***************************************************************************/
 441 static void init_service(service *pservice)
 442 {
 443         memset((char *)pservice,0,sizeof(service));
 444         copy_service(pservice,&sDefault);
 445 }
 446
 447
 448 /**
 449  * Assign a copy of @p v to @p *s.  Handles NULL strings.  @p *v must
 450  * be initialized when this is called, either to NULL or a malloc'd
 451  * string.
 452  *
 453  * @fixme There is a small leak here in that sometimes the existing
 454  * value will be dynamically allocated, and the old copy is lost.
 455  * However, we can't always deallocate the old value, because in the
 456  * case of sDefault, it points to a static string.  It would be nice
 457  * to have either all-strdup'd values, or to never need to free
 458  * memory.
 459  **/
 460 static void string_set(char **s, const char *v)
 461 {
 462         if (!v) {
 463                 *s = NULL;
 464                 return;
 465         }
 466         *s = strdup(v);
 467         if (!*s)
 468                 exit_cleanup(RERR_MALLOC);
 469 }
 470
 471
 472 /***************************************************************************
 473 add a new service to the services array initialising it with the given
 474 service
 475 ***************************************************************************/
 476 static int add_a_service(service *pservice, char *name)
 477 {
 478   int i;
 479   service tservice;
 480   int num_to_alloc = iNumServices+1;
 481
 482   tservice = *pservice;
 483
 484   /* it might already exist */
 485   if (name)
 486     {
 487       i = getservicebyname(name,NULL);
 488       if (i >= 0)
 489         return(i);
 490     }
 491
 492   i = iNumServices;
 493
 494   ServicePtrs = realloc_array(ServicePtrs, service *, num_to_alloc);
 495
 496   if (ServicePtrs)
 497           pSERVICE(iNumServices) = new(service);
 498
 499   if (!ServicePtrs || !pSERVICE(iNumServices))
 500           return(-1);
 501
 502   iNumServices++;
 503
 504   init_service(pSERVICE(i));
 505   copy_service(pSERVICE(i),&tservice);
 506   if (name)
 507     string_set(&iSERVICE(i).name,name);
 508
 509   return(i);
 510 }
 511
 512 /***************************************************************************
 513 Do a case-insensitive, whitespace-ignoring string compare.
 514 ***************************************************************************/
 515 static int strwicmp(char *psz1, char *psz2)
 516 {
 517    /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
 518    /* appropriate value. */
 519    if (psz1 == psz2)
 520       return (0);
 521    else
 522       if (psz1 == NULL)
 523          return (-1);
 524       else
 525           if (psz2 == NULL)
 526               return (1);
 527
 528    /* sync the strings on first non-whitespace */
 529    while (1)
 530    {
 531       while (isspace(* (unsigned char *) psz1))
 532          psz1++;
 533       while (isspace(* (unsigned char *) psz2))
 534          psz2++;
 535       if (toupper(* (unsigned char *) psz1) != toupper(* (unsigned char *) psz2)
 536           || *psz1 == '\0' || *psz2 == '\0')
 537          break;
 538       psz1++;
 539       psz2++;
 540    }
 541    return (*psz1 - *psz2);
 542 }
 543
 544 /***************************************************************************
 545 Map a parameter's string representation to something we can use.
 546 Returns False if the parameter string is not recognised, else TRUE.
 547 ***************************************************************************/
 548 static int map_parameter(char *parmname)
 549 {
 550    int iIndex;
 551
 552    if (*parmname == '-')
 553      return(-1);
 554
 555    for (iIndex = 0; parm_table[iIndex].label; iIndex++)
 556       if (strwicmp(parm_table[iIndex].label, parmname) == 0)
 557          return(iIndex);
 558
 559    rprintf(FERROR, "Unknown Parameter encountered: \"%s\"\n", parmname);
 560    return(-1);
 561 }
 562
 563
 564 /***************************************************************************
 565 Set a boolean variable from the text value stored in the passed string.
 566 Returns True in success, False if the passed string does not correctly
 567 represent a boolean.
 568 ***************************************************************************/
 569 static BOOL set_boolean(BOOL *pb, char *parmvalue)
 570 {
 571    BOOL bRetval;
 572
 573    bRetval = True;
 574    if (strwicmp(parmvalue, "yes") == 0 ||
 575        strwicmp(parmvalue, "true") == 0 ||
 576        strwicmp(parmvalue, "1") == 0)
 577       *pb = True;
 578    else
 579       if (strwicmp(parmvalue, "no") == 0 ||
 580           strwicmp(parmvalue, "False") == 0 ||
 581           strwicmp(parmvalue, "0") == 0)
 582          *pb = False;
 583       else
 584       {
 585          rprintf(FERROR, "Badly formed boolean in configuration file: \"%s\".\n",
 586                parmvalue);
 587          bRetval = False;
 588       }
 589    return (bRetval);
 590 }
 591
 592 /***************************************************************************
 593 Find a service by name. Otherwise works like get_service.
 594 ***************************************************************************/
 595 static int getservicebyname(char *name, service *pserviceDest)
 596 {
 597    int iService;
 598
 599    for (iService = iNumServices - 1; iService >= 0; iService--)
 600       if (strwicmp(iSERVICE(iService).name, name) == 0)
 601       {
 602          if (pserviceDest != NULL)
 603            copy_service(pserviceDest, pSERVICE(iService));
 604          break;
 605       }
 606
 607    return (iService);
 608 }
 609
 610
 611
 612 /***************************************************************************
 613 Copy a service structure to another
 614
 615 ***************************************************************************/
 616 static void copy_service(service *pserviceDest,
 617                          service *pserviceSource)
 618 {
 619   int i;
 620
 621   for (i=0;parm_table[i].label;i++)
 622     if (parm_table[i].ptr && parm_table[i].class == P_LOCAL) {
 623         void *def_ptr = parm_table[i].ptr;
 624         void *src_ptr =
 625           ((char *)pserviceSource) + PTR_DIFF(def_ptr,&sDefault);
 626         void *dest_ptr =
 627           ((char *)pserviceDest) + PTR_DIFF(def_ptr,&sDefault);
 628
 629         switch (parm_table[i].type)
 630           {
 631           case P_BOOL:
 632           case P_BOOLREV:
 633             *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
 634             break;
 635
 636           case P_INTEGER:
 637           case P_ENUM:
 638           case P_OCTAL:
 639             *(int *)dest_ptr = *(int *)src_ptr;
 640             break;
 641
 642           case P_CHAR:
 643             *(char *)dest_ptr = *(char *)src_ptr;
 644             break;
 645
 646           case P_PATH:
 647           case P_STRING:
 648             string_set(dest_ptr,*(char **)src_ptr);
 649             break;
 650
 651           default:
 652             break;
 653           }
 654       }
 655 }
 656
 657
 658 /***************************************************************************
 659 Process a parameter for a particular service number. If snum < 0
 660 then assume we are in the globals
 661 ***************************************************************************/
 662 static BOOL lp_do_parameter(int snum, char *parmname, char *parmvalue)
 663 {
 664    int parmnum, i;
 665    void *parm_ptr=NULL; /* where we are going to store the result */
 666    void *def_ptr=NULL;
 667    char *cp;
 668
 669    parmnum = map_parameter(parmname);
 670
 671    if (parmnum < 0)
 672      {
 673        rprintf(FERROR, "IGNORING unknown parameter \"%s\"\n", parmname);
 674        return(True);
 675      }
 676
 677    def_ptr = parm_table[parmnum].ptr;
 678
 679    /* we might point at a service, the default service or a global */
 680    if (snum < 0) {
 681      parm_ptr = def_ptr;
 682    } else {
 683        if (parm_table[parmnum].class == P_GLOBAL) {
 684            rprintf(FERROR, "Global parameter %s found in service section!\n",parmname);
 685            return(True);
 686          }
 687        parm_ptr = ((char *)pSERVICE(snum)) + PTR_DIFF(def_ptr,&sDefault);
 688    }
 689
 690    /* now switch on the type of variable it is */
 691    switch (parm_table[parmnum].type)
 692      {
 693      case P_BOOL:
 694        set_boolean(parm_ptr,parmvalue);
 695        break;
 696
 697      case P_BOOLREV:
 698        set_boolean(parm_ptr,parmvalue);
 699        *(BOOL *)parm_ptr = ! *(BOOL *)parm_ptr;
 700        break;
 701
 702      case P_INTEGER:
 703        *(int *)parm_ptr = atoi(parmvalue);
 704        break;
 705
 706      case P_CHAR:
 707        *(char *)parm_ptr = *parmvalue;
 708        break;
 709
 710      case P_OCTAL:
 711        sscanf(parmvalue,"%o",(int *)parm_ptr);
 712        break;
 713
 714      case P_PATH:
 715        string_set(parm_ptr,parmvalue);
 716        if ((cp = *(char**)parm_ptr) != NULL) {
 717            int len = strlen(cp);
 718            while (len > 1 && cp[len-1] == '/') len--;
 719            cp[len] = '\0';
 720        }
 721        break;
 722
 723      case P_STRING:
 724        string_set(parm_ptr,parmvalue);
 725        break;
 726
 727      case P_GSTRING:
 728        strlcpy((char *)parm_ptr,parmvalue,sizeof(pstring));
 729        break;
 730
 731      case P_ENUM:
 732              for (i=0;parm_table[parmnum].enum_list[i].name;i++) {
 733                      if (strequal(parmvalue, parm_table[parmnum].enum_list[i].name)) {
 734                              *(int *)parm_ptr = parm_table[parmnum].enum_list[i].value;
 735                              break;
 736                      }
 737              }
 738              if (!parm_table[parmnum].enum_list[i].name) {
 739                      if (atoi(parmvalue) > 0)
 740                              *(int *)parm_ptr = atoi(parmvalue);
 741              }
 742              break;
 743      case P_SEP:
 744              break;
 745      }
 746
 747    return(True);
 748 }
 749
 750 /***************************************************************************
 751 Process a parameter.
 752 ***************************************************************************/
 753 static BOOL do_parameter(char *parmname, char *parmvalue)
 754 {
 755    return lp_do_parameter(bInGlobalSection?-2:iServiceIndex, parmname, parmvalue);
 756 }
 757
 758 /***************************************************************************
 759 Process a new section (service). At this stage all sections are services.
 760 Later we'll have special sections that permit server parameters to be set.
 761 Returns True on success, False on failure.
 762 ***************************************************************************/
 763 static BOOL do_section(char *sectionname)
 764 {
 765    BOOL bRetval;
 766    BOOL isglobal = (strwicmp(sectionname, GLOBAL_NAME) == 0);
 767    bRetval = False;
 768
 769    /* if we were in a global section then do the local inits */
 770    if (bInGlobalSection && !isglobal)
 771      init_locals();
 772
 773    /* if we've just struck a global section, note the fact. */
 774    bInGlobalSection = isglobal;
 775
 776    /* check for multiple global sections */
 777    if (bInGlobalSection)
 778    {
 779      return(True);
 780    }
 781
 782    /* if we have a current service, tidy it up before moving on */
 783    bRetval = True;
 784
 785    if (iServiceIndex >= 0)
 786      bRetval = True;
 787
 788    /* if all is still well, move to the next record in the services array */
 789    if (bRetval)
 790      {
 791        /* We put this here to avoid an odd message order if messages are */
 792        /* issued by the post-processing of a previous section. */
 793
 794        if ((iServiceIndex=add_a_service(&sDefault,sectionname)) < 0)
 795          {
 796            rprintf(FERROR,"Failed to add a new service\n");
 797            return(False);
 798          }
 799      }
 800
 801    return (bRetval);
 802 }
 803
 804
 805 /***************************************************************************
 806 Load the services array from the services file. Return True on success,
 807 False on failure.
 808 ***************************************************************************/
 809 BOOL lp_load(char *pszFname, int globals_only)
 810 {
 811         extern int am_server;
 812         extern int am_root;
 813         pstring n2;
 814         BOOL bRetval;
 815
 816         bRetval = False;
 817
 818         bInGlobalSection = True;
 819
 820         init_globals();
 821
 822         if (pszFname)
 823             pstrcpy(n2,pszFname);
 824         else if (am_server && !am_root)
 825             pstrcpy(n2,RSYNCD_USERCONF);
 826         else
 827             pstrcpy(n2,RSYNCD_SYSCONF);
 828
 829         /* We get sections first, so have to start 'behind' to make up */
 830         iServiceIndex = -1;
 831         bRetval = pm_process(n2, globals_only?NULL:do_section, do_parameter);
 832
 833         return (bRetval);
 834 }
 835
 836
 837 /***************************************************************************
 838 return the max number of services
 839 ***************************************************************************/
 840 int lp_numservices(void)
 841 {
 842   return(iNumServices);
 843 }
 844
 845 /***************************************************************************
 846 Return the number of the service with the given name, or -1 if it doesn't
 847 exist. Note that this is a DIFFERENT ANIMAL from the internal function
 848 getservicebyname()! This works ONLY if all services have been loaded, and
 849 does not copy the found service.
 850 ***************************************************************************/
 851 int lp_number(char *name)
 852 {
 853    int iService;
 854
 855    for (iService = iNumServices - 1; iService >= 0; iService--)
 856       if (strcmp(lp_name(iService), name) == 0)
 857          break;
 858
 859    return (iService);
 860 }
 861