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