Since the loadparm.c file is changing, I'm reformatting it to use the

rsync style.

1 files changed, 310 insertions, 401 deletions

diff --git a/loadparm.c b/loadparm.c
index 8b3e9f7e..9b7c7e59 100644
--- a/loadparm.c
+++ b/loadparm.c
@@ -1,6 +1,3 @@
-/* This is based on loadparm.c from Samba, written by Andrew Tridgell
-   and Karl Auer */
-
 /*
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,13 +13,14 @@
  * with this program; if not, visit the http://fsf.org website.
  */
 
-/* some fixes
+/* This is based on loadparm.c from Samba, written by Andrew Tridgell
+ * and Karl Auer.  Some of the changes are:
  *
  * Copyright (C) 2001, 2002 Martin Pool <mbp@samba.org>
+ * Copyright (C) 2003-2008 Wayne Davison <wayned@samba.org>
  */
 
-/*
- *  Load parameters.
+/* Load parameters.
  *
  *  This module provides suitable callback functions for the params
  *  module. It builds the internal table of service details which is
@@ -38,24 +36,20 @@
  *
  *
  * Notes:
- *   The configuration file is processed sequentially for speed. It is NOT
- *   accessed randomly as happens in 'real' Windows. For this reason, there
- *   is a fair bit of sequence-dependent code here - ie., code which assumes
- *   that certain things happen before others. In particular, the code which
- *   happens at the boundary between sections is delicately poised, so be
- *   careful!
- *
+ *   The configuration file is processed sequentially for speed. For this
+ *   reason, there is a fair bit of sequence-dependent code here - ie., code
+ *   which assumes that certain things happen before others. In particular, the
+ *   code which happens at the boundary between sections is delicately poised,
+ *   so be careful!
  */
 
-/* TODO: Parameter to set debug level on server. */
-
 #include "rsync.h"
 #include "ifuncs.h"
-#define PTR_DIFF(p1,p2) ((ptrdiff_t)(((char *)(p1)) - (char *)(p2)))
-#define strequal(a,b) (strcasecmp(a,b)==0)
+#define PTR_DIFF(p1, p2) ((ptrdiff_t)(((char *)(p1)) - (char *)(p2)))
+#define strequal(a, b) (strcasecmp(a, b)==0)
 #define BOOLSTR(b) ((b) ? "Yes" : "No")
 typedef char pstring[1024];
-#define pstrcpy(a,b) strlcpy(a,b,sizeof(pstring))
+#define pstrcpy(a, b) strlcpy((a), (b), sizeof (pstring))
 
 #ifndef LOG_DAEMON
 #define LOG_DAEMON 0
@@ -65,15 +59,13 @@ typedef char pstring[1024];
 	" *.t[gb]z *.7z *.mp[34] *.mov *.avi *.ogg *.jpg *.jpeg"
 
 /* the following are used by loadparm for option lists */
-typedef enum
-{
-	P_BOOL,P_BOOLREV,P_CHAR,P_INTEGER,P_OCTAL,
-	P_PATH,P_STRING,P_GSTRING,P_ENUM,P_SEP
+typedef enum {
+	P_BOOL, P_BOOLREV, P_CHAR, P_INTEGER, P_OCTAL,
+	P_PATH, P_STRING, P_GSTRING, P_ENUM, P_SEP
 } parm_type;
 
-typedef enum
-{
-	P_LOCAL,P_GLOBAL,P_SEPARATOR,P_NONE
+typedef enum {
+	P_LOCAL, P_GLOBAL, P_SEPARATOR, P_NONE
 } parm_class;
 
 struct enum_list {
@@ -81,8 +73,7 @@ struct enum_list {
 	char *name;
 };
 
-struct parm_struct
-{
+struct parm_struct {
 	char *label;
 	parm_type type;
 	parm_class class;
@@ -103,8 +94,7 @@ struct parm_struct
 /*
  * This structure describes global (ie., server-wide) parameters.
  */
-typedef struct
-{
+typedef struct {
 	char *bind_address;
 	char *motd_file;
 	char *pid_file;
@@ -115,14 +105,12 @@ typedef struct
 
 static global Globals;
 
-
 /*
  * This structure describes a single service.  Their order must match the
  * initializers below, which you can accomplish by keeping each sub-section
  * sorted.  (e.g. in vim, just visually select each subsection and use !sort.)
  */
-typedef struct
-{
+typedef struct {
 	char *auth_users;
 	char *charset;
 	char *comment;
@@ -167,13 +155,11 @@ typedef struct
 	BOOL write_only;
 } service;
 
-
 /* This is a default service used to prime a services structure.  In order
  * to make these easy to keep sorted in the same way as the variables
  * above, use the variable name in the leading comment, including a
  * trailing ';' (to avoid a sorting problem with trailing digits). */
-static service sDefault =
-{
+static service sDefault = {
  /* auth_users; */		NULL,
  /* charset; */ 		NULL,
  /* comment; */ 		NULL,
@@ -218,15 +204,13 @@ static service sDefault =
  /* write_only; */		False,
 };
 
-
-
 /* local variables */
 static service **ServicePtrs = NULL;
 static int iNumServices = 0;
 static int iServiceIndex = 0;
 static BOOL bInGlobalSection = True;
 
-#define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
+#define NUMPARAMETERS (sizeof (parm_table) / sizeof (struct parm_struct))
 
 static struct enum_list enum_facilities[] = {
 #ifdef LOG_AUTH
@@ -292,7 +276,8 @@ static struct enum_list enum_facilities[] = {
 #ifdef LOG_LOCAL7
 	{ LOG_LOCAL7, "local7" },
 #endif
-	{ -1, NULL }};
+	{ -1, NULL }
+};
 
 
 /* note that we do not initialise the defaults union - it is not allowed in ANSI C */
@@ -349,46 +334,38 @@ static struct parm_struct parm_table[] =
  {NULL,                P_BOOL,   P_NONE,  NULL,                        NULL,0}
 };
 
-
-/***************************************************************************
-* Initialise the global parameter structure.
-***************************************************************************/
+/* Initialise the global parameter structure. */
 static void init_globals(void)
 {
 	memset(&Globals, 0, sizeof Globals);
 }
 
-/***************************************************************************
-* Initialise the sDefault parameter structure.
-***************************************************************************/
+/* Initialise the sDefault parameter structure. */
 static void init_locals(void)
 {
+	/* Nothing needed yet... */
 }
 
-
-/*
-   In this section all the functions that are used to access the
-   parameters from the rest of the program are defined
-*/
-
-#define FN_GLOBAL_STRING(fn_name,ptr) \
- char *fn_name(void) {return(*(char **)(ptr) ? *(char **)(ptr) : "");}
-#define FN_GLOBAL_BOOL(fn_name,ptr) \
- BOOL fn_name(void) {return(*(BOOL *)(ptr));}
-#define FN_GLOBAL_CHAR(fn_name,ptr) \
- char fn_name(void) {return(*(char *)(ptr));}
-#define FN_GLOBAL_INTEGER(fn_name,ptr) \
- int fn_name(void) {return(*(int *)(ptr));}
-
-#define FN_LOCAL_STRING(fn_name,val) \
- char *fn_name(int i) {return((LP_SNUM_OK(i)&&pSERVICE(i)->val)?pSERVICE(i)->val : (sDefault.val?sDefault.val:""));}
-#define FN_LOCAL_BOOL(fn_name,val) \
- BOOL fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
-#define FN_LOCAL_CHAR(fn_name,val) \
- char fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
-#define FN_LOCAL_INTEGER(fn_name,val) \
- int fn_name(int i) {return(LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val);}
-
+/* In this section all the functions that are used to access the
+ * parameters from the rest of the program are defined. */
+
+#define FN_GLOBAL_STRING(fn_name, ptr) \
+ char *fn_name(void) {return *(char **)(ptr) ? *(char **)(ptr) : "";}
+#define FN_GLOBAL_BOOL(fn_name, ptr) \
+ BOOL fn_name(void) {return *(BOOL *)(ptr);}
+#define FN_GLOBAL_CHAR(fn_name, ptr) \
+ char fn_name(void) {return *(char *)(ptr);}
+#define FN_GLOBAL_INTEGER(fn_name, ptr) \
+ int fn_name(void) {return *(int *)(ptr);}
+
+#define FN_LOCAL_STRING(fn_name, val) \
+ char *fn_name(int i) {return LP_SNUM_OK(i) && pSERVICE(i)->val? pSERVICE(i)->val : (sDefault.val? sDefault.val : "");}
+#define FN_LOCAL_BOOL(fn_name, val) \
+ BOOL fn_name(int i) {return LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val;}
+#define FN_LOCAL_CHAR(fn_name, val) \
+ char fn_name(int i) {return LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val;}
+#define FN_LOCAL_INTEGER(fn_name, val) \
+ int fn_name(int i) {return LP_SNUM_OK(i)? pSERVICE(i)->val : sDefault.val;}
 
 FN_GLOBAL_STRING(lp_bind_address, &Globals.bind_address)
 FN_GLOBAL_STRING(lp_motd_file, &Globals.motd_file)
@@ -449,387 +426,326 @@ static void   copy_service(service *pserviceDest, service *pserviceSource);
 static BOOL   do_parameter(char *parmname, char *parmvalue);
 static BOOL   do_section(char *sectionname);
 
-
-/***************************************************************************
-* initialise a service to the defaults
-***************************************************************************/
+/* Initialise a service to the defaults. */
 static void init_service(service *pservice)
 {
-	memset((char *)pservice,0,sizeof(service));
-	copy_service(pservice,&sDefault);
+	memset((char *)pservice, 0, sizeof (service));
+	copy_service(pservice, &sDefault);
 }
 
-
-/**
- * Assign a copy of @p v to @p *s.  Handles NULL strings.  @p *v must
+/* Assign a copy of v to *s.  Handles NULL strings.  *v must
  * be initialized when this is called, either to NULL or a malloc'd
  * string.
  *
- * @fixme There is a small leak here in that sometimes the existing
+ * FIXME There is a small leak here in that sometimes the existing
  * value will be dynamically allocated, and the old copy is lost.
  * However, we can't always deallocate the old value, because in the
  * case of sDefault, it points to a static string.  It would be nice
  * to have either all-strdup'd values, or to never need to free
- * memory.
- **/
+ * memory. */
 static void string_set(char **s, const char *v)
 {
 	if (!v) {
 		*s = NULL;
 		return;
 	}
-	*s = strdup(v);
-	if (!*s)
+	if (!(*s = strdup(v)))
 		exit_cleanup(RERR_MALLOC);
 }
 
-
-/***************************************************************************
-* add a new service to the services array initialising it with the given
-* service
-***************************************************************************/
+/* Add a new service to the services array, with defaults set. */
 static int add_a_service(service *pservice, char *name)
 {
-  int i;
-  service tservice;
-  int num_to_alloc = iNumServices+1;
+	int i;
+	service tservice;
+	int num_to_alloc = iNumServices+1;
 
-  tservice = *pservice;
+	tservice = *pservice;
 
-  /* it might already exist */
-  if (name)
-    {
-      i = getservicebyname(name,NULL);
-      if (i >= 0)
-	return(i);
-    }
-
-  i = iNumServices;
+	/* it might already exist */
+	if (name) {
+		i = getservicebyname(name, NULL);
+		if (i >= 0)
+			return i;
+	}
 
-  ServicePtrs = realloc_array(ServicePtrs, service *, num_to_alloc);
+	i = iNumServices;
+	ServicePtrs = realloc_array(ServicePtrs, service *, num_to_alloc);
 
-  if (ServicePtrs)
-	  pSERVICE(iNumServices) = new(service);
+	if (ServicePtrs)
+		pSERVICE(iNumServices) = new(service);
 
-  if (!ServicePtrs || !pSERVICE(iNumServices))
-	  return(-1);
+	if (!ServicePtrs || !pSERVICE(iNumServices))
+		return -1;
 
-  iNumServices++;
+	iNumServices++;
 
-  init_service(pSERVICE(i));
-  copy_service(pSERVICE(i),&tservice);
-  if (name)
-    string_set(&iSERVICE(i).name,name);
+	init_service(pSERVICE(i));
+	copy_service(pSERVICE(i), &tservice);
+	if (name)
+		string_set(&iSERVICE(i).name, name);
 
-  return(i);
+	return i;
 }
 
-/***************************************************************************
-* Do a case-insensitive, whitespace-ignoring string compare.
-***************************************************************************/
+/* Do a case-insensitive, whitespace-ignoring string compare. */
 static int strwicmp(char *psz1, char *psz2)
 {
-   /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
-   /* appropriate value. */
-   if (psz1 == psz2)
-      return (0);
-   else
-      if (psz1 == NULL)
-         return (-1);
-      else
-          if (psz2 == NULL)
-              return (1);
-
-   /* sync the strings on first non-whitespace */
-   while (1)
-   {
-      while (isSpace(psz1))
-         psz1++;
-      while (isSpace(psz2))
-         psz2++;
-      if (toUpper(psz1) != toUpper(psz2) || *psz1 == '\0' || *psz2 == '\0')
-         break;
-      psz1++;
-      psz2++;
-   }
-   return (*psz1 - *psz2);
+	/* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
+	/* appropriate value. */
+	if (psz1 == psz2)
+		return 0;
+
+	if (psz1 == NULL)
+		return -1;
+
+	if (psz2 == NULL)
+		return 1;
+
+	/* sync the strings on first non-whitespace */
+	while (1) {
+		while (isSpace(psz1))
+			psz1++;
+		while (isSpace(psz2))
+			psz2++;
+		if (toUpper(psz1) != toUpper(psz2) || *psz1 == '\0' || *psz2 == '\0')
+			break;
+		psz1++;
+		psz2++;
+	}
+	return *psz1 - *psz2;
 }
 
-/***************************************************************************
-* Map a parameter's string representation to something we can use.
-* Returns False if the parameter string is not recognised, else TRUE.
-***************************************************************************/
+/* Map a parameter's string representation to something we can use.
+ * Returns False if the parameter string is not recognised, else TRUE. */
 static int map_parameter(char *parmname)
 {
-   int iIndex;
+	int iIndex;
 
-   if (*parmname == '-')
-     return(-1);
+	if (*parmname == '-')
+		return -1;
 
-   for (iIndex = 0; parm_table[iIndex].label; iIndex++)
-      if (strwicmp(parm_table[iIndex].label, parmname) == 0)
-         return(iIndex);
+	for (iIndex = 0; parm_table[iIndex].label; iIndex++) {
+		if (strwicmp(parm_table[iIndex].label, parmname) == 0)
+			return iIndex;
+	}
 
-   rprintf(FLOG, "Unknown Parameter encountered: \"%s\"\n", parmname);
-   return(-1);
+	rprintf(FLOG, "Unknown Parameter encountered: \"%s\"\n", parmname);
+	return -1;
 }
 
-
-/***************************************************************************
-* Set a boolean variable from the text value stored in the passed string.
-* Returns True in success, False if the passed string does not correctly
-* represent a boolean.
-***************************************************************************/
+/* Set a boolean variable from the text value stored in the passed string.
+ * Returns True in success, False if the passed string does not correctly
+ * represent a boolean. */
 static BOOL set_boolean(BOOL *pb, char *parmvalue)
 {
-   BOOL bRetval;
-
-   bRetval = True;
-   if (strwicmp(parmvalue, "yes") == 0 ||
-       strwicmp(parmvalue, "true") == 0 ||
-       strwicmp(parmvalue, "1") == 0)
-      *pb = True;
-   else
-      if (strwicmp(parmvalue, "no") == 0 ||
-          strwicmp(parmvalue, "False") == 0 ||
-          strwicmp(parmvalue, "0") == 0)
-         *pb = False;
-      else
-      {
-         rprintf(FLOG, "Badly formed boolean in configuration file: \"%s\".\n",
-               parmvalue);
-         bRetval = False;
-      }
-   return (bRetval);
+	if (strwicmp(parmvalue, "yes") == 0
+	 || strwicmp(parmvalue, "true") == 0
+	 || strwicmp(parmvalue, "1") == 0)
+		*pb = True;
+	else if (strwicmp(parmvalue, "no") == 0
+	      || strwicmp(parmvalue, "False") == 0
+	      || strwicmp(parmvalue, "0") == 0)
+		*pb = False;
+	else {
+		rprintf(FLOG, "Badly formed boolean in configuration file: \"%s\".\n", parmvalue);
+		return False;
+	}
+	return True;
 }
 
-/***************************************************************************
-* Find a service by name. Otherwise works like get_service.
-***************************************************************************/
+/* Find a service by name. Otherwise works like get_service. */
 static int getservicebyname(char *name, service *pserviceDest)
 {
-   int iService;
-
-   for (iService = iNumServices - 1; iService >= 0; iService--)
-      if (strwicmp(iSERVICE(iService).name, name) == 0)
-      {
-         if (pserviceDest != NULL)
-	   copy_service(pserviceDest, pSERVICE(iService));
-         break;
-      }
+	int i;
+
+	for (i = iNumServices - 1; i >= 0; i--) {
+		if (strwicmp(iSERVICE(i).name, name) == 0) {
+			if (pserviceDest != NULL)
+				copy_service(pserviceDest, pSERVICE(i));
+			break;
+		}
+	}
 
-   return (iService);
+	return i;
 }
 
-
-
-/***************************************************************************
-* Copy a service structure to another
-***************************************************************************/
-static void copy_service(service *pserviceDest,
-                         service *pserviceSource)
+/* Copy a service structure to another. */
+static void copy_service(service *pserviceDest, service *pserviceSource)
 {
-  int i;
-
-  for (i=0;parm_table[i].label;i++)
-    if (parm_table[i].ptr && parm_table[i].class == P_LOCAL) {
-	void *def_ptr = parm_table[i].ptr;
-	void *src_ptr =
-	  ((char *)pserviceSource) + PTR_DIFF(def_ptr,&sDefault);
-	void *dest_ptr =
-	  ((char *)pserviceDest) + PTR_DIFF(def_ptr,&sDefault);
-
-	switch (parm_table[i].type)
-	  {
-	  case P_BOOL:
-	  case P_BOOLREV:
-	    *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
-	    break;
-
-	  case P_INTEGER:
-	  case P_ENUM:
-	  case P_OCTAL:
-	    *(int *)dest_ptr = *(int *)src_ptr;
-	    break;
-
-	  case P_CHAR:
-	    *(char *)dest_ptr = *(char *)src_ptr;
-	    break;
-
-	  case P_PATH:
-	  case P_STRING:
-	    string_set(dest_ptr,*(char **)src_ptr);
-	    break;
-
-	  default:
-	    break;
-	  }
-      }
+	int i;
+
+	for (i = 0; parm_table[i].label; i++) {
+		if (parm_table[i].ptr && parm_table[i].class == P_LOCAL) {
+			void *def_ptr = parm_table[i].ptr;
+			void *src_ptr = ((char *)pserviceSource) + PTR_DIFF(def_ptr, &sDefault);
+			void *dest_ptr = ((char *)pserviceDest) + PTR_DIFF(def_ptr, &sDefault);
+
+			switch (parm_table[i].type) {
+			case P_BOOL:
+			case P_BOOLREV:
+				*(BOOL *)dest_ptr = *(BOOL *)src_ptr;
+				break;
+
+			case P_INTEGER:
+			case P_ENUM:
+			case P_OCTAL:
+				*(int *)dest_ptr = *(int *)src_ptr;
+				break;
+
+			case P_CHAR:
+				*(char *)dest_ptr = *(char *)src_ptr;
+				break;
+
+			case P_PATH:
+			case P_STRING:
+				string_set(dest_ptr, *(char **)src_ptr);
+				break;
+
+			default:
+				break;
+			}
+		}
+	}
 }
 
-
-/***************************************************************************
-* Process a parameter for a particular service number. If snum < 0
-* then assume we are in the globals
-***************************************************************************/
+/* Process a parameter. */
 static BOOL lp_do_parameter(int snum, char *parmname, char *parmvalue)
 {
-   int parmnum, i;
-   void *parm_ptr=NULL; /* where we are going to store the result */
-   void *def_ptr=NULL;
-   char *cp;
-
-   parmnum = map_parameter(parmname);
-
-   if (parmnum < 0)
-     {
-       rprintf(FLOG, "IGNORING unknown parameter \"%s\"\n", parmname);
-       return(True);
-     }
-
-   def_ptr = parm_table[parmnum].ptr;
-
-   /* we might point at a service, the default service or a global */
-   if (snum < 0) {
-     parm_ptr = def_ptr;
-   } else {
-       if (parm_table[parmnum].class == P_GLOBAL) {
-	   rprintf(FLOG, "Global parameter %s found in service section!\n",parmname);
-	   return(True);
-	 }
-       parm_ptr = ((char *)pSERVICE(snum)) + PTR_DIFF(def_ptr,&sDefault);
-   }
-
-   /* now switch on the type of variable it is */
-   switch (parm_table[parmnum].type)
-     {
-     case P_BOOL:
-       set_boolean(parm_ptr,parmvalue);
-       break;
-
-     case P_BOOLREV:
-       set_boolean(parm_ptr,parmvalue);
-       *(BOOL *)parm_ptr = ! *(BOOL *)parm_ptr;
-       break;
-
-     case P_INTEGER:
-       *(int *)parm_ptr = atoi(parmvalue);
-       break;
-
-     case P_CHAR:
-       *(char *)parm_ptr = *parmvalue;
-       break;
-
-     case P_OCTAL:
-       sscanf(parmvalue,"%o",(int *)parm_ptr);
-       break;
-
-     case P_PATH:
-       string_set(parm_ptr,parmvalue);
-       if ((cp = *(char**)parm_ptr) != NULL) {
-	   int len = strlen(cp);
-	   while (len > 1 && cp[len-1] == '/') len--;
-	   cp[len] = '\0';
-       }
-       break;
-
-     case P_STRING:
-       string_set(parm_ptr,parmvalue);
-       break;
-
-     case P_GSTRING:
-       strlcpy((char *)parm_ptr,parmvalue,sizeof(pstring));
-       break;
-
-     case P_ENUM:
-	     for (i=0;parm_table[parmnum].enum_list[i].name;i++) {
-		     if (strequal(parmvalue, parm_table[parmnum].enum_list[i].name)) {
-			     *(int *)parm_ptr = parm_table[parmnum].enum_list[i].value;
-			     break;
-		     }
-	     }
-	     if (!parm_table[parmnum].enum_list[i].name) {
-		     if (atoi(parmvalue) > 0)
-			     *(int *)parm_ptr = atoi(parmvalue);
-	     }
-	     break;
-     case P_SEP:
-	     break;
-     }
-
-   return(True);
+	int parmnum, i;
+	void *parm_ptr=NULL; /* where we are going to store the result */
+	void *def_ptr=NULL;
+	char *cp;
+
+	parmnum = map_parameter(parmname);
+
+	if (parmnum < 0) {
+		rprintf(FLOG, "IGNORING unknown parameter \"%s\"\n", parmname);
+		return True;
+	}
+
+	def_ptr = parm_table[parmnum].ptr;
+
+	/* we might point at a service, the default service or a global */
+	if (snum < 0)
+		parm_ptr = def_ptr;
+	else {
+		if (parm_table[parmnum].class == P_GLOBAL) {
+			rprintf(FLOG, "Global parameter %s found in service section!\n", parmname);
+			return True;
+		}
+		parm_ptr = ((char *)pSERVICE(snum)) + PTR_DIFF(def_ptr, &sDefault);
+	}
+
+	/* now switch on the type of variable it is */
+	switch (parm_table[parmnum].type) {
+	case P_BOOL:
+		set_boolean(parm_ptr, parmvalue);
+		break;
+
+	case P_BOOLREV:
+		set_boolean(parm_ptr, parmvalue);
+		*(BOOL *)parm_ptr = ! *(BOOL *)parm_ptr;
+		break;
+
+	case P_INTEGER:
+		*(int *)parm_ptr = atoi(parmvalue);
+		break;
+
+	case P_CHAR:
+		*(char *)parm_ptr = *parmvalue;
+		break;
+
+	case P_OCTAL:
+		sscanf(parmvalue, "%o", (int *)parm_ptr);
+		break;
+
+	case P_PATH:
+		string_set(parm_ptr, parmvalue);
+		if ((cp = *(char**)parm_ptr) != NULL) {
+			int len = strlen(cp);
+			while (len > 1 && cp[len-1] == '/') len--;
+			cp[len] = '\0';
+		}
+		break;
+
+	case P_STRING:
+		string_set(parm_ptr, parmvalue);
+		break;
+
+	case P_GSTRING:
+		strlcpy((char *)parm_ptr, parmvalue, sizeof (pstring));
+		break;
+
+	case P_ENUM:
+		for (i=0;parm_table[parmnum].enum_list[i].name;i++) {
+			if (strequal(parmvalue, parm_table[parmnum].enum_list[i].name)) {
+				*(int *)parm_ptr = parm_table[parmnum].enum_list[i].value;
+				break;
+			}
+		}
+		if (!parm_table[parmnum].enum_list[i].name) {
+			if (atoi(parmvalue) > 0)
+				*(int *)parm_ptr = atoi(parmvalue);
+		}
+		break;
+	case P_SEP:
+		break;
+	}
+
+	return True;
 }
 
-/***************************************************************************
-* Process a parameter.
-***************************************************************************/
+/* Process a parameter.  */
 static BOOL do_parameter(char *parmname, char *parmvalue)
 {
-   return lp_do_parameter(bInGlobalSection?-2:iServiceIndex, parmname, parmvalue);
+	return lp_do_parameter(bInGlobalSection?-2:iServiceIndex, parmname, parmvalue);
 }
 
-/***************************************************************************
-* Process a new section (service). At this stage all sections are services.
-* Later we'll have special sections that permit server parameters to be set.
-* Returns True on success, False on failure.
-***************************************************************************/
+/* Process a new section (rsync module).
+ * Returns True on success, False on failure. */
 static BOOL do_section(char *sectionname)
 {
-   BOOL bRetval;
-   BOOL isglobal = (strwicmp(sectionname, GLOBAL_NAME) == 0);
-   bRetval = False;
-
-   /* if we were in a global section then do the local inits */
-   if (bInGlobalSection && !isglobal)
-     init_locals();
-
-   /* if we've just struck a global section, note the fact. */
-   bInGlobalSection = isglobal;
-
-   /* check for multiple global sections */
-   if (bInGlobalSection)
-   {
-     return(True);
-   }
-
-   if (strchr(sectionname, '/') != NULL) {
-     rprintf(FLOG, "Warning: invalid section name in configuration file: %s\n", sectionname);
-     return False;
-   }
-
-   /* if we have a current service, tidy it up before moving on */
-   bRetval = True;
-
-   if (iServiceIndex >= 0)
-     bRetval = True;
-
-   /* if all is still well, move to the next record in the services array */
-   if (bRetval)
-     {
-       /* We put this here to avoid an odd message order if messages are */
-       /* issued by the post-processing of a previous section. */
-
-       if ((iServiceIndex=add_a_service(&sDefault,sectionname)) < 0)
-	 {
-	   rprintf(FLOG, "Failed to add a new service\n");
-	   return(False);
-	 }
-     }
-
-   return (bRetval);
-}
+	BOOL isglobal = strwicmp(sectionname, GLOBAL_NAME) == 0;
+
+	/* if we were in a global section then do the local inits */
+	if (bInGlobalSection && !isglobal)
+		init_locals();
 
+	/* if we've just struck a global section, note the fact. */
+	bInGlobalSection = isglobal;
 
-/***************************************************************************
-* Load the services array from the services file. Return True on success,
-* False on failure.
-***************************************************************************/
+	/* check for multiple global sections */
+	if (bInGlobalSection)
+		return True;
+
+#if 0
+	/* If we have a current service, tidy it up before moving on. */
+	if (iServiceIndex >= 0) {
+		/* Add any tidy work as needed ... */
+		if (problem)
+			return False;
+	}
+#endif
+
+	if (strchr(sectionname, '/') != NULL) {
+		rprintf(FLOG, "Warning: invalid section name in configuration file: %s\n", sectionname);
+		return False;
+	}
+
+	if ((iServiceIndex = add_a_service(&sDefault, sectionname)) < 0) {
+		rprintf(FLOG, "Failed to add a new module\n");
+		return False;
+	}
+
+	return True;
+}
+
+/* Load the services array from the services file. Return True on success,
+ * False on failure. */
 BOOL lp_load(char *pszFname, int globals_only)
 {
 	pstring n2;
-	BOOL bRetval;
-
-	bRetval = False;
 
 	bInGlobalSection = True;
 
@@ -839,34 +755,27 @@ BOOL lp_load(char *pszFname, int globals_only)
 
 	/* We get sections first, so have to start 'behind' to make up */
 	iServiceIndex = -1;
-	bRetval = pm_process(n2, globals_only?NULL:do_section, do_parameter);
-
-	return (bRetval);
+	return pm_process(n2, globals_only ? NULL : do_section, do_parameter);
 }
 
-
-/***************************************************************************
-* return the max number of services
-***************************************************************************/
+/* Return the max number of services. */
 int lp_numservices(void)
 {
-  return(iNumServices);
+	return iNumServices;
 }
 
-/***************************************************************************
-* Return the number of the service with the given name, or -1 if it doesn't
-* exist. Note that this is a DIFFERENT ANIMAL from the internal function
-* getservicebyname()! This works ONLY if all services have been loaded, and
-* does not copy the found service.
-***************************************************************************/
+/* Return the number of the service with the given name, or -1 if it doesn't
+ * exist. Note that this is a DIFFERENT ANIMAL from the internal function
+ * getservicebyname()! This works ONLY if all services have been loaded,
+ * and does not copy the found service. */
 int lp_number(char *name)
 {
-   int iService;
+	int i;
 
-   for (iService = iNumServices - 1; iService >= 0; iService--)
-      if (strcmp(lp_name(iService), name) == 0)
-         break;
+	for (i = iNumServices - 1; i >= 0; i--) {
+		if (strcmp(lp_name(i), name) == 0)
+			break;
+	}
 
-   return (iService);
+	return i;
 }
-