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 read_only;
 157         BOOL strict_modes;
 158         BOOL transfer_logging;
 159         BOOL use_chroot;
 160         BOOL write_only;
 161 } service;
 162
 163
 164 /* This is a default service used to prime a services structure.  In order
 165  * to make these easy to keep sorted in the same way as the variables
 166  * above, use the variable name in the leading comment, including a
 167  * trailing ';' (to avoid a sorting problem with trailing digits). */
 168 static service sDefault =
 169 {
 170  /* auth_users; */              NULL,
 171  /* comment; */                 NULL,
 172  /* dont_compress; */           "*.gz *.tgz *.zip *.z *.rpm *.deb *.iso *.bz2 *.tbz",
 173  /* exclude; */                 NULL,
 174  /* exclude_from; */            NULL,
 175  /* filter; */                  NULL,
 176  /* gid; */                     NOBODY_GROUP,
 177  /* hosts_allow; */             NULL,
 178  /* hosts_deny; */              NULL,
 179  /* include; */                 NULL,
 180  /* include_from; */            NULL,
 181  /* incoming_chmod; */          NULL,
 182  /* lock_file; */               DEFAULT_LOCK_FILE,
 183  /* log_file; */                NULL,
 184  /* log_format; */              "%o %h [%a] %m (%u) %f %l",
 185  /* name; */                    NULL,
 186  /* outgoing_chmod; */          NULL,
 187  /* path; */                    NULL,
 188  /* postxfer_exec; */           NULL,
 189  /* prexfer_exec; */            NULL,
 190  /* refuse_options; */          NULL,
 191  /* secrets_file; */            NULL,
 192  /* temp_dir; */                NULL,
 193  /* uid; */                     NOBODY_USER,
 194
 195  /* max_connections; */         0,
 196  /* max_verbosity; */           1,
 197  /* syslog_facility; */         LOG_DAEMON,
 198  /* timeout; */                 0,
 199
 200  /* ignore_errors; */           False,
 201  /* ignore_nonreadable; */      False,
 202  /* list; */                    True,
 203  /* read_only; */               True,
 204  /* strict_modes; */            True,
 205  /* transfer_logging; */        False,
 206  /* use_chroot; */              True,
 207  /* write_only; */              False,
 208 };
 209
 210
 211
 212 /* local variables */
 213 static service **ServicePtrs = NULL;
 214 static int iNumServices = 0;
 215 static int iServiceIndex = 0;
 216 static BOOL bInGlobalSection = True;
 217
 218 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
 219
 220 static struct enum_list enum_facilities[] = {
 221 #ifdef LOG_AUTH
 222         { LOG_AUTH, "auth" },
 223 #endif
 224 #ifdef LOG_AUTHPRIV
 225         { LOG_AUTHPRIV, "authpriv" },
 226 #endif
 227 #ifdef LOG_CRON
 228         { LOG_CRON, "cron" },
 229 #endif
 230 #ifdef LOG_DAEMON
 231         { LOG_DAEMON, "daemon" },
 232 #endif
 233 #ifdef LOG_FTP
 234         { LOG_FTP, "ftp" },
 235 #endif
 236 #ifdef LOG_KERN
 237         { LOG_KERN, "kern" },
 238 #endif
 239 #ifdef LOG_LPR
 240         { LOG_LPR, "lpr" },
 241 #endif
 242 #ifdef LOG_MAIL
 243         { LOG_MAIL, "mail" },
 244 #endif
 245 #ifdef LOG_NEWS
 246         { LOG_NEWS, "news" },
 247 #endif
 248 #ifdef LOG_AUTH
 249         { LOG_AUTH, "security" },
 250 #endif
 251 #ifdef LOG_SYSLOG
 252         { LOG_SYSLOG, "syslog" },
 253 #endif
 254 #ifdef LOG_USER
 255         { LOG_USER, "user" },
 256 #endif
 257 #ifdef LOG_UUCP
 258         { LOG_UUCP, "uucp" },
 259 #endif
 260 #ifdef LOG_LOCAL0
 261         { LOG_LOCAL0, "local0" },
 262 #endif
 263 #ifdef LOG_LOCAL1
 264         { LOG_LOCAL1, "local1" },
 265 #endif
 266 #ifdef LOG_LOCAL2
 267         { LOG_LOCAL2, "local2" },
 268 #endif
 269 #ifdef LOG_LOCAL3
 270         { LOG_LOCAL3, "local3" },
 271 #endif
 272 #ifdef LOG_LOCAL4
 273         { LOG_LOCAL4, "local4" },
 274 #endif
 275 #ifdef LOG_LOCAL5
 276         { LOG_LOCAL5, "local5" },
 277 #endif
 278 #ifdef LOG_LOCAL6
 279         { LOG_LOCAL6, "local6" },
 280 #endif
 281 #ifdef LOG_LOCAL7
 282         { LOG_LOCAL7, "local7" },
 283 #endif
 284         { -1, NULL }};
 285
 286
 287 /* note that we do not initialise the defaults union - it is not allowed in ANSI C */
 288 static struct parm_struct parm_table[] =
 289 {
 290  {"address",           P_STRING, P_GLOBAL,&Globals.bind_address,       NULL,0},
 291  {"motd file",         P_STRING, P_GLOBAL,&Globals.motd_file,          NULL,0},
 292  {"pid file",          P_STRING, P_GLOBAL,&Globals.pid_file,           NULL,0},
 293  {"port",              P_INTEGER,P_GLOBAL,&Globals.rsync_port,         NULL,0},
 294  {"socket options",    P_STRING, P_GLOBAL,&Globals.socket_options,     NULL,0},
 295
 296  {"auth users",        P_STRING, P_LOCAL, &sDefault.auth_users,        NULL,0},
 297  {"comment",           P_STRING, P_LOCAL, &sDefault.comment,           NULL,0},
 298  {"dont compress",     P_STRING, P_LOCAL, &sDefault.dont_compress,     NULL,0},
 299  {"exclude from",      P_STRING, P_LOCAL, &sDefault.exclude_from,      NULL,0},
 300  {"exclude",           P_STRING, P_LOCAL, &sDefault.exclude,           NULL,0},
 301  {"filter",            P_STRING, P_LOCAL, &sDefault.filter,            NULL,0},
 302  {"gid",               P_STRING, P_LOCAL, &sDefault.gid,               NULL,0},
 303  {"hosts allow",       P_STRING, P_LOCAL, &sDefault.hosts_allow,       NULL,0},
 304  {"hosts deny",        P_STRING, P_LOCAL, &sDefault.hosts_deny,        NULL,0},
 305  {"ignore errors",     P_BOOL,   P_LOCAL, &sDefault.ignore_errors,     NULL,0},
 306  {"ignore nonreadable",P_BOOL,   P_LOCAL, &sDefault.ignore_nonreadable,NULL,0},
 307  {"include from",      P_STRING, P_LOCAL, &sDefault.include_from,      NULL,0},
 308  {"include",           P_STRING, P_LOCAL, &sDefault.include,           NULL,0},
 309  {"incoming chmod",    P_STRING, P_LOCAL, &sDefault.incoming_chmod,    NULL,0},
 310  {"list",              P_BOOL,   P_LOCAL, &sDefault.list,              NULL,0},
 311  {"lock file",         P_STRING, P_LOCAL, &sDefault.lock_file,         NULL,0},
 312  {"log file",          P_STRING, P_LOCAL, &sDefault.log_file,          NULL,0},
 313  {"log format",        P_STRING, P_LOCAL, &sDefault.log_format,        NULL,0},
 314  {"max connections",   P_INTEGER,P_LOCAL, &sDefault.max_connections,   NULL,0},
 315  {"max verbosity",     P_INTEGER,P_LOCAL, &sDefault.max_verbosity,     NULL,0},
 316  {"name",              P_STRING, P_LOCAL, &sDefault.name,              NULL,0},
 317  {"outgoing chmod",    P_STRING, P_LOCAL, &sDefault.outgoing_chmod,    NULL,0},
 318  {"path",              P_PATH,   P_LOCAL, &sDefault.path,              NULL,0},
 319 #ifdef HAVE_PUTENV
 320  {"post-xfer exec",    P_STRING, P_LOCAL, &sDefault.postxfer_exec,     NULL,0},
 321  {"pre-xfer exec",     P_STRING, P_LOCAL, &sDefault.prexfer_exec,      NULL,0},
 322 #endif
 323  {"read only",         P_BOOL,   P_LOCAL, &sDefault.read_only,         NULL,0},
 324  {"refuse options",    P_STRING, P_LOCAL, &sDefault.refuse_options,    NULL,0},
 325  {"secrets file",      P_STRING, P_LOCAL, &sDefault.secrets_file,      NULL,0},
 326  {"strict modes",      P_BOOL,   P_LOCAL, &sDefault.strict_modes,      NULL,0},
 327  {"syslog facility",   P_ENUM,   P_LOCAL, &sDefault.syslog_facility,enum_facilities,0},
 328  {"temp dir",          P_PATH,   P_LOCAL, &sDefault.temp_dir,          NULL,0},
 329  {"timeout",           P_INTEGER,P_LOCAL, &sDefault.timeout,           NULL,0},
 330  {"transfer logging",  P_BOOL,   P_LOCAL, &sDefault.transfer_logging,  NULL,0},
 331  {"uid",               P_STRING, P_LOCAL, &sDefault.uid,               NULL,0},
 332  {"use chroot",        P_BOOL,   P_LOCAL, &sDefault.use_chroot,        NULL,0},
 333  {"write only",        P_BOOL,   P_LOCAL, &sDefault.write_only,        NULL,0},
 334  {NULL,                P_BOOL,   P_NONE,  NULL,                        NULL,0}
 335 };
 336
 337
 338 /***************************************************************************
 339 Initialise the global parameter structure.
 340 ***************************************************************************/
 341 static void init_globals(void)
 342 {
 343         memset(&Globals, 0, sizeof Globals);
 344 }
 345
 346 /***************************************************************************
 347 Initialise the sDefault parameter structure.
 348 ***************************************************************************/
 349 static void init_locals(void)
 350 {
 351 }
 352
 353
 354 /*
 355    In this section all the functions that are used to access the
 356    parameters from the rest of the program are defined
 357 */
 358
 359 #define FN_GLOBAL_STRING(fn_name,ptr) \
 360  char *fn_name(void) {return(*(char **)(ptr) ? *(char **)(ptr) : "");}
 361 #define FN_GLOBAL_BOOL(fn_name,ptr) \
 362  BOOL fn_name(void) {return(*(BOOL *)(ptr));}
 363 #define FN_GLOBAL_CHAR(fn_name,ptr) \
 364  char fn_name(void) {return(*(char *)(ptr));}
 365 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
 366  int fn_name(void) {return(*(int *)(ptr));}
 367
 368 #define FN_LOCAL_STRING(fn_name,val) \
 369  char *fn_name(int i) {return((LP_SNUM_OK(i)&&pSERVICE(i)->val)?pSERVICE(i)->val : (sDefault.val?sDefault.val:""));}
 370 #define FN_LOCAL_BOOL(fn_name,val) \
 371  BOOL fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
 372 #define FN_LOCAL_CHAR(fn_name,val) \
 373  char fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
 374 #define FN_LOCAL_INTEGER(fn_name,val) \
 375  int fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
 376
 377
 378 FN_GLOBAL_STRING(lp_bind_address, &Globals.bind_address)
 379 FN_GLOBAL_STRING(lp_motd_file, &Globals.motd_file)
 380 FN_GLOBAL_STRING(lp_pid_file, &Globals.pid_file)
 381 FN_GLOBAL_STRING(lp_socket_options, &Globals.socket_options)
 382
 383 FN_GLOBAL_INTEGER(lp_rsync_port, &Globals.rsync_port)
 384
 385 FN_LOCAL_STRING(lp_auth_users, auth_users)
 386 FN_LOCAL_STRING(lp_comment, comment)
 387 FN_LOCAL_STRING(lp_dont_compress, dont_compress)
 388 FN_LOCAL_STRING(lp_exclude, exclude)
 389 FN_LOCAL_STRING(lp_exclude_from, exclude_from)
 390 FN_LOCAL_STRING(lp_filter, filter)
 391 FN_LOCAL_STRING(lp_gid, gid)
 392 FN_LOCAL_STRING(lp_hosts_allow, hosts_allow)
 393 FN_LOCAL_STRING(lp_hosts_deny, hosts_deny)
 394 FN_LOCAL_STRING(lp_include, include)
 395 FN_LOCAL_STRING(lp_include_from, include_from)
 396 FN_LOCAL_STRING(lp_incoming_chmod, incoming_chmod)
 397 FN_LOCAL_STRING(lp_lock_file, lock_file)
 398 FN_LOCAL_STRING(lp_log_file, log_file)
 399 FN_LOCAL_STRING(lp_log_format, log_format)
 400 FN_LOCAL_STRING(lp_name, name)
 401 FN_LOCAL_STRING(lp_outgoing_chmod, outgoing_chmod)
 402 FN_LOCAL_STRING(lp_path, path)
 403 FN_LOCAL_STRING(lp_postxfer_exec, postxfer_exec)
 404 FN_LOCAL_STRING(lp_prexfer_exec, prexfer_exec)
 405 FN_LOCAL_STRING(lp_refuse_options, refuse_options)
 406 FN_LOCAL_STRING(lp_secrets_file, secrets_file)
 407 FN_LOCAL_INTEGER(lp_syslog_facility, syslog_facility)
 408 FN_LOCAL_STRING(lp_temp_dir, temp_dir)
 409 FN_LOCAL_STRING(lp_uid, uid)
 410
 411 FN_LOCAL_INTEGER(lp_max_connections, max_connections)
 412 FN_LOCAL_INTEGER(lp_max_verbosity, max_verbosity)
 413 FN_LOCAL_INTEGER(lp_timeout, timeout)
 414
 415 FN_LOCAL_BOOL(lp_ignore_errors, ignore_errors)
 416 FN_LOCAL_BOOL(lp_ignore_nonreadable, ignore_nonreadable)
 417 FN_LOCAL_BOOL(lp_list, list)
 418 FN_LOCAL_BOOL(lp_read_only, read_only)
 419 FN_LOCAL_BOOL(lp_strict_modes, strict_modes)
 420 FN_LOCAL_BOOL(lp_transfer_logging, transfer_logging)
 421 FN_LOCAL_BOOL(lp_use_chroot, use_chroot)
 422 FN_LOCAL_BOOL(lp_write_only, write_only)
 423
 424 /* local prototypes */
 425 static int    strwicmp(char *psz1, char *psz2);
 426 static int    map_parameter(char *parmname);
 427 static BOOL   set_boolean(BOOL *pb, char *parmvalue);
 428 static int    getservicebyname(char *name, service *pserviceDest);
 429 static void   copy_service(service *pserviceDest, service *pserviceSource);
 430 static BOOL   do_parameter(char *parmname, char *parmvalue);
 431 static BOOL   do_section(char *sectionname);
 432
 433
 434 /***************************************************************************
 435 initialise a service to the defaults
 436 ***************************************************************************/
 437 static void init_service(service *pservice)
 438 {
 439         memset((char *)pservice,0,sizeof(service));
 440         copy_service(pservice,&sDefault);
 441 }
 442
 443
 444 /**
 445  * Assign a copy of @p v to @p *s.  Handles NULL strings.  @p *v must
 446  * be initialized when this is called, either to NULL or a malloc'd
 447  * string.
 448  *
 449  * @fixme There is a small leak here in that sometimes the existing
 450  * value will be dynamically allocated, and the old copy is lost.
 451  * However, we can't always deallocate the old value, because in the
 452  * case of sDefault, it points to a static string.  It would be nice
 453  * to have either all-strdup'd values, or to never need to free
 454  * memory.
 455  **/
 456 static void string_set(char **s, const char *v)
 457 {
 458         if (!v) {
 459                 *s = NULL;
 460                 return;
 461         }
 462         *s = strdup(v);
 463         if (!*s)
 464                 exit_cleanup(RERR_MALLOC);
 465 }
 466
 467
 468 /***************************************************************************
 469 add a new service to the services array initialising it with the given
 470 service
 471 ***************************************************************************/
 472 static int add_a_service(service *pservice, char *name)
 473 {
 474   int i;
 475   service tservice;
 476   int num_to_alloc = iNumServices+1;
 477
 478   tservice = *pservice;
 479
 480   /* it might already exist */
 481   if (name)
 482     {
 483       i = getservicebyname(name,NULL);
 484       if (i >= 0)
 485         return(i);
 486     }
 487
 488   i = iNumServices;
 489
 490   ServicePtrs = realloc_array(ServicePtrs, service *, num_to_alloc);
 491
 492   if (ServicePtrs)
 493           pSERVICE(iNumServices) = new(service);
 494
 495   if (!ServicePtrs || !pSERVICE(iNumServices))
 496           return(-1);
 497
 498   iNumServices++;
 499
 500   init_service(pSERVICE(i));
 501   copy_service(pSERVICE(i),&tservice);
 502   if (name)
 503     string_set(&iSERVICE(i).name,name);
 504
 505   return(i);
 506 }
 507
 508 /***************************************************************************
 509 Do a case-insensitive, whitespace-ignoring string compare.
 510 ***************************************************************************/
 511 static int strwicmp(char *psz1, char *psz2)
 512 {
 513    /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
 514    /* appropriate value. */
 515    if (psz1 == psz2)
 516       return (0);
 517    else
 518       if (psz1 == NULL)
 519          return (-1);
 520       else
 521           if (psz2 == NULL)
 522               return (1);
 523
 524    /* sync the strings on first non-whitespace */
 525    while (1)
 526    {
 527       while (isspace(* (unsigned char *) psz1))
 528          psz1++;
 529       while (isspace(* (unsigned char *) psz2))
 530          psz2++;
 531       if (toupper(* (unsigned char *) psz1) != toupper(* (unsigned char *) psz2)
 532           || *psz1 == '\0' || *psz2 == '\0')
 533          break;
 534       psz1++;
 535       psz2++;
 536    }
 537    return (*psz1 - *psz2);
 538 }
 539
 540 /***************************************************************************
 541 Map a parameter's string representation to something we can use.
 542 Returns False if the parameter string is not recognised, else TRUE.
 543 ***************************************************************************/
 544 static int map_parameter(char *parmname)
 545 {
 546    int iIndex;
 547
 548    if (*parmname == '-')
 549      return(-1);
 550
 551    for (iIndex = 0; parm_table[iIndex].label; iIndex++)
 552       if (strwicmp(parm_table[iIndex].label, parmname) == 0)
 553          return(iIndex);
 554
 555    rprintf(FERROR, "Unknown Parameter encountered: \"%s\"\n", parmname);
 556    return(-1);
 557 }
 558
 559
 560 /***************************************************************************
 561 Set a boolean variable from the text value stored in the passed string.
 562 Returns True in success, False if the passed string does not correctly
 563 represent a boolean.
 564 ***************************************************************************/
 565 static BOOL set_boolean(BOOL *pb, char *parmvalue)
 566 {
 567    BOOL bRetval;
 568
 569    bRetval = True;
 570    if (strwicmp(parmvalue, "yes") == 0 ||
 571        strwicmp(parmvalue, "true") == 0 ||
 572        strwicmp(parmvalue, "1") == 0)
 573       *pb = True;
 574    else
 575       if (strwicmp(parmvalue, "no") == 0 ||
 576           strwicmp(parmvalue, "False") == 0 ||
 577           strwicmp(parmvalue, "0") == 0)
 578          *pb = False;
 579       else
 580       {
 581          rprintf(FERROR, "Badly formed boolean in configuration file: \"%s\".\n",
 582                parmvalue);
 583          bRetval = False;
 584       }
 585    return (bRetval);
 586 }
 587
 588 /***************************************************************************
 589 Find a service by name. Otherwise works like get_service.
 590 ***************************************************************************/
 591 static int getservicebyname(char *name, service *pserviceDest)
 592 {
 593    int iService;
 594
 595    for (iService = iNumServices - 1; iService >= 0; iService--)
 596       if (strwicmp(iSERVICE(iService).name, name) == 0)
 597       {
 598          if (pserviceDest != NULL)
 599            copy_service(pserviceDest, pSERVICE(iService));
 600          break;
 601       }
 602
 603    return (iService);
 604 }
 605
 606
 607
 608 /***************************************************************************
 609 Copy a service structure to another
 610
 611 ***************************************************************************/
 612 static void copy_service(service *pserviceDest,
 613                          service *pserviceSource)
 614 {
 615   int i;
 616
 617   for (i=0;parm_table[i].label;i++)
 618     if (parm_table[i].ptr && parm_table[i].class == P_LOCAL) {
 619         void *def_ptr = parm_table[i].ptr;
 620         void *src_ptr =
 621           ((char *)pserviceSource) + PTR_DIFF(def_ptr,&sDefault);
 622         void *dest_ptr =
 623           ((char *)pserviceDest) + PTR_DIFF(def_ptr,&sDefault);
 624
 625         switch (parm_table[i].type)
 626           {
 627           case P_BOOL:
 628           case P_BOOLREV:
 629             *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
 630             break;
 631
 632           case P_INTEGER:
 633           case P_ENUM:
 634           case P_OCTAL:
 635             *(int *)dest_ptr = *(int *)src_ptr;
 636             break;
 637
 638           case P_CHAR:
 639             *(char *)dest_ptr = *(char *)src_ptr;
 640             break;
 641
 642           case P_PATH:
 643           case P_STRING:
 644             string_set(dest_ptr,*(char **)src_ptr);
 645             break;
 646
 647           default:
 648             break;
 649           }
 650       }
 651 }
 652
 653
 654 /***************************************************************************
 655 Process a parameter for a particular service number. If snum < 0
 656 then assume we are in the globals
 657 ***************************************************************************/
 658 static BOOL lp_do_parameter(int snum, char *parmname, char *parmvalue)
 659 {
 660    int parmnum, i;
 661    void *parm_ptr=NULL; /* where we are going to store the result */
 662    void *def_ptr=NULL;
 663    char *cp;
 664
 665    parmnum = map_parameter(parmname);
 666
 667    if (parmnum < 0)
 668      {
 669        rprintf(FERROR, "IGNORING unknown parameter \"%s\"\n", parmname);
 670        return(True);
 671      }
 672
 673    def_ptr = parm_table[parmnum].ptr;
 674
 675    /* we might point at a service, the default service or a global */
 676    if (snum < 0) {
 677      parm_ptr = def_ptr;
 678    } else {
 679        if (parm_table[parmnum].class == P_GLOBAL) {
 680            rprintf(FERROR, "Global parameter %s found in service section!\n",parmname);
 681            return(True);
 682          }
 683        parm_ptr = ((char *)pSERVICE(snum)) + PTR_DIFF(def_ptr,&sDefault);
 684    }
 685
 686    /* now switch on the type of variable it is */
 687    switch (parm_table[parmnum].type)
 688      {
 689      case P_BOOL:
 690        set_boolean(parm_ptr,parmvalue);
 691        break;
 692
 693      case P_BOOLREV:
 694        set_boolean(parm_ptr,parmvalue);
 695        *(BOOL *)parm_ptr = ! *(BOOL *)parm_ptr;
 696        break;
 697
 698      case P_INTEGER:
 699        *(int *)parm_ptr = atoi(parmvalue);
 700        break;
 701
 702      case P_CHAR:
 703        *(char *)parm_ptr = *parmvalue;
 704        break;
 705
 706      case P_OCTAL:
 707        sscanf(parmvalue,"%o",(int *)parm_ptr);
 708        break;
 709
 710      case P_PATH:
 711        string_set(parm_ptr,parmvalue);
 712        if ((cp = *(char**)parm_ptr) != NULL) {
 713            int len = strlen(cp);
 714            while (len > 1 && cp[len-1] == '/') len--;
 715            cp[len] = '\0';
 716        }
 717        break;
 718
 719      case P_STRING:
 720        string_set(parm_ptr,parmvalue);
 721        break;
 722
 723      case P_GSTRING:
 724        strlcpy((char *)parm_ptr,parmvalue,sizeof(pstring));
 725        break;
 726
 727      case P_ENUM:
 728              for (i=0;parm_table[parmnum].enum_list[i].name;i++) {
 729                      if (strequal(parmvalue, parm_table[parmnum].enum_list[i].name)) {
 730                              *(int *)parm_ptr = parm_table[parmnum].enum_list[i].value;
 731                              break;
 732                      }
 733              }
 734              if (!parm_table[parmnum].enum_list[i].name) {
 735                      if (atoi(parmvalue) > 0)
 736                              *(int *)parm_ptr = atoi(parmvalue);
 737              }
 738              break;
 739      case P_SEP:
 740              break;
 741      }
 742
 743    return(True);
 744 }
 745
 746 /***************************************************************************
 747 Process a parameter.
 748 ***************************************************************************/
 749 static BOOL do_parameter(char *parmname, char *parmvalue)
 750 {
 751    return lp_do_parameter(bInGlobalSection?-2:iServiceIndex, parmname, parmvalue);
 752 }
 753
 754 /***************************************************************************
 755 Process a new section (service). At this stage all sections are services.
 756 Later we'll have special sections that permit server parameters to be set.
 757 Returns True on success, False on failure.
 758 ***************************************************************************/
 759 static BOOL do_section(char *sectionname)
 760 {
 761    BOOL bRetval;
 762    BOOL isglobal = (strwicmp(sectionname, GLOBAL_NAME) == 0);
 763    bRetval = False;
 764
 765    /* if we were in a global section then do the local inits */
 766    if (bInGlobalSection && !isglobal)
 767      init_locals();
 768
 769    /* if we've just struck a global section, note the fact. */
 770    bInGlobalSection = isglobal;
 771
 772    /* check for multiple global sections */
 773    if (bInGlobalSection)
 774    {
 775      return(True);
 776    }
 777
 778    /* if we have a current service, tidy it up before moving on */
 779    bRetval = True;
 780
 781    if (iServiceIndex >= 0)
 782      bRetval = True;
 783
 784    /* if all is still well, move to the next record in the services array */
 785    if (bRetval)
 786      {
 787        /* We put this here to avoid an odd message order if messages are */
 788        /* issued by the post-processing of a previous section. */
 789
 790        if ((iServiceIndex=add_a_service(&sDefault,sectionname)) < 0)
 791          {
 792            rprintf(FERROR,"Failed to add a new service\n");
 793            return(False);
 794          }
 795      }
 796
 797    return (bRetval);
 798 }
 799
 800
 801 /***************************************************************************
 802 Load the services array from the services file. Return True on success,
 803 False on failure.
 804 ***************************************************************************/
 805 BOOL lp_load(char *pszFname, int globals_only)
 806 {
 807         extern int am_server;
 808         extern int am_root;
 809         pstring n2;
 810         BOOL bRetval;
 811
 812         bRetval = False;
 813
 814         bInGlobalSection = True;
 815
 816         init_globals();
 817
 818         if (pszFname)
 819             pstrcpy(n2,pszFname);
 820         else if (am_server && !am_root)
 821             pstrcpy(n2,RSYNCD_USERCONF);
 822         else
 823             pstrcpy(n2,RSYNCD_SYSCONF);
 824
 825         /* We get sections first, so have to start 'behind' to make up */
 826         iServiceIndex = -1;
 827         bRetval = pm_process(n2, globals_only?NULL:do_section, do_parameter);
 828
 829         return (bRetval);
 830 }
 831
 832
 833 /***************************************************************************
 834 return the max number of services
 835 ***************************************************************************/
 836 int lp_numservices(void)
 837 {
 838   return(iNumServices);
 839 }
 840
 841 /***************************************************************************
 842 Return the number of the service with the given name, or -1 if it doesn't
 843 exist. Note that this is a DIFFERENT ANIMAL from the internal function
 844 getservicebyname()! This works ONLY if all services have been loaded, and
 845 does not copy the found service.
 846 ***************************************************************************/
 847 int lp_number(char *name)
 848 {
 849    int iService;
 850
 851    for (iService = iNumServices - 1; iService >= 0; iService--)
 852       if (strcmp(lp_name(iService), name) == 0)
 853          break;
 854
 855    return (iService);
 856 }
 857