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