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 BOOL int
  48 #define False 0
  49 #define True 1
  50 #define Realloc realloc
  51 #define PTR_DIFF(p1,p2) ((ptrdiff_t)(((char *)(p1)) - (char *)(p2)))
  52 #define strequal(a,b) (strcasecmp(a,b)==0)
  53 #define BOOLSTR(b) ((b) ? "Yes" : "No")
  54 typedef char pstring[1024];
  55 #define pstrcpy(a,b) strcpy(a,b)
  56
  57 /* the following are used by loadparm for option lists */
  58 typedef enum
  59 {
  60   P_BOOL,P_BOOLREV,P_CHAR,P_INTEGER,P_OCTAL,
  61   P_STRING,P_GSTRING,P_ENUM,P_SEP
  62 } parm_type;
  63
  64 typedef enum
  65 {
  66   P_LOCAL,P_GLOBAL,P_SEPARATOR,P_NONE
  67 } parm_class;
  68
  69 struct enum_list {
  70         int value;
  71         char *name;
  72 };
  73
  74 struct parm_struct
  75 {
  76         char *label;
  77         parm_type type;
  78         parm_class class;
  79         void *ptr;
  80         struct enum_list *enum_list;
  81         unsigned flags;
  82 };
  83
  84 static BOOL bLoaded = False;
  85
  86 #ifndef GLOBAL_NAME
  87 #define GLOBAL_NAME "global"
  88 #endif
  89
  90 /* some helpful bits */
  91 #define pSERVICE(i) ServicePtrs[i]
  92 #define iSERVICE(i) (*pSERVICE(i))
  93 #define LP_SNUM_OK(iService) (((iService) >= 0) && ((iService) < iNumServices))
  94
  95 /*
  96  * This structure describes global (ie., server-wide) parameters.
  97  */
  98 typedef struct
  99 {
 100         char *motd_file;
 101 } global;
 102
 103 static global Globals;
 104
 105
 106
 107 /*
 108  * This structure describes a single service.
 109  */
 110 typedef struct
 111 {
 112         char *name;
 113         char *path;
 114         char *comment;
 115         BOOL read_only;
 116         BOOL list;
 117         char *uid;
 118         char *gid;
 119 } service;
 120
 121
 122 /* This is a default service used to prime a services structure */
 123 static service sDefault =
 124 {
 125         NULL,    /* name */
 126         NULL,    /* path */
 127         NULL,    /* comment */
 128         True,    /* read only */
 129         True,    /* list */
 130         "nobody",/* uid */
 131         "nobody",/* gid */
 132 };
 133
 134
 135
 136 /* local variables */
 137 static service **ServicePtrs = NULL;
 138 static int iNumServices = 0;
 139 static int iServiceIndex = 0;
 140 static BOOL bInGlobalSection = True;
 141
 142 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
 143
 144
 145 /* note that we do not initialise the defaults union - it is not allowed in ANSI C */
 146 static struct parm_struct parm_table[] =
 147 {
 148   {"motd file",        P_STRING,  P_GLOBAL, &Globals.motd_file,    NULL,   0},
 149   {"name",             P_STRING,  P_LOCAL,  &sDefault.name,        NULL,   0},
 150   {"comment",          P_STRING,  P_LOCAL,  &sDefault.comment,     NULL,   0},
 151   {"path",             P_STRING,  P_LOCAL,  &sDefault.path,        NULL,   0},
 152   {"read only",        P_BOOL,    P_LOCAL,  &sDefault.read_only,   NULL,   0},
 153   {"list",             P_BOOL,    P_LOCAL,  &sDefault.list,        NULL,   0},
 154   {"uid",              P_STRING,  P_LOCAL,  &sDefault.uid,         NULL,   0},
 155   {"gid",              P_STRING,  P_LOCAL,  &sDefault.gid,         NULL,   0},
 156   {NULL,               P_BOOL,    P_NONE,   NULL,                  NULL,   0}
 157 };
 158
 159
 160 /***************************************************************************
 161 Initialise the global parameter structure.
 162 ***************************************************************************/
 163 static void init_globals(void)
 164 {
 165 }
 166
 167 /***************************************************************************
 168 Initialise the sDefault parameter structure.
 169 ***************************************************************************/
 170 static void init_locals(void)
 171 {
 172 }
 173
 174
 175 /*
 176    In this section all the functions that are used to access the
 177    parameters from the rest of the program are defined
 178 */
 179
 180 #define FN_GLOBAL_STRING(fn_name,ptr) \
 181  char *fn_name(void) {return(*(char **)(ptr) ? *(char **)(ptr) : "");}
 182 #define FN_GLOBAL_BOOL(fn_name,ptr) \
 183  BOOL fn_name(void) {return(*(BOOL *)(ptr));}
 184 #define FN_GLOBAL_CHAR(fn_name,ptr) \
 185  char fn_name(void) {return(*(char *)(ptr));}
 186 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
 187  int fn_name(void) {return(*(int *)(ptr));}
 188
 189 #define FN_LOCAL_STRING(fn_name,val) \
 190  char *fn_name(int i) {return((LP_SNUM_OK(i)&&pSERVICE(i)->val)?pSERVICE(i)->val : (sDefault.val?sDefault.val:""));}
 191 #define FN_LOCAL_BOOL(fn_name,val) \
 192  BOOL fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
 193 #define FN_LOCAL_CHAR(fn_name,val) \
 194  char fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
 195 #define FN_LOCAL_INTEGER(fn_name,val) \
 196  int fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
 197
 198
 199 FN_GLOBAL_STRING(lp_motd_file, &Globals.motd_file)
 200 FN_LOCAL_STRING(lp_name, name)
 201 FN_LOCAL_STRING(lp_comment, comment)
 202 FN_LOCAL_STRING(lp_path, path)
 203 FN_LOCAL_BOOL(lp_read_only, read_only)
 204 FN_LOCAL_BOOL(lp_list, list)
 205 FN_LOCAL_STRING(lp_uid, uid)
 206 FN_LOCAL_STRING(lp_gid, gid)
 207
 208 /* local prototypes */
 209 static int    strwicmp( char *psz1, char *psz2 );
 210 static int    map_parameter( char *parmname);
 211 static BOOL   set_boolean( BOOL *pb, char *parmvalue );
 212 static int    getservicebyname(char *name, service *pserviceDest);
 213 static void   copy_service( service *pserviceDest,
 214                             service *pserviceSource);
 215 static BOOL   do_parameter(char *parmname, char *parmvalue);
 216 static BOOL   do_section(char *sectionname);
 217
 218
 219 /***************************************************************************
 220 initialise a service to the defaults
 221 ***************************************************************************/
 222 static void init_service(service *pservice)
 223 {
 224   bzero((char *)pservice,sizeof(service));
 225   copy_service(pservice,&sDefault);
 226 }
 227
 228 static void string_set(char **s, char *v)
 229 {
 230         if (*s) free(*s);
 231         if (!v) {
 232                 *s = NULL;
 233                 return;
 234         }
 235         *s = strdup(v);
 236         if (!*s) exit_cleanup(1);
 237 }
 238
 239
 240 /***************************************************************************
 241 add a new service to the services array initialising it with the given
 242 service
 243 ***************************************************************************/
 244 static int add_a_service(service *pservice, char *name)
 245 {
 246   int i;
 247   service tservice;
 248   int num_to_alloc = iNumServices+1;
 249
 250   tservice = *pservice;
 251
 252   /* it might already exist */
 253   if (name)
 254     {
 255       i = getservicebyname(name,NULL);
 256       if (i >= 0)
 257         return(i);
 258     }
 259
 260   i = iNumServices;
 261
 262   ServicePtrs = (service **)Realloc(ServicePtrs,sizeof(service *)*num_to_alloc);
 263   if (ServicePtrs)
 264           pSERVICE(iNumServices) = (service *)malloc(sizeof(service));
 265
 266   if (!ServicePtrs || !pSERVICE(iNumServices))
 267           return(-1);
 268
 269   iNumServices++;
 270
 271   init_service(pSERVICE(i));
 272   copy_service(pSERVICE(i),&tservice);
 273   if (name)
 274     string_set(&iSERVICE(i).name,name);
 275
 276   return(i);
 277 }
 278
 279 /***************************************************************************
 280 Do a case-insensitive, whitespace-ignoring string compare.
 281 ***************************************************************************/
 282 static int strwicmp(char *psz1, char *psz2)
 283 {
 284    /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
 285    /* appropriate value. */
 286    if (psz1 == psz2)
 287       return (0);
 288    else
 289       if (psz1 == NULL)
 290          return (-1);
 291       else
 292           if (psz2 == NULL)
 293               return (1);
 294
 295    /* sync the strings on first non-whitespace */
 296    while (1)
 297    {
 298       while (isspace(*psz1))
 299          psz1++;
 300       while (isspace(*psz2))
 301          psz2++;
 302       if (toupper(*psz1) != toupper(*psz2) || *psz1 == '\0' || *psz2 == '\0')
 303          break;
 304       psz1++;
 305       psz2++;
 306    }
 307    return (*psz1 - *psz2);
 308 }
 309
 310 /***************************************************************************
 311 Map a parameter's string representation to something we can use.
 312 Returns False if the parameter string is not recognised, else TRUE.
 313 ***************************************************************************/
 314 static int map_parameter(char *parmname)
 315 {
 316    int iIndex;
 317
 318    if (*parmname == '-')
 319      return(-1);
 320
 321    for (iIndex = 0; parm_table[iIndex].label; iIndex++)
 322       if (strwicmp(parm_table[iIndex].label, parmname) == 0)
 323          return(iIndex);
 324
 325    rprintf(FERROR, "Unknown parameter encountered: \"%s\"\n", parmname);
 326    return(-1);
 327 }
 328
 329
 330 /***************************************************************************
 331 Set a boolean variable from the text value stored in the passed string.
 332 Returns True in success, False if the passed string does not correctly
 333 represent a boolean.
 334 ***************************************************************************/
 335 static BOOL set_boolean(BOOL *pb, char *parmvalue)
 336 {
 337    BOOL bRetval;
 338
 339    bRetval = True;
 340    if (strwicmp(parmvalue, "yes") == 0 ||
 341        strwicmp(parmvalue, "true") == 0 ||
 342        strwicmp(parmvalue, "1") == 0)
 343       *pb = True;
 344    else
 345       if (strwicmp(parmvalue, "no") == 0 ||
 346           strwicmp(parmvalue, "False") == 0 ||
 347           strwicmp(parmvalue, "0") == 0)
 348          *pb = False;
 349       else
 350       {
 351          rprintf(FERROR, "Badly formed boolean in configuration file: \"%s\".\n",
 352                parmvalue);
 353          bRetval = False;
 354       }
 355    return (bRetval);
 356 }
 357
 358 /***************************************************************************
 359 Find a service by name. Otherwise works like get_service.
 360 ***************************************************************************/
 361 static int getservicebyname(char *name, service *pserviceDest)
 362 {
 363    int iService;
 364
 365    for (iService = iNumServices - 1; iService >= 0; iService--)
 366       if (strwicmp(iSERVICE(iService).name, name) == 0)
 367       {
 368          if (pserviceDest != NULL)
 369            copy_service(pserviceDest, pSERVICE(iService));
 370          break;
 371       }
 372
 373    return (iService);
 374 }
 375
 376
 377
 378 /***************************************************************************
 379 Copy a service structure to another
 380
 381 ***************************************************************************/
 382 static void copy_service(service *pserviceDest,
 383                          service *pserviceSource)
 384 {
 385   int i;
 386
 387   for (i=0;parm_table[i].label;i++)
 388     if (parm_table[i].ptr && parm_table[i].class == P_LOCAL) {
 389         void *def_ptr = parm_table[i].ptr;
 390         void *src_ptr =
 391           ((char *)pserviceSource) + PTR_DIFF(def_ptr,&sDefault);
 392         void *dest_ptr =
 393           ((char *)pserviceDest) + PTR_DIFF(def_ptr,&sDefault);
 394
 395         switch (parm_table[i].type)
 396           {
 397           case P_BOOL:
 398           case P_BOOLREV:
 399             *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
 400             break;
 401
 402           case P_INTEGER:
 403           case P_ENUM:
 404           case P_OCTAL:
 405             *(int *)dest_ptr = *(int *)src_ptr;
 406             break;
 407
 408           case P_CHAR:
 409             *(char *)dest_ptr = *(char *)src_ptr;
 410             break;
 411
 412           case P_STRING:
 413             string_set(dest_ptr,*(char **)src_ptr);
 414             break;
 415
 416           default:
 417             break;
 418           }
 419       }
 420 }
 421
 422
 423 /***************************************************************************
 424 Process a parameter for a particular service number. If snum < 0
 425 then assume we are in the globals
 426 ***************************************************************************/
 427 static BOOL lp_do_parameter(int snum, char *parmname, char *parmvalue)
 428 {
 429    int parmnum, i;
 430    void *parm_ptr=NULL; /* where we are going to store the result */
 431    void *def_ptr=NULL;
 432
 433    parmnum = map_parameter(parmname);
 434
 435    if (parmnum < 0)
 436      {
 437        rprintf(FERROR, "Ignoring unknown parameter \"%s\"\n", parmname);
 438        return(True);
 439      }
 440
 441    def_ptr = parm_table[parmnum].ptr;
 442
 443    /* we might point at a service, the default service or a global */
 444    if (snum < 0) {
 445      parm_ptr = def_ptr;
 446    } else {
 447        if (parm_table[parmnum].class == P_GLOBAL) {
 448            rprintf(FERROR, "Global parameter %s found in service section!\n",parmname);
 449            return(True);
 450          }
 451        parm_ptr = ((char *)pSERVICE(snum)) + PTR_DIFF(def_ptr,&sDefault);
 452    }
 453
 454    /* now switch on the type of variable it is */
 455    switch (parm_table[parmnum].type)
 456      {
 457      case P_BOOL:
 458        set_boolean(parm_ptr,parmvalue);
 459        break;
 460
 461      case P_BOOLREV:
 462        set_boolean(parm_ptr,parmvalue);
 463        *(BOOL *)parm_ptr = ! *(BOOL *)parm_ptr;
 464        break;
 465
 466      case P_INTEGER:
 467        *(int *)parm_ptr = atoi(parmvalue);
 468        break;
 469
 470      case P_CHAR:
 471        *(char *)parm_ptr = *parmvalue;
 472        break;
 473
 474      case P_OCTAL:
 475        sscanf(parmvalue,"%o",(int *)parm_ptr);
 476        break;
 477
 478      case P_STRING:
 479        string_set(parm_ptr,parmvalue);
 480        break;
 481
 482      case P_GSTRING:
 483        strcpy((char *)parm_ptr,parmvalue);
 484        break;
 485
 486      case P_ENUM:
 487              for (i=0;parm_table[parmnum].enum_list[i].name;i++) {
 488                      if (strequal(parmvalue, parm_table[parmnum].enum_list[i].name)) {
 489                              *(int *)parm_ptr = parm_table[parmnum].enum_list[i].value;
 490                              break;
 491                      }
 492              }
 493              break;
 494      case P_SEP:
 495              break;
 496      }
 497
 498    return(True);
 499 }
 500
 501 /***************************************************************************
 502 Process a parameter.
 503 ***************************************************************************/
 504 static BOOL do_parameter(char *parmname, char *parmvalue)
 505 {
 506    return lp_do_parameter(bInGlobalSection?-2:iServiceIndex, parmname, parmvalue);
 507 }
 508
 509 /***************************************************************************
 510 Process a new section (service). At this stage all sections are services.
 511 Later we'll have special sections that permit server parameters to be set.
 512 Returns True on success, False on failure.
 513 ***************************************************************************/
 514 static BOOL do_section(char *sectionname)
 515 {
 516    BOOL bRetval;
 517    BOOL isglobal = (strwicmp(sectionname, GLOBAL_NAME) == 0);
 518    bRetval = False;
 519
 520    /* if we were in a global section then do the local inits */
 521    if (bInGlobalSection && !isglobal)
 522      init_locals();
 523
 524    /* if we've just struck a global section, note the fact. */
 525    bInGlobalSection = isglobal;
 526
 527    /* check for multiple global sections */
 528    if (bInGlobalSection)
 529    {
 530      return(True);
 531    }
 532
 533    /* if we have a current service, tidy it up before moving on */
 534    bRetval = True;
 535
 536    if (iServiceIndex >= 0)
 537      bRetval = True;
 538
 539    /* if all is still well, move to the next record in the services array */
 540    if (bRetval)
 541      {
 542        /* We put this here to avoid an odd message order if messages are */
 543        /* issued by the post-processing of a previous section. */
 544
 545        if ((iServiceIndex=add_a_service(&sDefault,sectionname)) < 0)
 546          {
 547            rprintf(FERROR,"Failed to add a new service\n");
 548            return(False);
 549          }
 550      }
 551
 552    return (bRetval);
 553 }
 554
 555
 556 /***************************************************************************
 557 Load the services array from the services file. Return True on success,
 558 False on failure.
 559 ***************************************************************************/
 560 BOOL lp_load(char *pszFname)
 561 {
 562   pstring n2;
 563   BOOL bRetval;
 564
 565   bRetval = False;
 566
 567   bInGlobalSection = True;
 568
 569   init_globals();
 570
 571   pstrcpy(n2,pszFname);
 572
 573   /* We get sections first, so have to start 'behind' to make up */
 574   iServiceIndex = -1;
 575   bRetval = pm_process(n2, do_section, do_parameter);
 576
 577   bLoaded = True;
 578
 579   return (bRetval);
 580 }
 581
 582
 583 /***************************************************************************
 584 return the max number of services
 585 ***************************************************************************/
 586 int lp_numservices(void)
 587 {
 588   return(iNumServices);
 589 }
 590
 591 /***************************************************************************
 592 Return the number of the service with the given name, or -1 if it doesn't
 593 exist. Note that this is a DIFFERENT ANIMAL from the internal function
 594 getservicebyname()! This works ONLY if all services have been loaded, and
 595 does not copy the found service.
 596 ***************************************************************************/
 597 int lp_number(char *name)
 598 {
 599    int iService;
 600
 601    for (iService = iNumServices - 1; iService >= 0; iService--)
 602       if (strequal(lp_name(iService), name))
 603          break;
 604
 605    return (iService);
 606 }
 607