source/param/loadparm.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Parameter loading functions
   4    Copyright (C) Karl Auer 1993-1998
   5
   6    Largely re-written by Andrew Tridgell, September 1994
   7
   8    Copyright (C) Simo Sorce 2001
   9    Copyright (C) Alexander Bokovoy 2002
  10    Copyright (C) Stefan (metze) Metzmacher 2002
  11    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
  12    Copyright (C) Michael Adam 2008
  13
  14    This program is free software; you can redistribute it and/or modify
  15    it under the terms of the GNU General Public License as published by
  16    the Free Software Foundation; either version 3 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26 */
  27
  28 /*
  29  *  Load parameters.
  30  *
  31  *  This module provides suitable callback functions for the params
  32  *  module. It builds the internal table of service details which is
  33  *  then used by the rest of the server.
  34  *
  35  * To add a parameter:
  36  *
  37  * 1) add it to the global or service structure definition
  38  * 2) add it to the parm_table
  39  * 3) add it to the list of available functions (eg: using FN_GLOBAL_STRING())
  40  * 4) If it's a global then initialise it in init_globals. If a local
  41  *    (ie. service) parameter then initialise it in the sDefault structure
  42  *
  43  *
  44  * Notes:
  45  *   The configuration file is processed sequentially for speed. It is NOT
  46  *   accessed randomly as happens in 'real' Windows. For this reason, there
  47  *   is a fair bit of sequence-dependent code here - ie., code which assumes
  48  *   that certain things happen before others. In particular, the code which
  49  *   happens at the boundary between sections is delicately poised, so be
  50  *   careful!
  51  *
  52  */
  53
  54 #include "includes.h"
  55 #include "printing.h"
  56
  57 bool bLoaded = False;
  58
  59 extern enum protocol_types Protocol;
  60 extern userdom_struct current_user_info;
  61
  62 #ifndef GLOBAL_NAME
  63 #define GLOBAL_NAME "global"
  64 #endif
  65
  66 #ifndef PRINTERS_NAME
  67 #define PRINTERS_NAME "printers"
  68 #endif
  69
  70 #ifndef HOMES_NAME
  71 #define HOMES_NAME "homes"
  72 #endif
  73
  74 /* the special value for the include parameter
  75  * to be interpreted not as a file name but to
  76  * trigger loading of the global smb.conf options
  77  * from registry. */
  78 #ifndef INCLUDE_REGISTRY_NAME
  79 #define INCLUDE_REGISTRY_NAME "registry"
  80 #endif
  81
  82 static bool in_client = False;          /* Not in the client by default */
  83 static struct smbconf_csn conf_last_csn;
  84
  85 #define CONFIG_BACKEND_FILE 0
  86 #define CONFIG_BACKEND_REGISTRY 1
  87
  88 static int config_backend = CONFIG_BACKEND_FILE;
  89
  90 /* some helpful bits */
  91 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && (ServicePtrs != NULL) && ServicePtrs[(i)]->valid)
  92 #define VALID(i) (ServicePtrs != NULL && ServicePtrs[i]->valid)
  93
  94 #define USERSHARE_VALID 1
  95 #define USERSHARE_PENDING_DELETE 2
  96
  97 extern int extra_time_offset;
  98
  99 static bool defaults_saved = False;
 100
 101 struct param_opt_struct {
 102         struct param_opt_struct *prev, *next;
 103         char *key;
 104         char *value;
 105         char **list;
 106 };
 107
 108 /*
 109  * This structure describes global (ie., server-wide) parameters.
 110  */
 111 struct global {
 112         int ConfigBackend;
 113         char *smb_ports;
 114         char *dos_charset;
 115         char *unix_charset;
 116         char *display_charset;
 117         char *szPrintcapname;
 118         char *szAddPortCommand;
 119         char *szEnumPortsCommand;
 120         char *szAddPrinterCommand;
 121         char *szDeletePrinterCommand;
 122         char *szOs2DriverMap;
 123         char *szLockDir;
 124         char *szPidDir;
 125         char *szRootdir;
 126         char *szDefaultService;
 127         char *szGetQuota;
 128         char *szSetQuota;
 129         char *szMsgCommand;
 130         char *szServerString;
 131         char *szAutoServices;
 132         char *szPasswdProgram;
 133         char *szPasswdChat;
 134         char *szLogFile;
 135         char *szConfigFile;
 136         char *szSMBPasswdFile;
 137         char *szPrivateDir;
 138         char *szPassdbBackend;
 139         char **szPreloadModules;
 140         char *szPasswordServer;
 141         char *szSocketOptions;
 142         char *szRealm;
 143         char *szAfsUsernameMap;
 144         int iAfsTokenLifetime;
 145         char *szLogNtTokenCommand;
 146         char *szUsernameMap;
 147         char *szLogonScript;
 148         char *szLogonPath;
 149         char *szLogonDrive;
 150         char *szLogonHome;
 151         char **szWINSservers;
 152         char **szInterfaces;
 153         char *szRemoteAnnounce;
 154         char *szRemoteBrowseSync;
 155         char *szSocketAddress;
 156         char *szNISHomeMapName;
 157         char *szAnnounceVersion;        /* This is initialised in init_globals */
 158         char *szWorkgroup;
 159         char *szNetbiosName;
 160         char **szNetbiosAliases;
 161         char *szNetbiosScope;
 162         char *szNameResolveOrder;
 163         char *szPanicAction;
 164         char *szAddUserScript;
 165         char *szRenameUserScript;
 166         char *szDelUserScript;
 167         char *szAddGroupScript;
 168         char *szDelGroupScript;
 169         char *szAddUserToGroupScript;
 170         char *szDelUserFromGroupScript;
 171         char *szSetPrimaryGroupScript;
 172         char *szAddMachineScript;
 173         char *szShutdownScript;
 174         char *szAbortShutdownScript;
 175         char *szUsernameMapScript;
 176         char *szCheckPasswordScript;
 177         char *szWINSHook;
 178         char *szUtmpDir;
 179         char *szWtmpDir;
 180         bool bUtmp;
 181         char *szIdmapUID;
 182         char *szIdmapGID;
 183         bool bPassdbExpandExplicit;
 184         int AlgorithmicRidBase;
 185         char *szTemplateHomedir;
 186         char *szTemplateShell;
 187         char *szWinbindSeparator;
 188         bool bWinbindEnumUsers;
 189         bool bWinbindEnumGroups;
 190         bool bWinbindUseDefaultDomain;
 191         bool bWinbindTrustedDomainsOnly;
 192         bool bWinbindNestedGroups;
 193         int  winbind_expand_groups;
 194         bool bWinbindRefreshTickets;
 195         bool bWinbindOfflineLogon;
 196         bool bWinbindNormalizeNames;
 197         bool bWinbindRpcOnly;
 198         char *szIdmapBackend;
 199         char *szIdmapAllocBackend;
 200         char *szAddShareCommand;
 201         char *szChangeShareCommand;
 202         char *szDeleteShareCommand;
 203         char **szEventLogs;
 204         char *szGuestaccount;
 205         char *szManglingMethod;
 206         char **szServicesList;
 207         char *szUsersharePath;
 208         char *szUsershareTemplateShare;
 209         char **szUsersharePrefixAllowList;
 210         char **szUsersharePrefixDenyList;
 211         int mangle_prefix;
 212         int max_log_size;
 213         char *szLogLevel;
 214         int max_xmit;
 215         int max_mux;
 216         int max_open_files;
 217         int open_files_db_hash_size;
 218         int pwordlevel;
 219         int unamelevel;
 220         int deadtime;
 221         bool getwd_cache;
 222         int maxprotocol;
 223         int minprotocol;
 224         int security;
 225         char **AuthMethods;
 226         bool paranoid_server_security;
 227         int maxdisksize;
 228         int lpqcachetime;
 229         int iMaxSmbdProcesses;
 230         bool bDisableSpoolss;
 231         int syslog;
 232         int os_level;
 233         bool enhanced_browsing;
 234         int max_ttl;
 235         int max_wins_ttl;
 236         int min_wins_ttl;
 237         int lm_announce;
 238         int lm_interval;
 239         int announce_as;        /* This is initialised in init_globals */
 240         int machine_password_timeout;
 241         int map_to_guest;
 242         int oplock_break_wait_time;
 243         int winbind_cache_time;
 244         int winbind_reconnect_delay;
 245         int winbind_max_idle_children;
 246         char **szWinbindNssInfo;
 247         int iLockSpinTime;
 248         char *szLdapMachineSuffix;
 249         char *szLdapUserSuffix;
 250         char *szLdapIdmapSuffix;
 251         char *szLdapGroupSuffix;
 252         int ldap_ssl;
 253         bool ldap_ssl_ads;
 254         char *szLdapSuffix;
 255         char *szLdapAdminDn;
 256         int ldap_debug_level;
 257         int ldap_debug_threshold;
 258         int iAclCompat;
 259         char *szCupsServer;
 260         char *szIPrintServer;
 261         char *ctdbdSocket;
 262         char **szClusterAddresses;
 263         bool clustering;
 264         int ldap_passwd_sync;
 265         int ldap_replication_sleep;
 266         int ldap_timeout; /* This is initialised in init_globals */
 267         int ldap_connection_timeout;
 268         int ldap_page_size;
 269         bool ldap_delete_dn;
 270         bool bMsAddPrinterWizard;
 271         bool bDNSproxy;
 272         bool bWINSsupport;
 273         bool bWINSproxy;
 274         bool bLocalMaster;
 275         int  iPreferredMaster;
 276         int iDomainMaster;
 277         bool bDomainLogons;
 278         char **szInitLogonDelayedHosts;
 279         int InitLogonDelay;
 280         bool bEncryptPasswords;
 281         bool bUpdateEncrypt;
 282         int  clientSchannel;
 283         int  serverSchannel;
 284         bool bNullPasswords;
 285         bool bObeyPamRestrictions;
 286         bool bLoadPrinters;
 287         int PrintcapCacheTime;
 288         bool bLargeReadwrite;
 289         bool bReadRaw;
 290         bool bWriteRaw;
 291         bool bSyslogOnly;
 292         bool bBrowseList;
 293         bool bNISHomeMap;
 294         bool bTimeServer;
 295         bool bBindInterfacesOnly;
 296         bool bPamPasswordChange;
 297         bool bUnixPasswdSync;
 298         bool bPasswdChatDebug;
 299         int iPasswdChatTimeout;
 300         bool bTimestampLogs;
 301         bool bNTSmbSupport;
 302         bool bNTPipeSupport;
 303         bool bNTStatusSupport;
 304         bool bStatCache;
 305         int iMaxStatCacheSize;
 306         bool bKernelOplocks;
 307         bool bAllowTrustedDomains;
 308         bool bLanmanAuth;
 309         bool bNTLMAuth;
 310         bool bUseSpnego;
 311         bool bClientLanManAuth;
 312         bool bClientNTLMv2Auth;
 313         bool bClientPlaintextAuth;
 314         bool bClientUseSpnego;
 315         bool bDebugPrefixTimestamp;
 316         bool bDebugHiresTimestamp;
 317         bool bDebugPid;
 318         bool bDebugUid;
 319         bool bDebugClass;
 320         bool bEnableCoreFiles;
 321         bool bHostMSDfs;
 322         bool bUseMmap;
 323         bool bHostnameLookups;
 324         bool bUnixExtensions;
 325         bool bDisableNetbios;
 326         bool bUseKerberosKeytab;
 327         bool bDeferSharingViolations;
 328         bool bEnablePrivileges;
 329         bool bASUSupport;
 330         bool bUsershareOwnerOnly;
 331         bool bUsershareAllowGuests;
 332         bool bRegistryShares;
 333         int restrict_anonymous;
 334         int name_cache_timeout;
 335         int client_signing;
 336         int server_signing;
 337         int client_ldap_sasl_wrapping;
 338         int iUsershareMaxShares;
 339         int iIdmapCacheTime;
 340         int iIdmapNegativeCacheTime;
 341         bool bResetOnZeroVC;
 342         int iKeepalive;
 343         int iminreceivefile;
 344         struct param_opt_struct *param_opt;
 345         int cups_connection_timeout;
 346 };
 347
 348 static struct global Globals;
 349
 350 /*
 351  * This structure describes a single service.
 352  */
 353 struct service {
 354         bool valid;
 355         bool autoloaded;
 356         int usershare;
 357         time_t usershare_last_mod;
 358         char *szService;
 359         char *szPath;
 360         char *szUsername;
 361         char **szInvalidUsers;
 362         char **szValidUsers;
 363         char **szAdminUsers;
 364         char *szCopy;
 365         char *szInclude;
 366         char *szPreExec;
 367         char *szPostExec;
 368         char *szRootPreExec;
 369         char *szRootPostExec;
 370         char *szCupsOptions;
 371         char *szPrintcommand;
 372         char *szLpqcommand;
 373         char *szLprmcommand;
 374         char *szLppausecommand;
 375         char *szLpresumecommand;
 376         char *szQueuepausecommand;
 377         char *szQueueresumecommand;
 378         char *szPrintername;
 379         char *szPrintjobUsername;
 380         char *szDontdescend;
 381         char **szHostsallow;
 382         char **szHostsdeny;
 383         char *szMagicScript;
 384         char *szMagicOutput;
 385         char *szVetoFiles;
 386         char *szHideFiles;
 387         char *szVetoOplockFiles;
 388         char *comment;
 389         char *force_user;
 390         char *force_group;
 391         char **readlist;
 392         char **writelist;
 393         char **printer_admin;
 394         char *volume;
 395         char *fstype;
 396         char **szVfsObjects;
 397         char *szMSDfsProxy;
 398         char *szAioWriteBehind;
 399         char *szDfree;
 400         int iMinPrintSpace;
 401         int iMaxPrintJobs;
 402         int iMaxReportedPrintJobs;
 403         int iWriteCacheSize;
 404         int iCreate_mask;
 405         int iCreate_force_mode;
 406         int iSecurity_mask;
 407         int iSecurity_force_mode;
 408         int iDir_mask;
 409         int iDir_force_mode;
 410         int iDir_Security_mask;
 411         int iDir_Security_force_mode;
 412         int iMaxConnections;
 413         int iDefaultCase;
 414         int iPrinting;
 415         int iOplockContentionLimit;
 416         int iCSCPolicy;
 417         int iBlock_size;
 418         int iDfreeCacheTime;
 419         bool bPreexecClose;
 420         bool bRootpreexecClose;
 421         int  iCaseSensitive;
 422         bool bCasePreserve;
 423         bool bShortCasePreserve;
 424         bool bHideDotFiles;
 425         bool bHideSpecialFiles;
 426         bool bHideUnReadable;
 427         bool bHideUnWriteableFiles;
 428         bool bBrowseable;
 429         bool bAvailable;
 430         bool bRead_only;
 431         bool bNo_set_dir;
 432         bool bGuest_only;
 433         bool bAdministrative_share;
 434         bool bGuest_ok;
 435         bool bPrint_ok;
 436         bool bMap_system;
 437         bool bMap_hidden;
 438         bool bMap_archive;
 439         bool bStoreDosAttributes;
 440         bool bDmapiSupport;
 441         bool bLocking;
 442         int iStrictLocking;
 443         bool bPosixLocking;
 444         bool bShareModes;
 445         bool bOpLocks;
 446         bool bLevel2OpLocks;
 447         bool bOnlyUser;
 448         bool bMangledNames;
 449         bool bWidelinks;
 450         bool bSymlinks;
 451         bool bSyncAlways;
 452         bool bStrictAllocate;
 453         bool bStrictSync;
 454         char magic_char;
 455         struct bitmap *copymap;
 456         bool bDeleteReadonly;
 457         bool bFakeOplocks;
 458         bool bDeleteVetoFiles;
 459         bool bDosFilemode;
 460         bool bDosFiletimes;
 461         bool bDosFiletimeResolution;
 462         bool bFakeDirCreateTimes;
 463         bool bBlockingLocks;
 464         bool bInheritPerms;
 465         bool bInheritACLS;
 466         bool bInheritOwner;
 467         bool bMSDfsRoot;
 468         bool bUseClientDriver;
 469         bool bDefaultDevmode;
 470         bool bForcePrintername;
 471         bool bNTAclSupport;
 472         bool bForceUnknownAclUser;
 473         bool bUseSendfile;
 474         bool bProfileAcls;
 475         bool bMap_acl_inherit;
 476         bool bAfs_Share;
 477         bool bEASupport;
 478         bool bAclCheckPermissions;
 479         bool bAclMapFullControl;
 480         bool bAclGroupControl;
 481         bool bChangeNotify;
 482         bool bKernelChangeNotify;
 483         int iallocation_roundup_size;
 484         int iAioReadSize;
 485         int iAioWriteSize;
 486         int iMap_readonly;
 487         int iDirectoryNameCacheSize;
 488         int ismb_encrypt;
 489         struct param_opt_struct *param_opt;
 490
 491         char dummy[3];          /* for alignment */
 492 };
 493
 494
 495 /* This is a default service used to prime a services structure */
 496 static struct service sDefault = {
 497         True,                   /* valid */
 498         False,                  /* not autoloaded */
 499         0,                      /* not a usershare */
 500         (time_t)0,              /* No last mod time */
 501         NULL,                   /* szService */
 502         NULL,                   /* szPath */
 503         NULL,                   /* szUsername */
 504         NULL,                   /* szInvalidUsers */
 505         NULL,                   /* szValidUsers */
 506         NULL,                   /* szAdminUsers */
 507         NULL,                   /* szCopy */
 508         NULL,                   /* szInclude */
 509         NULL,                   /* szPreExec */
 510         NULL,                   /* szPostExec */
 511         NULL,                   /* szRootPreExec */
 512         NULL,                   /* szRootPostExec */
 513         NULL,                   /* szCupsOptions */
 514         NULL,                   /* szPrintcommand */
 515         NULL,                   /* szLpqcommand */
 516         NULL,                   /* szLprmcommand */
 517         NULL,                   /* szLppausecommand */
 518         NULL,                   /* szLpresumecommand */
 519         NULL,                   /* szQueuepausecommand */
 520         NULL,                   /* szQueueresumecommand */
 521         NULL,                   /* szPrintername */
 522         NULL,                   /* szPrintjobUsername */
 523         NULL,                   /* szDontdescend */
 524         NULL,                   /* szHostsallow */
 525         NULL,                   /* szHostsdeny */
 526         NULL,                   /* szMagicScript */
 527         NULL,                   /* szMagicOutput */
 528         NULL,                   /* szVetoFiles */
 529         NULL,                   /* szHideFiles */
 530         NULL,                   /* szVetoOplockFiles */
 531         NULL,                   /* comment */
 532         NULL,                   /* force user */
 533         NULL,                   /* force group */
 534         NULL,                   /* readlist */
 535         NULL,                   /* writelist */
 536         NULL,                   /* printer admin */
 537         NULL,                   /* volume */
 538         NULL,                   /* fstype */
 539         NULL,                   /* vfs objects */
 540         NULL,                   /* szMSDfsProxy */
 541         NULL,                   /* szAioWriteBehind */
 542         NULL,                   /* szDfree */
 543         0,                      /* iMinPrintSpace */
 544         1000,                   /* iMaxPrintJobs */
 545         0,                      /* iMaxReportedPrintJobs */
 546         0,                      /* iWriteCacheSize */
 547         0744,                   /* iCreate_mask */
 548         0000,                   /* iCreate_force_mode */
 549         0777,                   /* iSecurity_mask */
 550         0,                      /* iSecurity_force_mode */
 551         0755,                   /* iDir_mask */
 552         0000,                   /* iDir_force_mode */
 553         0777,                   /* iDir_Security_mask */
 554         0,                      /* iDir_Security_force_mode */
 555         0,                      /* iMaxConnections */
 556         CASE_LOWER,             /* iDefaultCase */
 557         DEFAULT_PRINTING,       /* iPrinting */
 558         2,                      /* iOplockContentionLimit */
 559         0,                      /* iCSCPolicy */
 560         1024,                   /* iBlock_size */
 561         0,                      /* iDfreeCacheTime */
 562         False,                  /* bPreexecClose */
 563         False,                  /* bRootpreexecClose */
 564         Auto,                   /* case sensitive */
 565         True,                   /* case preserve */
 566         True,                   /* short case preserve */
 567         True,                   /* bHideDotFiles */
 568         False,                  /* bHideSpecialFiles */
 569         False,                  /* bHideUnReadable */
 570         False,                  /* bHideUnWriteableFiles */
 571         True,                   /* bBrowseable */
 572         True,                   /* bAvailable */
 573         True,                   /* bRead_only */
 574         True,                   /* bNo_set_dir */
 575         False,                  /* bGuest_only */
 576         False,                  /* bAdministrative_share */
 577         False,                  /* bGuest_ok */
 578         False,                  /* bPrint_ok */
 579         False,                  /* bMap_system */
 580         False,                  /* bMap_hidden */
 581         True,                   /* bMap_archive */
 582         False,                  /* bStoreDosAttributes */
 583         False,                  /* bDmapiSupport */
 584         True,                   /* bLocking */
 585         Auto,                   /* iStrictLocking */
 586         True,                   /* bPosixLocking */
 587         True,                   /* bShareModes */
 588         True,                   /* bOpLocks */
 589         True,                   /* bLevel2OpLocks */
 590         False,                  /* bOnlyUser */
 591         True,                   /* bMangledNames */
 592         True,                   /* bWidelinks */
 593         True,                   /* bSymlinks */
 594         False,                  /* bSyncAlways */
 595         False,                  /* bStrictAllocate */
 596         False,                  /* bStrictSync */
 597         '~',                    /* magic char */
 598         NULL,                   /* copymap */
 599         False,                  /* bDeleteReadonly */
 600         False,                  /* bFakeOplocks */
 601         False,                  /* bDeleteVetoFiles */
 602         False,                  /* bDosFilemode */
 603         True,                   /* bDosFiletimes */
 604         False,                  /* bDosFiletimeResolution */
 605         False,                  /* bFakeDirCreateTimes */
 606         True,                   /* bBlockingLocks */
 607         False,                  /* bInheritPerms */
 608         False,                  /* bInheritACLS */
 609         False,                  /* bInheritOwner */
 610         False,                  /* bMSDfsRoot */
 611         False,                  /* bUseClientDriver */
 612         True,                   /* bDefaultDevmode */
 613         False,                  /* bForcePrintername */
 614         True,                   /* bNTAclSupport */
 615         False,                  /* bForceUnknownAclUser */
 616         False,                  /* bUseSendfile */
 617         False,                  /* bProfileAcls */
 618         False,                  /* bMap_acl_inherit */
 619         False,                  /* bAfs_Share */
 620         False,                  /* bEASupport */
 621         True,                   /* bAclCheckPermissions */
 622         True,                   /* bAclMapFullControl */
 623         False,                  /* bAclGroupControl */
 624         True,                   /* bChangeNotify */
 625         True,                   /* bKernelChangeNotify */
 626         SMB_ROUNDUP_ALLOCATION_SIZE,            /* iallocation_roundup_size */
 627         0,                      /* iAioReadSize */
 628         0,                      /* iAioWriteSize */
 629         MAP_READONLY_YES,       /* iMap_readonly */
 630 #ifdef BROKEN_DIRECTORY_HANDLING
 631         0,                      /* iDirectoryNameCacheSize */
 632 #else
 633         100,                    /* iDirectoryNameCacheSize */
 634 #endif
 635         Auto,                   /* ismb_encrypt */
 636         NULL,                   /* Parametric options */
 637
 638         ""                      /* dummy */
 639 };
 640
 641 /* local variables */
 642 static struct service **ServicePtrs = NULL;
 643 static int iNumServices = 0;
 644 static int iServiceIndex = 0;
 645 static struct db_context *ServiceHash;
 646 static int *invalid_services = NULL;
 647 static int num_invalid_services = 0;
 648 static bool bInGlobalSection = True;
 649 static bool bGlobalOnly = False;
 650 static int server_role;
 651 static int default_server_announce;
 652
 653 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
 654
 655 /* prototypes for the special type handlers */
 656 static bool handle_include( int snum, const char *pszParmValue, char **ptr);
 657 static bool handle_copy( int snum, const char *pszParmValue, char **ptr);
 658 static bool handle_netbios_name( int snum, const char *pszParmValue, char **ptr);
 659 static bool handle_idmap_uid( int snum, const char *pszParmValue, char **ptr);
 660 static bool handle_idmap_gid( int snum, const char *pszParmValue, char **ptr);
 661 static bool handle_debug_list( int snum, const char *pszParmValue, char **ptr );
 662 static bool handle_workgroup( int snum, const char *pszParmValue, char **ptr );
 663 static bool handle_netbios_aliases( int snum, const char *pszParmValue, char **ptr );
 664 static bool handle_netbios_scope( int snum, const char *pszParmValue, char **ptr );
 665 static bool handle_charset( int snum, const char *pszParmValue, char **ptr );
 666 static bool handle_printing( int snum, const char *pszParmValue, char **ptr);
 667 static bool handle_ldap_debug_level( int snum, const char *pszParmValue, char **ptr);
 668
 669 static void set_server_role(void);
 670 static void set_default_server_announce_type(void);
 671 static void set_allowed_client_auth(void);
 672
 673 static void add_to_file_list(const char *fname, const char *subfname);
 674
 675 static const struct enum_list enum_protocol[] = {
 676         {PROTOCOL_NT1, "NT1"},
 677         {PROTOCOL_LANMAN2, "LANMAN2"},
 678         {PROTOCOL_LANMAN1, "LANMAN1"},
 679         {PROTOCOL_CORE, "CORE"},
 680         {PROTOCOL_COREPLUS, "COREPLUS"},
 681         {PROTOCOL_COREPLUS, "CORE+"},
 682         {-1, NULL}
 683 };
 684
 685 static const struct enum_list enum_security[] = {
 686         {SEC_SHARE, "SHARE"},
 687         {SEC_USER, "USER"},
 688         {SEC_SERVER, "SERVER"},
 689         {SEC_DOMAIN, "DOMAIN"},
 690 #ifdef HAVE_ADS
 691         {SEC_ADS, "ADS"},
 692 #endif
 693         {-1, NULL}
 694 };
 695
 696 static const struct enum_list enum_printing[] = {
 697         {PRINT_SYSV, "sysv"},
 698         {PRINT_AIX, "aix"},
 699         {PRINT_HPUX, "hpux"},
 700         {PRINT_BSD, "bsd"},
 701         {PRINT_QNX, "qnx"},
 702         {PRINT_PLP, "plp"},
 703         {PRINT_LPRNG, "lprng"},
 704         {PRINT_CUPS, "cups"},
 705         {PRINT_IPRINT, "iprint"},
 706         {PRINT_LPRNT, "nt"},
 707         {PRINT_LPROS2, "os2"},
 708 #ifdef DEVELOPER
 709         {PRINT_TEST, "test"},
 710         {PRINT_VLP, "vlp"},
 711 #endif /* DEVELOPER */
 712         {-1, NULL}
 713 };
 714
 715 static const struct enum_list enum_ldap_sasl_wrapping[] = {
 716         {0, "plain"},
 717         {ADS_AUTH_SASL_SIGN, "sign"},
 718         {ADS_AUTH_SASL_SEAL, "seal"},
 719         {-1, NULL}
 720 };
 721
 722 static const struct enum_list enum_ldap_ssl[] = {
 723         {LDAP_SSL_OFF, "no"},
 724         {LDAP_SSL_OFF, "off"},
 725         {LDAP_SSL_START_TLS, "start tls"},
 726         {LDAP_SSL_START_TLS, "start_tls"},
 727         {-1, NULL}
 728 };
 729
 730 static const struct enum_list enum_ldap_passwd_sync[] = {
 731         {LDAP_PASSWD_SYNC_OFF, "no"},
 732         {LDAP_PASSWD_SYNC_OFF, "off"},
 733         {LDAP_PASSWD_SYNC_ON, "yes"},
 734         {LDAP_PASSWD_SYNC_ON, "on"},
 735         {LDAP_PASSWD_SYNC_ONLY, "only"},
 736         {-1, NULL}
 737 };
 738
 739 /* Types of machine we can announce as. */
 740 #define ANNOUNCE_AS_NT_SERVER 1
 741 #define ANNOUNCE_AS_WIN95 2
 742 #define ANNOUNCE_AS_WFW 3
 743 #define ANNOUNCE_AS_NT_WORKSTATION 4
 744
 745 static const struct enum_list enum_announce_as[] = {
 746         {ANNOUNCE_AS_NT_SERVER, "NT"},
 747         {ANNOUNCE_AS_NT_SERVER, "NT Server"},
 748         {ANNOUNCE_AS_NT_WORKSTATION, "NT Workstation"},
 749         {ANNOUNCE_AS_WIN95, "win95"},
 750         {ANNOUNCE_AS_WFW, "WfW"},
 751         {-1, NULL}
 752 };
 753
 754 static const struct enum_list enum_map_readonly[] = {
 755         {MAP_READONLY_NO, "no"},
 756         {MAP_READONLY_NO, "false"},
 757         {MAP_READONLY_NO, "0"},
 758         {MAP_READONLY_YES, "yes"},
 759         {MAP_READONLY_YES, "true"},
 760         {MAP_READONLY_YES, "1"},
 761         {MAP_READONLY_PERMISSIONS, "permissions"},
 762         {MAP_READONLY_PERMISSIONS, "perms"},
 763         {-1, NULL}
 764 };
 765
 766 static const struct enum_list enum_case[] = {
 767         {CASE_LOWER, "lower"},
 768         {CASE_UPPER, "upper"},
 769         {-1, NULL}
 770 };
 771
 772 static const struct enum_list enum_bool_auto[] = {
 773         {False, "No"},
 774         {False, "False"},
 775         {False, "0"},
 776         {True, "Yes"},
 777         {True, "True"},
 778         {True, "1"},
 779         {Auto, "Auto"},
 780         {-1, NULL}
 781 };
 782
 783 /* Client-side offline caching policy types */
 784 #define CSC_POLICY_MANUAL 0
 785 #define CSC_POLICY_DOCUMENTS 1
 786 #define CSC_POLICY_PROGRAMS 2
 787 #define CSC_POLICY_DISABLE 3
 788
 789 static const struct enum_list enum_csc_policy[] = {
 790         {CSC_POLICY_MANUAL, "manual"},
 791         {CSC_POLICY_DOCUMENTS, "documents"},
 792         {CSC_POLICY_PROGRAMS, "programs"},
 793         {CSC_POLICY_DISABLE, "disable"},
 794         {-1, NULL}
 795 };
 796
 797 /* SMB signing types. */
 798 static const struct enum_list enum_smb_signing_vals[] = {
 799         {False, "No"},
 800         {False, "False"},
 801         {False, "0"},
 802         {False, "Off"},
 803         {False, "disabled"},
 804         {True, "Yes"},
 805         {True, "True"},
 806         {True, "1"},
 807         {True, "On"},
 808         {True, "enabled"},
 809         {Auto, "auto"},
 810         {Required, "required"},
 811         {Required, "mandatory"},
 812         {Required, "force"},
 813         {Required, "forced"},
 814         {Required, "enforced"},
 815         {-1, NULL}
 816 };
 817
 818 /* ACL compatibility options. */
 819 static const struct enum_list enum_acl_compat_vals[] = {
 820     { ACL_COMPAT_AUTO, "auto" },
 821     { ACL_COMPAT_WINNT, "winnt" },
 822     { ACL_COMPAT_WIN2K, "win2k" },
 823     { -1, NULL}
 824 };
 825
 826 /*
 827    Do you want session setups at user level security with a invalid
 828    password to be rejected or allowed in as guest? WinNT rejects them
 829    but it can be a pain as it means "net view" needs to use a password
 830
 831    You have 3 choices in the setting of map_to_guest:
 832
 833    "Never" means session setups with an invalid password
 834    are rejected. This is the default.
 835
 836    "Bad User" means session setups with an invalid password
 837    are rejected, unless the username does not exist, in which case it
 838    is treated as a guest login
 839
 840    "Bad Password" means session setups with an invalid password
 841    are treated as a guest login
 842
 843    Note that map_to_guest only has an effect in user or server
 844    level security.
 845 */
 846
 847 static const struct enum_list enum_map_to_guest[] = {
 848         {NEVER_MAP_TO_GUEST, "Never"},
 849         {MAP_TO_GUEST_ON_BAD_USER, "Bad User"},
 850         {MAP_TO_GUEST_ON_BAD_PASSWORD, "Bad Password"},
 851         {MAP_TO_GUEST_ON_BAD_UID, "Bad Uid"},
 852         {-1, NULL}
 853 };
 854
 855 /* Config backend options */
 856
 857 static const struct enum_list enum_config_backend[] = {
 858         {CONFIG_BACKEND_FILE, "file"},
 859         {CONFIG_BACKEND_REGISTRY, "registry"},
 860         {-1, NULL}
 861 };
 862
 863 /* Note: We do not initialise the defaults union - it is not allowed in ANSI C
 864  *
 865  * The FLAG_HIDE is explicit. Parameters set this way do NOT appear in any edit
 866  * screen in SWAT. This is used to exclude parameters as well as to squash all
 867  * parameters that have been duplicated by pseudonyms.
 868  *
 869  * NOTE: To display a parameter in BASIC view set FLAG_BASIC
 870  *       Any parameter that does NOT have FLAG_ADVANCED will not disply at all
 871  *       Set FLAG_SHARE and FLAG_PRINT to specifically display parameters in
 872  *        respective views.
 873  *
 874  * NOTE2: Handling of duplicated (synonym) parameters:
 875  *      Only the first occurance of a parameter should be enabled by FLAG_BASIC
 876  *      and/or FLAG_ADVANCED. All duplicates following the first mention should be
 877  *      set to FLAG_HIDE. ie: Make you must place the parameter that has the preferred
 878  *      name first, and all synonyms must follow it with the FLAG_HIDE attribute.
 879  */
 880
 881 static struct parm_struct parm_table[] = {
 882         {N_("Base Options"), P_SEP, P_SEPARATOR},
 883
 884         {
 885                 .label          = "dos charset",
 886                 .type           = P_STRING,
 887                 .p_class        = P_GLOBAL,
 888                 .ptr            = &Globals.dos_charset,
 889                 .special        = handle_charset,
 890                 .enum_list      = NULL,
 891                 .flags          = FLAG_ADVANCED
 892         },
 893         {
 894                 .label          = "unix charset",
 895                 .type           = P_STRING,
 896                 .p_class        = P_GLOBAL,
 897                 .ptr            = &Globals.unix_charset,
 898                 .special        = handle_charset,
 899                 .enum_list      = NULL,
 900                 .flags          = FLAG_ADVANCED
 901         },
 902         {
 903                 .label          = "display charset",
 904                 .type           = P_STRING,
 905                 .p_class        = P_GLOBAL,
 906                 .ptr            = &Globals.display_charset,
 907                 .special        = handle_charset,
 908                 .enum_list      = NULL,
 909                 .flags          = FLAG_ADVANCED
 910         },
 911         {
 912                 .label          = "comment",
 913                 .type           = P_STRING,
 914                 .p_class        = P_LOCAL,
 915                 .ptr            = &sDefault.comment,
 916                 .special        = NULL,
 917                 .enum_list      = NULL,
 918                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT
 919         },
 920         {
 921                 .label          = "path",
 922                 .type           = P_STRING,
 923                 .p_class        = P_LOCAL,
 924                 .ptr            = &sDefault.szPath,
 925                 .special        = NULL,
 926                 .enum_list      = NULL,
 927                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
 928         },
 929         {
 930                 .label          = "directory",
 931                 .type           = P_STRING,
 932                 .p_class        = P_LOCAL,
 933                 .ptr            = &sDefault.szPath,
 934                 .special        = NULL,
 935                 .enum_list      = NULL,
 936                 .flags          = FLAG_HIDE,
 937         },
 938         {
 939                 .label          = "workgroup",
 940                 .type           = P_USTRING,
 941                 .p_class        = P_GLOBAL,
 942                 .ptr            = &Globals.szWorkgroup,
 943                 .special        = handle_workgroup,
 944                 .enum_list      = NULL,
 945                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
 946         },
 947 #ifdef WITH_ADS
 948         {
 949                 .label          = "realm",
 950                 .type           = P_USTRING,
 951                 .p_class        = P_GLOBAL,
 952                 .ptr            = &Globals.szRealm,
 953                 .special        = NULL,
 954                 .enum_list      = NULL,
 955                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
 956         },
 957 #endif
 958         {
 959                 .label          = "netbios name",
 960                 .type           = P_USTRING,
 961                 .p_class        = P_GLOBAL,
 962                 .ptr            = &Globals.szNetbiosName,
 963                 .special        = handle_netbios_name,
 964                 .enum_list      = NULL,
 965                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
 966         },
 967         {
 968                 .label          = "netbios aliases",
 969                 .type           = P_LIST,
 970                 .p_class        = P_GLOBAL,
 971                 .ptr            = &Globals.szNetbiosAliases,
 972                 .special        = handle_netbios_aliases,
 973                 .enum_list      = NULL,
 974                 .flags          = FLAG_ADVANCED,
 975         },
 976         {
 977                 .label          = "netbios scope",
 978                 .type           = P_USTRING,
 979                 .p_class        = P_GLOBAL,
 980                 .ptr            = &Globals.szNetbiosScope,
 981                 .special        = handle_netbios_scope,
 982                 .enum_list      = NULL,
 983                 .flags          = FLAG_ADVANCED,
 984         },
 985         {
 986                 .label          = "server string",
 987                 .type           = P_STRING,
 988                 .p_class        = P_GLOBAL,
 989                 .ptr            = &Globals.szServerString,
 990                 .special        = NULL,
 991                 .enum_list      = NULL,
 992                 .flags          = FLAG_BASIC | FLAG_ADVANCED,
 993         },
 994         {
 995                 .label          = "interfaces",
 996                 .type           = P_LIST,
 997                 .p_class        = P_GLOBAL,
 998                 .ptr            = &Globals.szInterfaces,
 999                 .special        = NULL,
1000                 .enum_list      = NULL,
1001                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
1002         },
1003         {
1004                 .label          = "bind interfaces only",
1005                 .type           = P_BOOL,
1006                 .p_class        = P_GLOBAL,
1007                 .ptr            = &Globals.bBindInterfacesOnly,
1008                 .special        = NULL,
1009                 .enum_list      = NULL,
1010                 .flags          = FLAG_ADVANCED | FLAG_WIZARD,
1011         },
1012         {
1013                 .label          = "config backend",
1014                 .type           = P_ENUM,
1015                 .p_class        = P_GLOBAL,
1016                 .ptr            = &Globals.ConfigBackend,
1017                 .special        = NULL,
1018                 .enum_list      = enum_config_backend,
1019                 .flags          = FLAG_ADVANCED,
1020         },
1021
1022         {N_("Security Options"), P_SEP, P_SEPARATOR},
1023
1024         {
1025                 .label          = "security",
1026                 .type           = P_ENUM,
1027                 .p_class        = P_GLOBAL,
1028                 .ptr            = &Globals.security,
1029                 .special        = NULL,
1030                 .enum_list      = enum_security,
1031                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
1032         },
1033         {
1034                 .label          = "auth methods",
1035                 .type           = P_LIST,
1036                 .p_class        = P_GLOBAL,
1037                 .ptr            = &Globals.AuthMethods,
1038                 .special        = NULL,
1039                 .enum_list      = NULL,
1040                 .flags          = FLAG_ADVANCED,
1041         },
1042         {
1043                 .label          = "encrypt passwords",
1044                 .type           = P_BOOL,
1045                 .p_class        = P_GLOBAL,
1046                 .ptr            = &Globals.bEncryptPasswords,
1047                 .special        = NULL,
1048                 .enum_list      = NULL,
1049                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
1050         },
1051         {
1052                 .label          = "update encrypted",
1053                 .type           = P_BOOL,
1054                 .p_class        = P_GLOBAL,
1055                 .ptr            = &Globals.bUpdateEncrypt,
1056                 .special        = NULL,
1057                 .enum_list      = NULL,
1058                 .flags          = FLAG_ADVANCED,
1059         },
1060         {
1061                 .label          = "client schannel",
1062                 .type           = P_ENUM,
1063                 .p_class        = P_GLOBAL,
1064                 .ptr            = &Globals.clientSchannel,
1065                 .special        = NULL,
1066                 .enum_list      = enum_bool_auto,
1067                 .flags          = FLAG_BASIC | FLAG_ADVANCED,
1068         },
1069         {
1070                 .label          = "server schannel",
1071                 .type           = P_ENUM,
1072                 .p_class        = P_GLOBAL,
1073                 .ptr            = &Globals.serverSchannel,
1074                 .special        = NULL,
1075                 .enum_list      = enum_bool_auto,
1076                 .flags          = FLAG_BASIC | FLAG_ADVANCED,
1077         },
1078         {
1079                 .label          = "allow trusted domains",
1080                 .type           = P_BOOL,
1081                 .p_class        = P_GLOBAL,
1082                 .ptr            = &Globals.bAllowTrustedDomains,
1083                 .special        = NULL,
1084                 .enum_list      = NULL,
1085                 .flags          = FLAG_ADVANCED,
1086         },
1087         {
1088                 .label          = "map to guest",
1089                 .type           = P_ENUM,
1090                 .p_class        = P_GLOBAL,
1091                 .ptr            = &Globals.map_to_guest,
1092                 .special        = NULL,
1093                 .enum_list      = enum_map_to_guest,
1094                 .flags          = FLAG_ADVANCED,
1095         },
1096         {
1097                 .label          = "null passwords",
1098                 .type           = P_BOOL,
1099                 .p_class        = P_GLOBAL,
1100                 .ptr            = &Globals.bNullPasswords,
1101                 .special        = NULL,
1102                 .enum_list      = NULL,
1103                 .flags          = FLAG_ADVANCED,
1104         },
1105         {
1106                 .label          = "obey pam restrictions",
1107                 .type           = P_BOOL,
1108                 .p_class        = P_GLOBAL,
1109                 .ptr            = &Globals.bObeyPamRestrictions,
1110                 .special        = NULL,
1111                 .enum_list      = NULL,
1112                 .flags          = FLAG_ADVANCED,
1113         },
1114         {
1115                 .label          = "password server",
1116                 .type           = P_STRING,
1117                 .p_class        = P_GLOBAL,
1118                 .ptr            = &Globals.szPasswordServer,
1119                 .special        = NULL,
1120                 .enum_list      = NULL,
1121                 .flags          = FLAG_ADVANCED | FLAG_WIZARD,
1122         },
1123         {
1124                 .label          = "smb passwd file",
1125                 .type           = P_STRING,
1126                 .p_class        = P_GLOBAL,
1127                 .ptr            = &Globals.szSMBPasswdFile,
1128                 .special        = NULL,
1129                 .enum_list      = NULL,
1130                 .flags          = FLAG_ADVANCED,
1131         },
1132         {
1133                 .label          = "private dir",
1134                 .type           = P_STRING,
1135                 .p_class        = P_GLOBAL,
1136                 .ptr            = &Globals.szPrivateDir,
1137                 .special        = NULL,
1138                 .enum_list      = NULL,
1139                 .flags          = FLAG_ADVANCED,
1140         },
1141         {
1142                 .label          = "passdb backend",
1143                 .type           = P_STRING,
1144                 .p_class        = P_GLOBAL,
1145                 .ptr            = &Globals.szPassdbBackend,
1146                 .special        = NULL,
1147                 .enum_list      = NULL,
1148                 .flags          = FLAG_ADVANCED | FLAG_WIZARD,
1149         },
1150         {
1151                 .label          = "algorithmic rid base",
1152                 .type           = P_INTEGER,
1153                 .p_class        = P_GLOBAL,
1154                 .ptr            = &Globals.AlgorithmicRidBase,
1155                 .special        = NULL,
1156                 .enum_list      = NULL,
1157                 .flags          = FLAG_ADVANCED,
1158         },
1159         {
1160                 .label          = "root directory",
1161                 .type           = P_STRING,
1162                 .p_class        = P_GLOBAL,
1163                 .ptr            = &Globals.szRootdir,
1164                 .special        = NULL,
1165                 .enum_list      = NULL,
1166                 .flags          = FLAG_ADVANCED,
1167         },
1168         {
1169                 .label          = "root dir",
1170                 .type           = P_STRING,
1171                 .p_class        = P_GLOBAL,
1172                 .ptr            = &Globals.szRootdir,
1173                 .special        = NULL,
1174                 .enum_list      = NULL,
1175                 .flags          = FLAG_HIDE,
1176         },
1177         {
1178                 .label          = "root",
1179                 .type           = P_STRING,
1180                 .p_class        = P_GLOBAL,
1181                 .ptr            = &Globals.szRootdir,
1182                 .special        = NULL,
1183                 .enum_list      = NULL,
1184                 .flags          = FLAG_HIDE,
1185         },
1186         {
1187                 .label          = "guest account",
1188                 .type           = P_STRING,
1189                 .p_class        = P_GLOBAL,
1190                 .ptr            = &Globals.szGuestaccount,
1191                 .special        = NULL,
1192                 .enum_list      = NULL,
1193                 .flags          = FLAG_BASIC | FLAG_ADVANCED,
1194         },
1195         {
1196                 .label          = "enable privileges",
1197                 .type           = P_BOOL,
1198                 .p_class        = P_GLOBAL,
1199                 .ptr            = &Globals.bEnablePrivileges,
1200                 .special        = NULL,
1201                 .enum_list      = NULL,
1202                 .flags          = FLAG_ADVANCED,
1203         },
1204
1205         {
1206                 .label          = "pam password change",
1207                 .type           = P_BOOL,
1208                 .p_class        = P_GLOBAL,
1209                 .ptr            = &Globals.bPamPasswordChange,
1210                 .special        = NULL,
1211                 .enum_list      = NULL,
1212                 .flags          = FLAG_ADVANCED,
1213         },
1214         {
1215                 .label          = "passwd program",
1216                 .type           = P_STRING,
1217                 .p_class        = P_GLOBAL,
1218                 .ptr            = &Globals.szPasswdProgram,
1219                 .special        = NULL,
1220                 .enum_list      = NULL,
1221                 .flags          = FLAG_ADVANCED,
1222         },
1223         {
1224                 .label          = "passwd chat",
1225                 .type           = P_STRING,
1226                 .p_class        = P_GLOBAL,
1227                 .ptr            = &Globals.szPasswdChat,
1228                 .special        = NULL,
1229                 .enum_list      = NULL,
1230                 .flags          = FLAG_ADVANCED,
1231         },
1232         {
1233                 .label          = "passwd chat debug",
1234                 .type           = P_BOOL,
1235                 .p_class        = P_GLOBAL,
1236                 .ptr            = &Globals.bPasswdChatDebug,
1237                 .special        = NULL,
1238                 .enum_list      = NULL,
1239                 .flags          = FLAG_ADVANCED,
1240         },
1241         {
1242                 .label          = "passwd chat timeout",
1243                 .type           = P_INTEGER,
1244                 .p_class        = P_GLOBAL,
1245                 .ptr            = &Globals.iPasswdChatTimeout,
1246                 .special        = NULL,
1247                 .enum_list      = NULL,
1248                 .flags          = FLAG_ADVANCED,
1249         },
1250         {
1251                 .label          = "check password script",
1252                 .type           = P_STRING,
1253                 .p_class        = P_GLOBAL,
1254                 .ptr            = &Globals.szCheckPasswordScript,
1255                 .special        = NULL,
1256                 .enum_list      = NULL,
1257                 .flags          = FLAG_ADVANCED,
1258         },
1259         {
1260                 .label          = "username map",
1261                 .type           = P_STRING,
1262                 .p_class        = P_GLOBAL,
1263                 .ptr            = &Globals.szUsernameMap,
1264                 .special        = NULL,
1265                 .enum_list      = NULL,
1266                 .flags          = FLAG_ADVANCED,
1267         },
1268         {
1269                 .label          = "password level",
1270                 .type           = P_INTEGER,
1271                 .p_class        = P_GLOBAL,
1272                 .ptr            = &Globals.pwordlevel,
1273                 .special        = NULL,
1274                 .enum_list      = NULL,
1275                 .flags          = FLAG_ADVANCED,
1276         },
1277         {
1278                 .label          = "username level",
1279                 .type           = P_INTEGER,
1280                 .p_class        = P_GLOBAL,
1281                 .ptr            = &Globals.unamelevel,
1282                 .special        = NULL,
1283                 .enum_list      = NULL,
1284                 .flags          = FLAG_ADVANCED,
1285         },
1286         {
1287                 .label          = "unix password sync",
1288                 .type           = P_BOOL,
1289                 .p_class        = P_GLOBAL,
1290                 .ptr            = &Globals.bUnixPasswdSync,
1291                 .special        = NULL,
1292                 .enum_list      = NULL,
1293                 .flags          = FLAG_ADVANCED,
1294         },
1295         {
1296                 .label          = "restrict anonymous",
1297                 .type           = P_INTEGER,
1298                 .p_class        = P_GLOBAL,
1299                 .ptr            = &Globals.restrict_anonymous,
1300                 .special        = NULL,
1301                 .enum_list      = NULL,
1302                 .flags          = FLAG_ADVANCED,
1303         },
1304         {
1305                 .label          = "lanman auth",
1306                 .type           = P_BOOL,
1307                 .p_class        = P_GLOBAL,
1308                 .ptr            = &Globals.bLanmanAuth,
1309                 .special        = NULL,
1310                 .enum_list      = NULL,
1311                 .flags          = FLAG_ADVANCED,
1312         },
1313         {
1314                 .label          = "ntlm auth",
1315                 .type           = P_BOOL,
1316                 .p_class        = P_GLOBAL,
1317                 .ptr            = &Globals.bNTLMAuth,
1318                 .special        = NULL,
1319                 .enum_list      = NULL,
1320                 .flags          = FLAG_ADVANCED,
1321         },
1322         {
1323                 .label          = "client NTLMv2 auth",
1324                 .type           = P_BOOL,
1325                 .p_class        = P_GLOBAL,
1326                 .ptr            = &Globals.bClientNTLMv2Auth,
1327                 .special        = NULL,
1328                 .enum_list      = NULL,
1329                 .flags          = FLAG_ADVANCED,
1330         },
1331         {
1332                 .label          = "client lanman auth",
1333                 .type           = P_BOOL,
1334                 .p_class        = P_GLOBAL,
1335                 .ptr            = &Globals.bClientLanManAuth,
1336                 .special        = NULL,
1337                 .enum_list      = NULL,
1338                 .flags          = FLAG_ADVANCED,
1339         },
1340         {
1341                 .label          = "client plaintext auth",
1342                 .type           = P_BOOL,
1343                 .p_class        = P_GLOBAL,
1344                 .ptr            = &Globals.bClientPlaintextAuth,
1345                 .special        = NULL,
1346                 .enum_list      = NULL,
1347                 .flags          = FLAG_ADVANCED,
1348         },
1349         {
1350                 .label          = "username",
1351                 .type           = P_STRING,
1352                 .p_class        = P_LOCAL,
1353                 .ptr            = &sDefault.szUsername,
1354                 .special        = NULL,
1355                 .enum_list      = NULL,
1356                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1357         },
1358         {
1359                 .label          = "user",
1360                 .type           = P_STRING,
1361                 .p_class        = P_LOCAL,
1362                 .ptr            = &sDefault.szUsername,
1363                 .special        = NULL,
1364                 .enum_list      = NULL,
1365                 .flags          = FLAG_HIDE,
1366         },
1367         {
1368                 .label          = "users",
1369                 .type           = P_STRING,
1370                 .p_class        = P_LOCAL,
1371                 .ptr            = &sDefault.szUsername,
1372                 .special        = NULL,
1373                 .enum_list      = NULL,
1374                 .flags          = FLAG_HIDE,
1375         },
1376         {
1377                 .label          = "invalid users",
1378                 .type           = P_LIST,
1379                 .p_class        = P_LOCAL,
1380                 .ptr            = &sDefault.szInvalidUsers,
1381                 .special        = NULL,
1382                 .enum_list      = NULL,
1383                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1384         },
1385         {
1386                 .label          = "valid users",
1387                 .type           = P_LIST,
1388                 .p_class        = P_LOCAL,
1389                 .ptr            = &sDefault.szValidUsers,
1390                 .special        = NULL,
1391                 .enum_list      = NULL,
1392                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1393         },
1394         {
1395                 .label          = "admin users",
1396                 .type           = P_LIST,
1397                 .p_class        = P_LOCAL,
1398                 .ptr            = &sDefault.szAdminUsers,
1399                 .special        = NULL,
1400                 .enum_list      = NULL,
1401                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1402         },
1403         {
1404                 .label          = "read list",
1405                 .type           = P_LIST,
1406                 .p_class        = P_LOCAL,
1407                 .ptr            = &sDefault.readlist,
1408                 .special        = NULL,
1409                 .enum_list      = NULL,
1410                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1411         },
1412         {
1413                 .label          = "write list",
1414                 .type           = P_LIST,
1415                 .p_class        = P_LOCAL,
1416                 .ptr            = &sDefault.writelist,
1417                 .special        = NULL,
1418                 .enum_list      = NULL,
1419                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1420         },
1421         {
1422                 .label          = "printer admin",
1423                 .type           = P_LIST,
1424                 .p_class        = P_LOCAL,
1425                 .ptr            = &sDefault.printer_admin,
1426                 .special        = NULL,
1427                 .enum_list      = NULL,
1428                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_PRINT | FLAG_DEPRECATED,
1429         },
1430         {
1431                 .label          = "force user",
1432                 .type           = P_STRING,
1433                 .p_class        = P_LOCAL,
1434                 .ptr            = &sDefault.force_user,
1435                 .special        = NULL,
1436                 .enum_list      = NULL,
1437                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
1438         },
1439         {
1440                 .label          = "force group",
1441                 .type           = P_STRING,
1442                 .p_class        = P_LOCAL,
1443                 .ptr            = &sDefault.force_group,
1444                 .special        = NULL,
1445                 .enum_list      = NULL,
1446                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
1447         },
1448         {
1449                 .label          = "group",
1450                 .type           = P_STRING,
1451                 .p_class        = P_LOCAL,
1452                 .ptr            = &sDefault.force_group,
1453                 .special        = NULL,
1454                 .enum_list      = NULL,
1455                 .flags          = FLAG_ADVANCED,
1456         },
1457         {
1458                 .label          = "read only",
1459                 .type           = P_BOOL,
1460                 .p_class        = P_LOCAL,
1461                 .ptr            = &sDefault.bRead_only,
1462                 .special        = NULL,
1463                 .enum_list      = NULL,
1464                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE,
1465         },
1466         {
1467                 .label          = "write ok",
1468                 .type           = P_BOOLREV,
1469                 .p_class        = P_LOCAL,
1470                 .ptr            = &sDefault.bRead_only,
1471                 .special        = NULL,
1472                 .enum_list      = NULL,
1473                 .flags          = FLAG_HIDE,
1474         },
1475         {
1476                 .label          = "writeable",
1477                 .type           = P_BOOLREV,
1478                 .p_class        = P_LOCAL,
1479                 .ptr            = &sDefault.bRead_only,
1480                 .special        = NULL,
1481                 .enum_list      = NULL,
1482                 .flags          = FLAG_HIDE,
1483         },
1484         {
1485                 .label          = "writable",
1486                 .type           = P_BOOLREV,
1487                 .p_class        = P_LOCAL,
1488                 .ptr            = &sDefault.bRead_only,
1489                 .special        = NULL,
1490                 .enum_list      = NULL,
1491                 .flags          = FLAG_HIDE,
1492         },
1493         {
1494                 .label          = "acl check permissions",
1495                 .type           = P_BOOL,
1496                 .p_class        = P_LOCAL,
1497                 .ptr            = &sDefault.bAclCheckPermissions,
1498                 .special        = NULL,
1499                 .enum_list      = NULL,
1500                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1501         },
1502         {
1503                 .label          = "acl group control",
1504                 .type           = P_BOOL,
1505                 .p_class        = P_LOCAL,
1506                 .ptr            = &sDefault.bAclGroupControl,
1507                 .special        = NULL,
1508                 .enum_list      = NULL,
1509                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1510         },
1511         {
1512                 .label          = "acl map full control",
1513                 .type           = P_BOOL,
1514                 .p_class        = P_LOCAL,
1515                 .ptr            = &sDefault.bAclMapFullControl,
1516                 .special        = NULL,
1517                 .enum_list      = NULL,
1518                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1519         },
1520         {
1521                 .label          = "create mask",
1522                 .type           = P_OCTAL,
1523                 .p_class        = P_LOCAL,
1524                 .ptr            = &sDefault.iCreate_mask,
1525                 .special        = NULL,
1526                 .enum_list      = NULL,
1527                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1528         },
1529         {
1530                 .label          = "create mode",
1531                 .type           = P_OCTAL,
1532                 .p_class        = P_LOCAL,
1533                 .ptr            = &sDefault.iCreate_mask,
1534                 .special        = NULL,
1535                 .enum_list      = NULL,
1536                 .flags          = FLAG_HIDE,
1537         },
1538         {
1539                 .label          = "force create mode",
1540                 .type           = P_OCTAL,
1541                 .p_class        = P_LOCAL,
1542                 .ptr            = &sDefault.iCreate_force_mode,
1543                 .special        = NULL,
1544                 .enum_list      = NULL,
1545                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1546         },
1547         {
1548                 .label          = "security mask",
1549                 .type           = P_OCTAL,
1550                 .p_class        = P_LOCAL,
1551                 .ptr            = &sDefault.iSecurity_mask,
1552                 .special        = NULL,
1553                 .enum_list      = NULL,
1554                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1555         },
1556         {
1557                 .label          = "force security mode",
1558                 .type           = P_OCTAL,
1559                 .p_class        = P_LOCAL,
1560                 .ptr            = &sDefault.iSecurity_force_mode,
1561                 .special        = NULL,
1562                 .enum_list      = NULL,
1563                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1564         },
1565         {
1566                 .label          = "directory mask",
1567                 .type           = P_OCTAL,
1568                 .p_class        = P_LOCAL,
1569                 .ptr            = &sDefault.iDir_mask,
1570                 .special        = NULL,
1571                 .enum_list      = NULL,
1572                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1573         },
1574         {
1575                 .label          = "directory mode",
1576                 .type           = P_OCTAL,
1577                 .p_class        = P_LOCAL,
1578                 .ptr            = &sDefault.iDir_mask,
1579                 .special        = NULL,
1580                 .enum_list      = NULL,
1581                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL,
1582         },
1583         {
1584                 .label          = "force directory mode",
1585                 .type           = P_OCTAL,
1586                 .p_class        = P_LOCAL,
1587                 .ptr            = &sDefault.iDir_force_mode,
1588                 .special        = NULL,
1589                 .enum_list      = NULL,
1590                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1591         },
1592         {
1593                 .label          = "directory security mask",
1594                 .type           = P_OCTAL,
1595                 .p_class        = P_LOCAL,
1596                 .ptr            = &sDefault.iDir_Security_mask,
1597                 .special        = NULL,
1598                 .enum_list      = NULL,
1599                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1600         },
1601         {
1602                 .label          = "force directory security mode",
1603                 .type           = P_OCTAL,
1604                 .p_class        = P_LOCAL,
1605                 .ptr            = &sDefault.iDir_Security_force_mode,
1606                 .special        = NULL,
1607                 .enum_list      = NULL,
1608                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1609         },
1610         {
1611                 .label          = "force unknown acl user",
1612                 .type           = P_BOOL,
1613                 .p_class        = P_LOCAL,
1614                 .ptr            = &sDefault.bForceUnknownAclUser,
1615                 .special        = NULL,
1616                 .enum_list      = NULL,
1617                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1618         },
1619         {
1620                 .label          = "inherit permissions",
1621                 .type           = P_BOOL,
1622                 .p_class        = P_LOCAL,
1623                 .ptr            = &sDefault.bInheritPerms,
1624                 .special        = NULL,
1625                 .enum_list      = NULL,
1626                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
1627         },
1628         {
1629                 .label          = "inherit acls",
1630                 .type           = P_BOOL,
1631                 .p_class        = P_LOCAL,
1632                 .ptr            = &sDefault.bInheritACLS,
1633                 .special        = NULL,
1634                 .enum_list      = NULL,
1635                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
1636         },
1637         {
1638                 .label          = "inherit owner",
1639                 .type           = P_BOOL,
1640                 .p_class        = P_LOCAL,
1641                 .ptr            = &sDefault.bInheritOwner,
1642                 .special        = NULL,
1643                 .enum_list      = NULL,
1644                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
1645         },
1646         {
1647                 .label          = "guest only",
1648                 .type           = P_BOOL,
1649                 .p_class        = P_LOCAL,
1650                 .ptr            = &sDefault.bGuest_only,
1651                 .special        = NULL,
1652                 .enum_list      = NULL,
1653                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
1654         },
1655         {
1656                 .label          = "only guest",
1657                 .type           = P_BOOL,
1658                 .p_class        = P_LOCAL,
1659                 .ptr            = &sDefault.bGuest_only,
1660                 .special        = NULL,
1661                 .enum_list      = NULL,
1662                 .flags          = FLAG_HIDE,
1663         },
1664         {
1665                 .label          = "administrative share",
1666                 .type           = P_BOOL,
1667                 .p_class        = P_LOCAL,
1668                 .ptr            = &sDefault.bAdministrative_share,
1669                 .special        = NULL,
1670                 .enum_list      = NULL,
1671                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
1672         },
1673
1674         {
1675                 .label          = "guest ok",
1676                 .type           = P_BOOL,
1677                 .p_class        = P_LOCAL,
1678                 .ptr            = &sDefault.bGuest_ok,
1679                 .special        = NULL,
1680                 .enum_list      = NULL,
1681                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
1682         },
1683         {
1684                 .label          = "public",
1685                 .type           = P_BOOL,
1686                 .p_class        = P_LOCAL,
1687                 .ptr            = &sDefault.bGuest_ok,
1688                 .special        = NULL,
1689                 .enum_list      = NULL,
1690                 .flags          = FLAG_HIDE,
1691         },
1692         {
1693                 .label          = "only user",
1694                 .type           = P_BOOL,
1695                 .p_class        = P_LOCAL,
1696                 .ptr            = &sDefault.bOnlyUser,
1697                 .special        = NULL,
1698                 .enum_list      = NULL,
1699                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_DEPRECATED,
1700         },
1701         {
1702                 .label          = "hosts allow",
1703                 .type           = P_LIST,
1704                 .p_class        = P_LOCAL,
1705                 .ptr            = &sDefault.szHostsallow,
1706                 .special        = NULL,
1707                 .enum_list      = NULL,
1708                 .flags          = FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
1709         },
1710         {
1711                 .label          = "allow hosts",
1712                 .type           = P_LIST,
1713                 .p_class        = P_LOCAL,
1714                 .ptr            = &sDefault.szHostsallow,
1715                 .special        = NULL,
1716                 .enum_list      = NULL,
1717                 .flags          = FLAG_HIDE,
1718         },
1719         {
1720                 .label          = "hosts deny",
1721                 .type           = P_LIST,
1722                 .p_class        = P_LOCAL,
1723                 .ptr            = &sDefault.szHostsdeny,
1724                 .special        = NULL,
1725                 .enum_list      = NULL,
1726                 .flags          = FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
1727         },
1728         {
1729                 .label          = "deny hosts",
1730                 .type           = P_LIST,
1731                 .p_class        = P_LOCAL,
1732                 .ptr            = &sDefault.szHostsdeny,
1733                 .special        = NULL,
1734                 .enum_list      = NULL,
1735                 .flags          = FLAG_HIDE,
1736         },
1737         {
1738                 .label          = "preload modules",
1739                 .type           = P_LIST,
1740                 .p_class        = P_GLOBAL,
1741                 .ptr            = &Globals.szPreloadModules,
1742                 .special        = NULL,
1743                 .enum_list      = NULL,
1744                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL,
1745         },
1746         {
1747                 .label          = "use kerberos keytab",
1748                 .type           = P_BOOL,
1749                 .p_class        = P_GLOBAL,
1750                 .ptr            = &Globals.bUseKerberosKeytab,
1751                 .special        = NULL,
1752                 .enum_list      = NULL,
1753                 .flags          = FLAG_ADVANCED,
1754         },
1755
1756         {N_("Logging Options"), P_SEP, P_SEPARATOR},
1757
1758         {
1759                 .label          = "log level",
1760                 .type           = P_STRING,
1761                 .p_class        = P_GLOBAL,
1762                 .ptr            = &Globals.szLogLevel,
1763                 .special        = handle_debug_list,
1764                 .enum_list      = NULL,
1765                 .flags          = FLAG_ADVANCED,
1766         },
1767         {
1768                 .label          = "debuglevel",
1769                 .type           = P_STRING,
1770                 .p_class        = P_GLOBAL,
1771                 .ptr            = &Globals.szLogLevel,
1772                 .special        = handle_debug_list,
1773                 .enum_list      = NULL,
1774                 .flags          = FLAG_HIDE,
1775         },
1776         {
1777                 .label          = "syslog",
1778                 .type           = P_INTEGER,
1779                 .p_class        = P_GLOBAL,
1780                 .ptr            = &Globals.syslog,
1781                 .special        = NULL,
1782                 .enum_list      = NULL,
1783                 .flags          = FLAG_ADVANCED,
1784         },
1785         {
1786                 .label          = "syslog only",
1787                 .type           = P_BOOL,
1788                 .p_class        = P_GLOBAL,
1789                 .ptr            = &Globals.bSyslogOnly,
1790                 .special        = NULL,
1791                 .enum_list      = NULL,
1792                 .flags          = FLAG_ADVANCED,
1793         },
1794         {
1795                 .label          = "log file",
1796                 .type           = P_STRING,
1797                 .p_class        = P_GLOBAL,
1798                 .ptr            = &Globals.szLogFile,
1799                 .special        = NULL,
1800                 .enum_list      = NULL,
1801                 .flags          = FLAG_ADVANCED,
1802         },
1803         {
1804                 .label          = "max log size",
1805                 .type           = P_INTEGER,
1806                 .p_class        = P_GLOBAL,
1807                 .ptr            = &Globals.max_log_size,
1808                 .special        = NULL,
1809                 .enum_list      = NULL,
1810                 .flags          = FLAG_ADVANCED,
1811         },
1812         {
1813                 .label          = "debug timestamp",
1814                 .type           = P_BOOL,
1815                 .p_class        = P_GLOBAL,
1816                 .ptr            = &Globals.bTimestampLogs,
1817                 .special        = NULL,
1818                 .enum_list      = NULL,
1819                 .flags          = FLAG_ADVANCED,
1820         },
1821         {
1822                 .label          = "timestamp logs",
1823                 .type           = P_BOOL,
1824                 .p_class        = P_GLOBAL,
1825                 .ptr            = &Globals.bTimestampLogs,
1826                 .special        = NULL,
1827                 .enum_list      = NULL,
1828                 .flags          = FLAG_ADVANCED,
1829         },
1830         {
1831                 .label          = "debug prefix timestamp",
1832                 .type           = P_BOOL,
1833                 .p_class        = P_GLOBAL,
1834                 .ptr            = &Globals.bDebugPrefixTimestamp,
1835                 .special        = NULL,
1836                 .enum_list      = NULL,
1837                 .flags          = FLAG_ADVANCED,
1838         },
1839         {
1840                 .label          = "debug hires timestamp",
1841                 .type           = P_BOOL,
1842                 .p_class        = P_GLOBAL,
1843                 .ptr            = &Globals.bDebugHiresTimestamp,
1844                 .special        = NULL,
1845                 .enum_list      = NULL,
1846                 .flags          = FLAG_ADVANCED,
1847         },
1848         {
1849                 .label          = "debug pid",
1850                 .type           = P_BOOL,
1851                 .p_class        = P_GLOBAL,
1852                 .ptr            = &Globals.bDebugPid,
1853                 .special        = NULL,
1854                 .enum_list      = NULL,
1855                 .flags          = FLAG_ADVANCED,
1856         },
1857         {
1858                 .label          = "debug uid",
1859                 .type           = P_BOOL,
1860                 .p_class        = P_GLOBAL,
1861                 .ptr            = &Globals.bDebugUid,
1862                 .special        = NULL,
1863                 .enum_list      = NULL,
1864                 .flags          = FLAG_ADVANCED,
1865         },
1866         {
1867                 .label          = "debug class",
1868                 .type           = P_BOOL,
1869                 .p_class        = P_GLOBAL,
1870                 .ptr            = &Globals.bDebugClass,
1871                 .special        = NULL,
1872                 .enum_list      = NULL,
1873                 .flags          = FLAG_ADVANCED,
1874         },
1875         {
1876                 .label          = "enable core files",
1877                 .type           = P_BOOL,
1878                 .p_class        = P_GLOBAL,
1879                 .ptr            = &Globals.bEnableCoreFiles,
1880                 .special        = NULL,
1881                 .enum_list      = NULL,
1882                 .flags          = FLAG_ADVANCED,
1883         },
1884
1885         {N_("Protocol Options"), P_SEP, P_SEPARATOR},
1886
1887         {
1888                 .label          = "allocation roundup size",
1889                 .type           = P_INTEGER,
1890                 .p_class        = P_LOCAL,
1891                 .ptr            = &sDefault.iallocation_roundup_size,
1892                 .special        = NULL,
1893                 .enum_list      = NULL,
1894                 .flags          = FLAG_ADVANCED,
1895         },
1896         {
1897                 .label          = "aio read size",
1898                 .type           = P_INTEGER,
1899                 .p_class        = P_LOCAL,
1900                 .ptr            = &sDefault.iAioReadSize,
1901                 .special        = NULL,
1902                 .enum_list      = NULL,
1903                 .flags          = FLAG_ADVANCED,
1904         },
1905         {
1906                 .label          = "aio write size",
1907                 .type           = P_INTEGER,
1908                 .p_class        = P_LOCAL,
1909                 .ptr            = &sDefault.iAioWriteSize,
1910                 .special        = NULL,
1911                 .enum_list      = NULL,
1912                 .flags          = FLAG_ADVANCED,
1913         },
1914         {
1915                 .label          = "aio write behind",
1916                 .type           = P_STRING,
1917                 .p_class        = P_LOCAL,
1918                 .ptr            = &sDefault.szAioWriteBehind,
1919                 .special        = NULL,
1920                 .enum_list      = NULL,
1921                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
1922         },
1923         {
1924                 .label          = "smb ports",
1925                 .type           = P_STRING,
1926                 .p_class        = P_GLOBAL,
1927                 .ptr            = &Globals.smb_ports,
1928                 .special        = NULL,
1929                 .enum_list      = NULL,
1930                 .flags          = FLAG_ADVANCED,
1931         },
1932         {
1933                 .label          = "large readwrite",
1934                 .type           = P_BOOL,
1935                 .p_class        = P_GLOBAL,
1936                 .ptr            = &Globals.bLargeReadwrite,
1937                 .special        = NULL,
1938                 .enum_list      = NULL,
1939                 .flags          = FLAG_ADVANCED,
1940         },
1941         {
1942                 .label          = "max protocol",
1943                 .type           = P_ENUM,
1944                 .p_class        = P_GLOBAL,
1945                 .ptr            = &Globals.maxprotocol,
1946                 .special        = NULL,
1947                 .enum_list      = enum_protocol,
1948                 .flags          = FLAG_ADVANCED,
1949         },
1950         {
1951                 .label          = "protocol",
1952                 .type           = P_ENUM,
1953                 .p_class        = P_GLOBAL,
1954                 .ptr            = &Globals.maxprotocol,
1955                 .special        = NULL,
1956                 .enum_list      = enum_protocol,
1957                 .flags          = FLAG_ADVANCED,
1958         },
1959         {
1960                 .label          = "min protocol",
1961                 .type           = P_ENUM,
1962                 .p_class        = P_GLOBAL,
1963                 .ptr            = &Globals.minprotocol,
1964                 .special        = NULL,
1965                 .enum_list      = enum_protocol,
1966                 .flags          = FLAG_ADVANCED,
1967         },
1968         {
1969                 .label          = "min receivefile size",
1970                 .type           = P_INTEGER,
1971                 .p_class        = P_GLOBAL,
1972                 .ptr            = &Globals.iminreceivefile,
1973                 .special        = NULL,
1974                 .enum_list      = NULL,
1975                 .flags          = FLAG_ADVANCED,
1976         },
1977         {
1978                 .label          = "read raw",
1979                 .type           = P_BOOL,
1980                 .p_class        = P_GLOBAL,
1981                 .ptr            = &Globals.bReadRaw,
1982                 .special        = NULL,
1983                 .enum_list      = NULL,
1984                 .flags          = FLAG_ADVANCED,
1985         },
1986         {
1987                 .label          = "write raw",
1988                 .type           = P_BOOL,
1989                 .p_class        = P_GLOBAL,
1990                 .ptr            = &Globals.bWriteRaw,
1991                 .special        = NULL,
1992                 .enum_list      = NULL,
1993                 .flags          = FLAG_ADVANCED,
1994         },
1995         {
1996                 .label          = "disable netbios",
1997                 .type           = P_BOOL,
1998                 .p_class        = P_GLOBAL,
1999                 .ptr            = &Globals.bDisableNetbios,
2000                 .special        = NULL,
2001                 .enum_list      = NULL,
2002                 .flags          = FLAG_ADVANCED,
2003         },
2004         {
2005                 .label          = "reset on zero vc",
2006                 .type           = P_BOOL,
2007                 .p_class        = P_GLOBAL,
2008                 .ptr            = &Globals.bResetOnZeroVC,
2009                 .special        = NULL,
2010                 .enum_list      = NULL,
2011                 .flags          = FLAG_ADVANCED,
2012         },
2013         {
2014                 .label          = "acl compatibility",
2015                 .type           = P_ENUM,
2016                 .p_class        = P_GLOBAL,
2017                 .ptr            = &Globals.iAclCompat,
2018                 .special        = NULL,
2019                 .enum_list      = enum_acl_compat_vals,
2020                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2021         },
2022         {
2023                 .label          = "defer sharing violations",
2024                 .type           = P_BOOL,
2025                 .p_class        = P_GLOBAL,
2026                 .ptr            = &Globals.bDeferSharingViolations,
2027                 .special        = NULL,
2028                 .enum_list      = NULL,
2029                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL,
2030         },
2031         {
2032                 .label          = "ea support",
2033                 .type           = P_BOOL,
2034                 .p_class        = P_LOCAL,
2035                 .ptr            = &sDefault.bEASupport,
2036                 .special        = NULL,
2037                 .enum_list      = NULL,
2038                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2039         },
2040         {
2041                 .label          = "nt acl support",
2042                 .type           = P_BOOL,
2043                 .p_class        = P_LOCAL,
2044                 .ptr            = &sDefault.bNTAclSupport,
2045                 .special        = NULL,
2046                 .enum_list      = NULL,
2047                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2048         },
2049         {
2050                 .label          = "nt pipe support",
2051                 .type           = P_BOOL,
2052                 .p_class        = P_GLOBAL,
2053                 .ptr            = &Globals.bNTPipeSupport,
2054                 .special        = NULL,
2055                 .enum_list      = NULL,
2056                 .flags          = FLAG_ADVANCED,
2057         },
2058         {
2059                 .label          = "nt status support",
2060                 .type           = P_BOOL,
2061                 .p_class        = P_GLOBAL,
2062                 .ptr            = &Globals.bNTStatusSupport,
2063                 .special        = NULL,
2064                 .enum_list      = NULL,
2065                 .flags          = FLAG_ADVANCED,
2066         },
2067         {
2068                 .label          = "profile acls",
2069                 .type           = P_BOOL,
2070                 .p_class        = P_LOCAL,
2071                 .ptr            = &sDefault.bProfileAcls,
2072                 .special        = NULL,
2073                 .enum_list      = NULL,
2074                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
2075         },
2076         {
2077                 .label          = "announce version",
2078                 .type           = P_STRING,
2079                 .p_class        = P_GLOBAL,
2080                 .ptr            = &Globals.szAnnounceVersion,
2081                 .special        = NULL,
2082                 .enum_list      = NULL,
2083                 .flags          = FLAG_ADVANCED,
2084         },
2085         {
2086                 .label          = "announce as",
2087                 .type           = P_ENUM,
2088                 .p_class        = P_GLOBAL,
2089                 .ptr            = &Globals.announce_as,
2090                 .special        = NULL,
2091                 .enum_list      = enum_announce_as,
2092                 .flags          = FLAG_ADVANCED,
2093         },
2094         {
2095                 .label          = "map acl inherit",
2096                 .type           = P_BOOL,
2097                 .p_class        = P_LOCAL,
2098                 .ptr            = &sDefault.bMap_acl_inherit,
2099                 .special        = NULL,
2100                 .enum_list      = NULL,
2101                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2102         },
2103         {
2104                 .label          = "afs share",
2105                 .type           = P_BOOL,
2106                 .p_class        = P_LOCAL,
2107                 .ptr            = &sDefault.bAfs_Share,
2108                 .special        = NULL,
2109                 .enum_list      = NULL,
2110                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2111         },
2112         {
2113                 .label          = "max mux",
2114                 .type           = P_INTEGER,
2115                 .p_class        = P_GLOBAL,
2116                 .ptr            = &Globals.max_mux,
2117                 .special        = NULL,
2118                 .enum_list      = NULL,
2119                 .flags          = FLAG_ADVANCED,
2120         },
2121         {
2122                 .label          = "max xmit",
2123                 .type           = P_INTEGER,
2124                 .p_class        = P_GLOBAL,
2125                 .ptr            = &Globals.max_xmit,
2126                 .special        = NULL,
2127                 .enum_list      = NULL,
2128                 .flags          = FLAG_ADVANCED,
2129         },
2130         {
2131                 .label          = "name resolve order",
2132                 .type           = P_STRING,
2133                 .p_class        = P_GLOBAL,
2134                 .ptr            = &Globals.szNameResolveOrder,
2135                 .special        = NULL,
2136                 .enum_list      = NULL,
2137                 .flags          = FLAG_ADVANCED | FLAG_WIZARD,
2138         },
2139         {
2140                 .label          = "max ttl",
2141                 .type           = P_INTEGER,
2142                 .p_class        = P_GLOBAL,
2143                 .ptr            = &Globals.max_ttl,
2144                 .special        = NULL,
2145                 .enum_list      = NULL,
2146                 .flags          = FLAG_ADVANCED,
2147         },
2148         {
2149                 .label          = "max wins ttl",
2150                 .type           = P_INTEGER,
2151                 .p_class        = P_GLOBAL,
2152                 .ptr            = &Globals.max_wins_ttl,
2153                 .special        = NULL,
2154                 .enum_list      = NULL,
2155                 .flags          = FLAG_ADVANCED,
2156         },
2157         {
2158                 .label          = "min wins ttl",
2159                 .type           = P_INTEGER,
2160                 .p_class        = P_GLOBAL,
2161                 .ptr            = &Globals.min_wins_ttl,
2162                 .special        = NULL,
2163                 .enum_list      = NULL,
2164                 .flags          = FLAG_ADVANCED,
2165         },
2166         {
2167                 .label          = "time server",
2168                 .type           = P_BOOL,
2169                 .p_class        = P_GLOBAL,
2170                 .ptr            = &Globals.bTimeServer,
2171                 .special        = NULL,
2172                 .enum_list      = NULL,
2173                 .flags          = FLAG_ADVANCED,
2174         },
2175         {
2176                 .label          = "unix extensions",
2177                 .type           = P_BOOL,
2178                 .p_class        = P_GLOBAL,
2179                 .ptr            = &Globals.bUnixExtensions,
2180                 .special        = NULL,
2181                 .enum_list      = NULL,
2182                 .flags          = FLAG_ADVANCED,
2183         },
2184         {
2185                 .label          = "use spnego",
2186                 .type           = P_BOOL,
2187                 .p_class        = P_GLOBAL,
2188                 .ptr            = &Globals.bUseSpnego,
2189                 .special        = NULL,
2190                 .enum_list      = NULL,
2191                 .flags          = FLAG_ADVANCED,
2192         },
2193         {
2194                 .label          = "client signing",
2195                 .type           = P_ENUM,
2196                 .p_class        = P_GLOBAL,
2197                 .ptr            = &Globals.client_signing,
2198                 .special        = NULL,
2199                 .enum_list      = enum_smb_signing_vals,
2200                 .flags          = FLAG_ADVANCED,
2201         },
2202         {
2203                 .label          = "server signing",
2204                 .type           = P_ENUM,
2205                 .p_class        = P_GLOBAL,
2206                 .ptr            = &Globals.server_signing,
2207                 .special        = NULL,
2208                 .enum_list      = enum_smb_signing_vals,
2209                 .flags          = FLAG_ADVANCED,
2210         },
2211         {
2212                 .label          = "smb encrypt",
2213                 .type           = P_ENUM,
2214                 .p_class        = P_LOCAL,
2215                 .ptr            = &sDefault.ismb_encrypt,
2216                 .special        = NULL,
2217                 .enum_list      = enum_smb_signing_vals,
2218                 .flags          = FLAG_ADVANCED,
2219         },
2220         {
2221                 .label          = "client use spnego",
2222                 .type           = P_BOOL,
2223                 .p_class        = P_GLOBAL,
2224                 .ptr            = &Globals.bClientUseSpnego,
2225                 .special        = NULL,
2226                 .enum_list      = NULL,
2227                 .flags          = FLAG_ADVANCED,
2228         },
2229         {
2230                 .label          = "client ldap sasl wrapping",
2231                 .type           = P_ENUM,
2232                 .p_class        = P_GLOBAL,
2233                 .ptr            = &Globals.client_ldap_sasl_wrapping,
2234                 .special        = NULL,
2235                 .enum_list      = enum_ldap_sasl_wrapping,
2236                 .flags          = FLAG_ADVANCED,
2237         },
2238         {
2239                 .label          = "enable asu support",
2240                 .type           = P_BOOL,
2241                 .p_class        = P_GLOBAL,
2242                 .ptr            = &Globals.bASUSupport,
2243                 .special        = NULL,
2244                 .enum_list      = NULL,
2245                 .flags          = FLAG_ADVANCED,
2246         },
2247         {
2248                 .label          = "svcctl list",
2249                 .type           = P_LIST,
2250                 .p_class        = P_GLOBAL,
2251                 .ptr            = &Globals.szServicesList,
2252                 .special        = NULL,
2253                 .enum_list      = NULL,
2254                 .flags          = FLAG_ADVANCED,
2255         },
2256
2257         {N_("Tuning Options"), P_SEP, P_SEPARATOR},
2258
2259         {
2260                 .label          = "block size",
2261                 .type           = P_INTEGER,
2262                 .p_class        = P_LOCAL,
2263                 .ptr            = &sDefault.iBlock_size,
2264                 .special        = NULL,
2265                 .enum_list      = NULL,
2266                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2267         },
2268         {
2269                 .label          = "deadtime",
2270                 .type           = P_INTEGER,
2271                 .p_class        = P_GLOBAL,
2272                 .ptr            = &Globals.deadtime,
2273                 .special        = NULL,
2274                 .enum_list      = NULL,
2275                 .flags          = FLAG_ADVANCED,
2276         },
2277         {
2278                 .label          = "getwd cache",
2279                 .type           = P_BOOL,
2280                 .p_class        = P_GLOBAL,
2281                 .ptr            = &Globals.getwd_cache,
2282                 .special        = NULL,
2283                 .enum_list      = NULL,
2284                 .flags          = FLAG_ADVANCED,
2285         },
2286         {
2287                 .label          = "keepalive",
2288                 .type           = P_INTEGER,
2289                 .p_class        = P_GLOBAL,
2290                 .ptr            = &Globals.iKeepalive,
2291                 .special        = NULL,
2292                 .enum_list      = NULL,
2293                 .flags          = FLAG_ADVANCED,
2294         },
2295         {
2296                 .label          = "change notify",
2297                 .type           = P_BOOL,
2298                 .p_class        = P_LOCAL,
2299                 .ptr            = &sDefault.bChangeNotify,
2300                 .special        = NULL,
2301                 .enum_list      = NULL,
2302                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
2303         },
2304         {
2305                 .label          = "directory name cache size",
2306                 .type           = P_INTEGER,
2307                 .p_class        = P_LOCAL,
2308                 .ptr            = &sDefault.iDirectoryNameCacheSize,
2309                 .special        = NULL,
2310                 .enum_list      = NULL,
2311                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
2312         },
2313         {
2314                 .label          = "kernel change notify",
2315                 .type           = P_BOOL,
2316                 .p_class        = P_LOCAL,
2317                 .ptr            = &sDefault.bKernelChangeNotify,
2318                 .special        = NULL,
2319                 .enum_list      = NULL,
2320                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
2321         },
2322         {
2323                 .label          = "lpq cache time",
2324                 .type           = P_INTEGER,
2325                 .p_class        = P_GLOBAL,
2326                 .ptr            = &Globals.lpqcachetime,
2327                 .special        = NULL,
2328                 .enum_list      = NULL,
2329                 .flags          = FLAG_ADVANCED,
2330         },
2331         {
2332                 .label          = "max smbd processes",
2333                 .type           = P_INTEGER,
2334                 .p_class        = P_GLOBAL,
2335                 .ptr            = &Globals.iMaxSmbdProcesses,
2336                 .special        = NULL,
2337                 .enum_list      = NULL,
2338                 .flags          = FLAG_ADVANCED,
2339         },
2340         {
2341                 .label          = "max connections",
2342                 .type           = P_INTEGER,
2343                 .p_class        = P_LOCAL,
2344                 .ptr            = &sDefault.iMaxConnections,
2345                 .special        = NULL,
2346                 .enum_list      = NULL,
2347                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
2348         },
2349         {
2350                 .label          = "paranoid server security",
2351                 .type           = P_BOOL,
2352                 .p_class        = P_GLOBAL,
2353                 .ptr            = &Globals.paranoid_server_security,
2354                 .special        = NULL,
2355                 .enum_list      = NULL,
2356                 .flags          = FLAG_ADVANCED,
2357         },
2358         {
2359                 .label          = "max disk size",
2360                 .type           = P_INTEGER,
2361                 .p_class        = P_GLOBAL,
2362                 .ptr            = &Globals.maxdisksize,
2363                 .special        = NULL,
2364                 .enum_list      = NULL,
2365                 .flags          = FLAG_ADVANCED,
2366         },
2367         {
2368                 .label          = "max open files",
2369                 .type           = P_INTEGER,
2370                 .p_class        = P_GLOBAL,
2371                 .ptr            = &Globals.max_open_files,
2372                 .special        = NULL,
2373                 .enum_list      = NULL,
2374                 .flags          = FLAG_ADVANCED,
2375         },
2376         {
2377                 .label          = "min print space",
2378                 .type           = P_INTEGER,
2379                 .p_class        = P_LOCAL,
2380                 .ptr            = &sDefault.iMinPrintSpace,
2381                 .special        = NULL,
2382                 .enum_list      = NULL,
2383                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2384         },
2385         {
2386                 .label          = "socket options",
2387                 .type           = P_STRING,
2388                 .p_class        = P_GLOBAL,
2389                 .ptr            = &Globals.szSocketOptions,
2390                 .special        = NULL,
2391                 .enum_list      = NULL,
2392                 .flags          = FLAG_ADVANCED,
2393         },
2394         {
2395                 .label          = "strict allocate",
2396                 .type           = P_BOOL,
2397                 .p_class        = P_LOCAL,
2398                 .ptr            = &sDefault.bStrictAllocate,
2399                 .special        = NULL,
2400                 .enum_list      = NULL,
2401                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
2402         },
2403         {
2404                 .label          = "strict sync",
2405                 .type           = P_BOOL,
2406                 .p_class        = P_LOCAL,
2407                 .ptr            = &sDefault.bStrictSync,
2408                 .special        = NULL,
2409                 .enum_list      = NULL,
2410                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
2411         },
2412         {
2413                 .label          = "sync always",
2414                 .type           = P_BOOL,
2415                 .p_class        = P_LOCAL,
2416                 .ptr            = &sDefault.bSyncAlways,
2417                 .special        = NULL,
2418                 .enum_list      = NULL,
2419                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
2420         },
2421         {
2422                 .label          = "use mmap",
2423                 .type           = P_BOOL,
2424                 .p_class        = P_GLOBAL,
2425                 .ptr            = &Globals.bUseMmap,
2426                 .special        = NULL,
2427                 .enum_list      = NULL,
2428                 .flags          = FLAG_ADVANCED,
2429         },
2430         {
2431                 .label          = "use sendfile",
2432                 .type           = P_BOOL,
2433                 .p_class        = P_LOCAL,
2434                 .ptr            = &sDefault.bUseSendfile,
2435                 .special        = NULL,
2436                 .enum_list      = NULL,
2437                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
2438         },
2439         {
2440                 .label          = "hostname lookups",
2441                 .type           = P_BOOL,
2442                 .p_class        = P_GLOBAL,
2443                 .ptr            = &Globals.bHostnameLookups,
2444                 .special        = NULL,
2445                 .enum_list      = NULL,
2446                 .flags          = FLAG_ADVANCED,
2447         },
2448         {
2449                 .label          = "write cache size",
2450                 .type           = P_INTEGER,
2451                 .p_class        = P_LOCAL,
2452                 .ptr            = &sDefault.iWriteCacheSize,
2453                 .special        = NULL,
2454                 .enum_list      = NULL,
2455                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_DEPRECATED,
2456         },
2457         {
2458                 .label          = "name cache timeout",
2459                 .type           = P_INTEGER,
2460                 .p_class        = P_GLOBAL,
2461                 .ptr            = &Globals.name_cache_timeout,
2462                 .special        = NULL,
2463                 .enum_list      = NULL,
2464                 .flags          = FLAG_ADVANCED,
2465         },
2466         {
2467                 .label          = "ctdbd socket",
2468                 .type           = P_STRING,
2469                 .p_class        = P_GLOBAL,
2470                 .ptr            = &Globals.ctdbdSocket,
2471                 .special        = NULL,
2472                 .enum_list      = NULL,
2473                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL,
2474         },
2475         {
2476                 .label          = "cluster addresses",
2477                 .type           = P_LIST,
2478                 .p_class        = P_GLOBAL,
2479                 .ptr            = &Globals.szClusterAddresses,
2480                 .special        = NULL,
2481                 .enum_list      = NULL,
2482                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL,
2483         },
2484         {
2485                 .label          = "clustering",
2486                 .type           = P_BOOL,
2487                 .p_class        = P_GLOBAL,
2488                 .ptr            = &Globals.clustering,
2489                 .special        = NULL,
2490                 .enum_list      = NULL,
2491                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL,
2492         },
2493
2494         {N_("Printing Options"), P_SEP, P_SEPARATOR},
2495
2496         {
2497                 .label          = "max reported print jobs",
2498                 .type           = P_INTEGER,
2499                 .p_class        = P_LOCAL,
2500                 .ptr            = &sDefault.iMaxReportedPrintJobs,
2501                 .special        = NULL,
2502                 .enum_list      = NULL,
2503                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2504         },
2505         {
2506                 .label          = "max print jobs",
2507                 .type           = P_INTEGER,
2508                 .p_class        = P_LOCAL,
2509                 .ptr            = &sDefault.iMaxPrintJobs,
2510                 .special        = NULL,
2511                 .enum_list      = NULL,
2512                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2513         },
2514         {
2515                 .label          = "load printers",
2516                 .type           = P_BOOL,
2517                 .p_class        = P_GLOBAL,
2518                 .ptr            = &Globals.bLoadPrinters,
2519                 .special        = NULL,
2520                 .enum_list      = NULL,
2521                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2522         },
2523         {
2524                 .label          = "printcap cache time",
2525                 .type           = P_INTEGER,
2526                 .p_class        = P_GLOBAL,
2527                 .ptr            = &Globals.PrintcapCacheTime,
2528                 .special        = NULL,
2529                 .enum_list      = NULL,
2530                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2531         },
2532         {
2533                 .label          = "printcap name",
2534                 .type           = P_STRING,
2535                 .p_class        = P_GLOBAL,
2536                 .ptr            = &Globals.szPrintcapname,
2537                 .special        = NULL,
2538                 .enum_list      = NULL,
2539                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2540         },
2541         {
2542                 .label          = "printcap",
2543                 .type           = P_STRING,
2544                 .p_class        = P_GLOBAL,
2545                 .ptr            = &Globals.szPrintcapname,
2546                 .special        = NULL,
2547                 .enum_list      = NULL,
2548                 .flags          = FLAG_HIDE,
2549         },
2550         {
2551                 .label          = "printable",
2552                 .type           = P_BOOL,
2553                 .p_class        = P_LOCAL,
2554                 .ptr            = &sDefault.bPrint_ok,
2555                 .special        = NULL,
2556                 .enum_list      = NULL,
2557                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2558         },
2559         {
2560                 .label          = "print ok",
2561                 .type           = P_BOOL,
2562                 .p_class        = P_LOCAL,
2563                 .ptr            = &sDefault.bPrint_ok,
2564                 .special        = NULL,
2565                 .enum_list      = NULL,
2566                 .flags          = FLAG_HIDE,
2567         },
2568         {
2569                 .label          = "printing",
2570                 .type           = P_ENUM,
2571                 .p_class        = P_LOCAL,
2572                 .ptr            = &sDefault.iPrinting,
2573                 .special        = handle_printing,
2574                 .enum_list      = enum_printing,
2575                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2576         },
2577         {
2578                 .label          = "cups options",
2579                 .type           = P_STRING,
2580                 .p_class        = P_LOCAL,
2581                 .ptr            = &sDefault.szCupsOptions,
2582                 .special        = NULL,
2583                 .enum_list      = NULL,
2584                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2585         },
2586         {
2587                 .label          = "cups server",
2588                 .type           = P_STRING,
2589                 .p_class        = P_GLOBAL,
2590                 .ptr            = &Globals.szCupsServer,
2591                 .special        = NULL,
2592                 .enum_list      = NULL,
2593                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2594         },
2595         {
2596                 .label          = "cups connection timeout",
2597                 .type           = P_INTEGER,
2598                 .p_class        = P_GLOBAL,
2599                 .ptr            = &Globals.cups_connection_timeout,
2600                 .special        = NULL,
2601                 .enum_list      = NULL,
2602                 .flags          = FLAG_ADVANCED,
2603         },
2604         {
2605                 .label          = "iprint server",
2606                 .type           = P_STRING,
2607                 .p_class        = P_GLOBAL,
2608                 .ptr            = &Globals.szIPrintServer,
2609                 .special        = NULL,
2610                 .enum_list      = NULL,
2611                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2612         },
2613         {
2614                 .label          = "print command",
2615                 .type           = P_STRING,
2616                 .p_class        = P_LOCAL,
2617                 .ptr            = &sDefault.szPrintcommand,
2618                 .special        = NULL,
2619                 .enum_list      = NULL,
2620                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2621         },
2622         {
2623                 .label          = "disable spoolss",
2624                 .type           = P_BOOL,
2625                 .p_class        = P_GLOBAL,
2626                 .ptr            = &Globals.bDisableSpoolss,
2627                 .special        = NULL,
2628                 .enum_list      = NULL,
2629                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2630         },
2631         {
2632                 .label          = "enable spoolss",
2633                 .type           = P_BOOLREV,
2634                 .p_class        = P_GLOBAL,
2635                 .ptr            = &Globals.bDisableSpoolss,
2636                 .special        = NULL,
2637                 .enum_list      = NULL,
2638                 .flags          = FLAG_HIDE,
2639         },
2640         {
2641                 .label          = "lpq command",
2642                 .type           = P_STRING,
2643                 .p_class        = P_LOCAL,
2644                 .ptr            = &sDefault.szLpqcommand,
2645                 .special        = NULL,
2646                 .enum_list      = NULL,
2647                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2648         },
2649         {
2650                 .label          = "lprm command",
2651                 .type           = P_STRING,
2652                 .p_class        = P_LOCAL,
2653                 .ptr            = &sDefault.szLprmcommand,
2654                 .special        = NULL,
2655                 .enum_list      = NULL,
2656                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2657         },
2658         {
2659                 .label          = "lppause command",
2660                 .type           = P_STRING,
2661                 .p_class        = P_LOCAL,
2662                 .ptr            = &sDefault.szLppausecommand,
2663                 .special        = NULL,
2664                 .enum_list      = NULL,
2665                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2666         },
2667         {
2668                 .label          = "lpresume command",
2669                 .type           = P_STRING,
2670                 .p_class        = P_LOCAL,
2671                 .ptr            = &sDefault.szLpresumecommand,
2672                 .special        = NULL,
2673                 .enum_list      = NULL,
2674                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2675         },
2676         {
2677                 .label          = "queuepause command",
2678                 .type           = P_STRING,
2679                 .p_class        = P_LOCAL,
2680                 .ptr            = &sDefault.szQueuepausecommand,
2681                 .special        = NULL,
2682                 .enum_list      = NULL,
2683                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2684         },
2685         {
2686                 .label          = "queueresume command",
2687                 .type           = P_STRING,
2688                 .p_class        = P_LOCAL,
2689                 .ptr            = &sDefault.szQueueresumecommand,
2690                 .special        = NULL,
2691                 .enum_list      = NULL,
2692                 .flags          = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2693         },
2694         {
2695                 .label          = "addport command",
2696                 .type           = P_STRING,
2697                 .p_class        = P_GLOBAL,
2698                 .ptr            = &Globals.szAddPortCommand,
2699                 .special        = NULL,
2700                 .enum_list      = NULL,
2701                 .flags          = FLAG_ADVANCED,
2702         },
2703         {
2704                 .label          = "enumports command",
2705                 .type           = P_STRING,
2706                 .p_class        = P_GLOBAL,
2707                 .ptr            = &Globals.szEnumPortsCommand,
2708                 .special        = NULL,
2709                 .enum_list      = NULL,
2710                 .flags          = FLAG_ADVANCED,
2711         },
2712         {
2713                 .label          = "addprinter command",
2714                 .type           = P_STRING,
2715                 .p_class        = P_GLOBAL,
2716                 .ptr            = &Globals.szAddPrinterCommand,
2717                 .special        = NULL,
2718                 .enum_list      = NULL,
2719                 .flags          = FLAG_ADVANCED,
2720         },
2721         {
2722                 .label          = "deleteprinter command",
2723                 .type           = P_STRING,
2724                 .p_class        = P_GLOBAL,
2725                 .ptr            = &Globals.szDeletePrinterCommand,
2726                 .special        = NULL,
2727                 .enum_list      = NULL,
2728                 .flags          = FLAG_ADVANCED,
2729         },
2730         {
2731                 .label          = "show add printer wizard",
2732                 .type           = P_BOOL,
2733                 .p_class        = P_GLOBAL,
2734                 .ptr            = &Globals.bMsAddPrinterWizard,
2735                 .special        = NULL,
2736                 .enum_list      = NULL,
2737                 .flags          = FLAG_ADVANCED,
2738         },
2739         {
2740                 .label          = "os2 driver map",
2741                 .type           = P_STRING,
2742                 .p_class        = P_GLOBAL,
2743                 .ptr            = &Globals.szOs2DriverMap,
2744                 .special        = NULL,
2745                 .enum_list      = NULL,
2746                 .flags          = FLAG_ADVANCED,
2747         },
2748
2749         {
2750                 .label          = "printer name",
2751                 .type           = P_STRING,
2752                 .p_class        = P_LOCAL,
2753                 .ptr            = &sDefault.szPrintername,
2754                 .special        = NULL,
2755                 .enum_list      = NULL,
2756                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2757         },
2758         {
2759                 .label          = "printer",
2760                 .type           = P_STRING,
2761                 .p_class        = P_LOCAL,
2762                 .ptr            = &sDefault.szPrintername,
2763                 .special        = NULL,
2764                 .enum_list      = NULL,
2765                 .flags          = FLAG_HIDE,
2766         },
2767         {
2768                 .label          = "use client driver",
2769                 .type           = P_BOOL,
2770                 .p_class        = P_LOCAL,
2771                 .ptr            = &sDefault.bUseClientDriver,
2772                 .special        = NULL,
2773                 .enum_list      = NULL,
2774                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2775         },
2776         {
2777                 .label          = "default devmode",
2778                 .type           = P_BOOL,
2779                 .p_class        = P_LOCAL,
2780                 .ptr            = &sDefault.bDefaultDevmode,
2781                 .special        = NULL,
2782                 .enum_list      = NULL,
2783                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2784         },
2785         {
2786                 .label          = "force printername",
2787                 .type           = P_BOOL,
2788                 .p_class        = P_LOCAL,
2789                 .ptr            = &sDefault.bForcePrintername,
2790                 .special        = NULL,
2791                 .enum_list      = NULL,
2792                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2793         },
2794         {
2795                 .label          = "printjob username",
2796                 .type           = P_STRING,
2797                 .p_class        = P_LOCAL,
2798                 .ptr            = &sDefault.szPrintjobUsername,
2799                 .special        = NULL,
2800                 .enum_list      = NULL,
2801                 .flags          = FLAG_ADVANCED | FLAG_PRINT,
2802         },
2803
2804         {N_("Filename Handling"), P_SEP, P_SEPARATOR},
2805
2806         {
2807                 .label          = "mangling method",
2808                 .type           = P_STRING,
2809                 .p_class        = P_GLOBAL,
2810                 .ptr            = &Globals.szManglingMethod,
2811                 .special        = NULL,
2812                 .enum_list      = NULL,
2813                 .flags          = FLAG_ADVANCED,
2814         },
2815         {
2816                 .label          = "mangle prefix",
2817                 .type           = P_INTEGER,
2818                 .p_class        = P_GLOBAL,
2819                 .ptr            = &Globals.mangle_prefix,
2820                 .special        = NULL,
2821                 .enum_list      = NULL,
2822                 .flags          = FLAG_ADVANCED,
2823         },
2824
2825         {
2826                 .label          = "default case",
2827                 .type           = P_ENUM,
2828                 .p_class        = P_LOCAL,
2829                 .ptr            = &sDefault.iDefaultCase,
2830                 .special        = NULL,
2831                 .enum_list      = enum_case,
2832                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
2833         },
2834         {
2835                 .label          = "case sensitive",
2836                 .type           = P_ENUM,
2837                 .p_class        = P_LOCAL,
2838                 .ptr            = &sDefault.iCaseSensitive,
2839                 .special        = NULL,
2840                 .enum_list      = enum_bool_auto,
2841                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2842         },
2843         {
2844                 .label          = "casesignames",
2845                 .type           = P_ENUM,
2846                 .p_class        = P_LOCAL,
2847                 .ptr            = &sDefault.iCaseSensitive,
2848                 .special        = NULL,
2849                 .enum_list      = enum_bool_auto,
2850                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL | FLAG_HIDE,
2851         },
2852         {
2853                 .label          = "preserve case",
2854                 .type           = P_BOOL,
2855                 .p_class        = P_LOCAL,
2856                 .ptr            = &sDefault.bCasePreserve,
2857                 .special        = NULL,
2858                 .enum_list      = NULL,
2859                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2860         },
2861         {
2862                 .label          = "short preserve case",
2863                 .type           = P_BOOL,
2864                 .p_class        = P_LOCAL,
2865                 .ptr            = &sDefault.bShortCasePreserve,
2866                 .special        = NULL,
2867                 .enum_list      = NULL,
2868                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2869         },
2870         {
2871                 .label          = "mangling char",
2872                 .type           = P_CHAR,
2873                 .p_class        = P_LOCAL,
2874                 .ptr            = &sDefault.magic_char,
2875                 .special        = NULL,
2876                 .enum_list      = NULL,
2877                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2878         },
2879         {
2880                 .label          = "hide dot files",
2881                 .type           = P_BOOL,
2882                 .p_class        = P_LOCAL,
2883                 .ptr            = &sDefault.bHideDotFiles,
2884                 .special        = NULL,
2885                 .enum_list      = NULL,
2886                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2887         },
2888         {
2889                 .label          = "hide special files",
2890                 .type           = P_BOOL,
2891                 .p_class        = P_LOCAL,
2892                 .ptr            = &sDefault.bHideSpecialFiles,
2893                 .special        = NULL,
2894                 .enum_list      = NULL,
2895                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2896         },
2897         {
2898                 .label          = "hide unreadable",
2899                 .type           = P_BOOL,
2900                 .p_class        = P_LOCAL,
2901                 .ptr            = &sDefault.bHideUnReadable,
2902                 .special        = NULL,
2903                 .enum_list      = NULL,
2904                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2905         },
2906         {
2907                 .label          = "hide unwriteable files",
2908                 .type           = P_BOOL,
2909                 .p_class        = P_LOCAL,
2910                 .ptr            = &sDefault.bHideUnWriteableFiles,
2911                 .special        = NULL,
2912                 .enum_list      = NULL,
2913                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2914         },
2915         {
2916                 .label          = "delete veto files",
2917                 .type           = P_BOOL,
2918                 .p_class        = P_LOCAL,
2919                 .ptr            = &sDefault.bDeleteVetoFiles,
2920                 .special        = NULL,
2921                 .enum_list      = NULL,
2922                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2923         },
2924         {
2925                 .label          = "veto files",
2926                 .type           = P_STRING,
2927                 .p_class        = P_LOCAL,
2928                 .ptr            = &sDefault.szVetoFiles,
2929                 .special        = NULL,
2930                 .enum_list      = NULL,
2931                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2932         },
2933         {
2934                 .label          = "hide files",
2935                 .type           = P_STRING,
2936                 .p_class        = P_LOCAL,
2937                 .ptr            = &sDefault.szHideFiles,
2938                 .special        = NULL,
2939                 .enum_list      = NULL,
2940                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2941         },
2942         {
2943                 .label          = "veto oplock files",
2944                 .type           = P_STRING,
2945                 .p_class        = P_LOCAL,
2946                 .ptr            = &sDefault.szVetoOplockFiles,
2947                 .special        = NULL,
2948                 .enum_list      = NULL,
2949                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2950         },
2951         {
2952                 .label          = "map archive",
2953                 .type           = P_BOOL,
2954                 .p_class        = P_LOCAL,
2955                 .ptr            = &sDefault.bMap_archive,
2956                 .special        = NULL,
2957                 .enum_list      = NULL,
2958                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2959         },
2960         {
2961                 .label          = "map hidden",
2962                 .type           = P_BOOL,
2963                 .p_class        = P_LOCAL,
2964                 .ptr            = &sDefault.bMap_hidden,
2965                 .special        = NULL,
2966                 .enum_list      = NULL,
2967                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2968         },
2969         {
2970                 .label          = "map system",
2971                 .type           = P_BOOL,
2972                 .p_class        = P_LOCAL,
2973                 .ptr            = &sDefault.bMap_system,
2974                 .special        = NULL,
2975                 .enum_list      = NULL,
2976                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2977         },
2978         {
2979                 .label          = "map readonly",
2980                 .type           = P_ENUM,
2981                 .p_class        = P_LOCAL,
2982                 .ptr            = &sDefault.iMap_readonly,
2983                 .special        = NULL,
2984                 .enum_list      = enum_map_readonly,
2985                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2986         },
2987         {
2988                 .label          = "mangled names",
2989                 .type           = P_BOOL,
2990                 .p_class        = P_LOCAL,
2991                 .ptr            = &sDefault.bMangledNames,
2992                 .special        = NULL,
2993                 .enum_list      = NULL,
2994                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2995         },
2996         {
2997                 .label          = "max stat cache size",
2998                 .type           = P_INTEGER,
2999                 .p_class        = P_GLOBAL,
3000                 .ptr            = &Globals.iMaxStatCacheSize,
3001                 .special        = NULL,
3002                 .enum_list      = NULL,
3003                 .flags          = FLAG_ADVANCED,
3004         },
3005         {
3006                 .label          = "stat cache",
3007                 .type           = P_BOOL,
3008                 .p_class        = P_GLOBAL,
3009                 .ptr            = &Globals.bStatCache,
3010                 .special        = NULL,
3011                 .enum_list      = NULL,
3012                 .flags          = FLAG_ADVANCED,
3013         },
3014         {
3015                 .label          = "store dos attributes",
3016                 .type           = P_BOOL,
3017                 .p_class        = P_LOCAL,
3018                 .ptr            = &sDefault.bStoreDosAttributes,
3019                 .special        = NULL,
3020                 .enum_list      = NULL,
3021                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3022         },
3023         {
3024                 .label          = "dmapi support",
3025                 .type           = P_BOOL,
3026                 .p_class        = P_LOCAL,
3027                 .ptr            = &sDefault.bDmapiSupport,
3028                 .special        = NULL,
3029                 .enum_list      = NULL,
3030                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3031         },
3032
3033
3034         {N_("Domain Options"), P_SEP, P_SEPARATOR},
3035
3036         {
3037                 .label          = "machine password timeout",
3038                 .type           = P_INTEGER,
3039                 .p_class        = P_GLOBAL,
3040                 .ptr            = &Globals.machine_password_timeout,
3041                 .special        = NULL,
3042                 .enum_list      = NULL,
3043                 .flags          = FLAG_ADVANCED | FLAG_WIZARD,
3044         },
3045
3046         {N_("Logon Options"), P_SEP, P_SEPARATOR},
3047
3048         {
3049                 .label          = "add user script",
3050                 .type           = P_STRING,
3051                 .p_class        = P_GLOBAL,
3052                 .ptr            = &Globals.szAddUserScript,
3053                 .special        = NULL,
3054                 .enum_list      = NULL,
3055                 .flags          = FLAG_ADVANCED,
3056         },
3057         {
3058                 .label          = "rename user script",
3059                 .type           = P_STRING,
3060                 .p_class        = P_GLOBAL,
3061                 .ptr            = &Globals.szRenameUserScript,
3062                 .special        = NULL,
3063                 .enum_list      = NULL,
3064                 .flags          = FLAG_ADVANCED,
3065         },
3066         {
3067                 .label          = "delete user script",
3068                 .type           = P_STRING,
3069                 .p_class        = P_GLOBAL,
3070                 .ptr            = &Globals.szDelUserScript,
3071                 .special        = NULL,
3072                 .enum_list      = NULL,
3073                 .flags          = FLAG_ADVANCED,
3074         },
3075         {
3076                 .label          = "add group script",
3077                 .type           = P_STRING,
3078                 .p_class        = P_GLOBAL,
3079                 .ptr            = &Globals.szAddGroupScript,
3080                 .special        = NULL,
3081                 .enum_list      = NULL,
3082                 .flags          = FLAG_ADVANCED,
3083         },
3084         {
3085                 .label          = "delete group script",
3086                 .type           = P_STRING,
3087                 .p_class        = P_GLOBAL,
3088                 .ptr            = &Globals.szDelGroupScript,
3089                 .special        = NULL,
3090                 .enum_list      = NULL,
3091                 .flags          = FLAG_ADVANCED,
3092         },
3093         {
3094                 .label          = "add user to group script",
3095                 .type           = P_STRING,
3096                 .p_class        = P_GLOBAL,
3097                 .ptr            = &Globals.szAddUserToGroupScript,
3098                 .special        = NULL,
3099                 .enum_list      = NULL,
3100                 .flags          = FLAG_ADVANCED,
3101         },
3102         {
3103                 .label          = "delete user from group script",
3104                 .type           = P_STRING,
3105                 .p_class        = P_GLOBAL,
3106                 .ptr            = &Globals.szDelUserFromGroupScript,
3107                 .special        = NULL,
3108                 .enum_list      = NULL,
3109                 .flags          = FLAG_ADVANCED,
3110         },
3111         {
3112                 .label          = "set primary group script",
3113                 .type           = P_STRING,
3114                 .p_class        = P_GLOBAL,
3115                 .ptr            = &Globals.szSetPrimaryGroupScript,
3116                 .special        = NULL,
3117                 .enum_list      = NULL,
3118                 .flags          = FLAG_ADVANCED,
3119         },
3120         {
3121                 .label          = "add machine script",
3122                 .type           = P_STRING,
3123                 .p_class        = P_GLOBAL,
3124                 .ptr            = &Globals.szAddMachineScript,
3125                 .special        = NULL,
3126                 .enum_list      = NULL,
3127                 .flags          = FLAG_ADVANCED,
3128         },
3129         {
3130                 .label          = "shutdown script",
3131                 .type           = P_STRING,
3132                 .p_class        = P_GLOBAL,
3133                 .ptr            = &Globals.szShutdownScript,
3134                 .special        = NULL,
3135                 .enum_list      = NULL,
3136                 .flags          = FLAG_ADVANCED,
3137         },
3138         {
3139                 .label          = "abort shutdown script",
3140                 .type           = P_STRING,
3141                 .p_class        = P_GLOBAL,
3142                 .ptr            = &Globals.szAbortShutdownScript,
3143                 .special        = NULL,
3144                 .enum_list      = NULL,
3145                 .flags          = FLAG_ADVANCED,
3146         },
3147         {
3148                 .label          = "username map script",
3149                 .type           = P_STRING,
3150                 .p_class        = P_GLOBAL,
3151                 .ptr            = &Globals.szUsernameMapScript,
3152                 .special        = NULL,
3153                 .enum_list      = NULL,
3154                 .flags          = FLAG_ADVANCED,
3155         },
3156         {
3157                 .label          = "logon script",
3158                 .type           = P_STRING,
3159                 .p_class        = P_GLOBAL,
3160                 .ptr            = &Globals.szLogonScript,
3161                 .special        = NULL,
3162                 .enum_list      = NULL,
3163                 .flags          = FLAG_ADVANCED,
3164         },
3165         {
3166                 .label          = "logon path",
3167                 .type           = P_STRING,
3168                 .p_class        = P_GLOBAL,
3169                 .ptr            = &Globals.szLogonPath,
3170                 .special        = NULL,
3171                 .enum_list      = NULL,
3172                 .flags          = FLAG_ADVANCED,
3173         },
3174         {
3175                 .label          = "logon drive",
3176                 .type           = P_STRING,
3177                 .p_class        = P_GLOBAL,
3178                 .ptr            = &Globals.szLogonDrive,
3179                 .special        = NULL,
3180                 .enum_list      = NULL,
3181                 .flags          = FLAG_ADVANCED,
3182         },
3183         {
3184                 .label          = "logon home",
3185                 .type           = P_STRING,
3186                 .p_class        = P_GLOBAL,
3187                 .ptr            = &Globals.szLogonHome,
3188                 .special        = NULL,
3189                 .enum_list      = NULL,
3190                 .flags          = FLAG_ADVANCED,
3191         },
3192         {
3193                 .label          = "domain logons",
3194                 .type           = P_BOOL,
3195                 .p_class        = P_GLOBAL,
3196                 .ptr            = &Globals.bDomainLogons,
3197                 .special        = NULL,
3198                 .enum_list      = NULL,
3199                 .flags          = FLAG_ADVANCED,
3200         },
3201
3202         {
3203                 .label          = "init logon delayed hosts",
3204                 .type           = P_LIST,
3205                 .p_class        = P_GLOBAL,
3206                 .ptr            = &Globals.szInitLogonDelayedHosts,
3207                 .flags          = FLAG_ADVANCED,
3208         },
3209
3210         {
3211                 .label          = "init logon delay",
3212                 .type           = P_INTEGER,
3213                 .p_class        = P_GLOBAL,
3214                 .ptr            = &Globals.InitLogonDelay,
3215                 .flags          = FLAG_ADVANCED,
3216
3217         },
3218
3219         {N_("Browse Options"), P_SEP, P_SEPARATOR},
3220
3221         {
3222                 .label          = "os level",
3223                 .type           = P_INTEGER,
3224                 .p_class        = P_GLOBAL,
3225                 .ptr            = &Globals.os_level,
3226                 .special        = NULL,
3227                 .enum_list      = NULL,
3228                 .flags          = FLAG_BASIC | FLAG_ADVANCED,
3229         },
3230         {
3231                 .label          = "lm announce",
3232                 .type           = P_ENUM,
3233                 .p_class        = P_GLOBAL,
3234                 .ptr            = &Globals.lm_announce,
3235                 .special        = NULL,
3236                 .enum_list      = enum_bool_auto,
3237                 .flags          = FLAG_ADVANCED,
3238         },
3239         {
3240                 .label          = "lm interval",
3241                 .type           = P_INTEGER,
3242                 .p_class        = P_GLOBAL,
3243                 .ptr            = &Globals.lm_interval,
3244                 .special        = NULL,
3245                 .enum_list      = NULL,
3246                 .flags          = FLAG_ADVANCED,
3247         },
3248         {
3249                 .label          = "preferred master",
3250                 .type           = P_ENUM,
3251                 .p_class        = P_GLOBAL,
3252                 .ptr            = &Globals.iPreferredMaster,
3253                 .special        = NULL,
3254                 .enum_list      = enum_bool_auto,
3255                 .flags          = FLAG_BASIC | FLAG_ADVANCED,
3256         },
3257         {
3258                 .label          = "prefered master",
3259                 .type           = P_ENUM,
3260                 .p_class        = P_GLOBAL,
3261                 .ptr            = &Globals.iPreferredMaster,
3262                 .special        = NULL,
3263                 .enum_list      = enum_bool_auto,
3264                 .flags          = FLAG_HIDE,
3265         },
3266         {
3267                 .label          = "local master",
3268                 .type           = P_BOOL,
3269                 .p_class        = P_GLOBAL,
3270                 .ptr            = &Globals.bLocalMaster,
3271                 .special        = NULL,
3272                 .enum_list      = NULL,
3273                 .flags          = FLAG_BASIC | FLAG_ADVANCED,
3274         },
3275         {
3276                 .label          = "domain master",
3277                 .type           = P_ENUM,
3278                 .p_class        = P_GLOBAL,
3279                 .ptr            = &Globals.iDomainMaster,
3280                 .special        = NULL,
3281                 .enum_list      = enum_bool_auto,
3282                 .flags          = FLAG_BASIC | FLAG_ADVANCED,
3283         },
3284         {
3285                 .label          = "browse list",
3286                 .type           = P_BOOL,
3287                 .p_class        = P_GLOBAL,
3288                 .ptr            = &Globals.bBrowseList,
3289                 .special        = NULL,
3290                 .enum_list      = NULL,
3291                 .flags          = FLAG_ADVANCED,
3292         },
3293         {
3294                 .label          = "browseable",
3295                 .type           = P_BOOL,
3296                 .p_class        = P_LOCAL,
3297                 .ptr            = &sDefault.bBrowseable,
3298                 .special        = NULL,
3299                 .enum_list      = NULL,
3300                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
3301         },
3302         {
3303                 .label          = "browsable",
3304                 .type           = P_BOOL,
3305                 .p_class        = P_LOCAL,
3306                 .ptr            = &sDefault.bBrowseable,
3307                 .special        = NULL,
3308                 .enum_list      = NULL,
3309                 .flags          = FLAG_HIDE,
3310         },
3311         {
3312                 .label          = "enhanced browsing",
3313                 .type           = P_BOOL,
3314                 .p_class        = P_GLOBAL,
3315                 .ptr            = &Globals.enhanced_browsing,
3316                 .special        = NULL,
3317                 .enum_list      = NULL,
3318                 .flags          = FLAG_ADVANCED,
3319         },
3320
3321         {N_("WINS Options"), P_SEP, P_SEPARATOR},
3322
3323         {
3324                 .label          = "dns proxy",
3325                 .type           = P_BOOL,
3326                 .p_class        = P_GLOBAL,
3327                 .ptr            = &Globals.bDNSproxy,
3328                 .special        = NULL,
3329                 .enum_list      = NULL,
3330                 .flags          = FLAG_ADVANCED,
3331         },
3332         {
3333                 .label          = "wins proxy",
3334                 .type           = P_BOOL,
3335                 .p_class        = P_GLOBAL,
3336                 .ptr            = &Globals.bWINSproxy,
3337                 .special        = NULL,
3338                 .enum_list      = NULL,
3339                 .flags          = FLAG_ADVANCED,
3340         },
3341         {
3342                 .label          = "wins server",
3343                 .type           = P_LIST,
3344                 .p_class        = P_GLOBAL,
3345                 .ptr            = &Globals.szWINSservers,
3346                 .special        = NULL,
3347                 .enum_list      = NULL,
3348                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
3349         },
3350         {
3351                 .label          = "wins support",
3352                 .type           = P_BOOL,
3353                 .p_class        = P_GLOBAL,
3354                 .ptr            = &Globals.bWINSsupport,
3355                 .special        = NULL,
3356                 .enum_list      = NULL,
3357                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
3358         },
3359         {
3360                 .label          = "wins hook",
3361                 .type           = P_STRING,
3362                 .p_class        = P_GLOBAL,
3363                 .ptr            = &Globals.szWINSHook,
3364                 .special        = NULL,
3365                 .enum_list      = NULL,
3366                 .flags          = FLAG_ADVANCED,
3367         },
3368
3369         {N_("Locking Options"), P_SEP, P_SEPARATOR},
3370
3371         {
3372                 .label          = "blocking locks",
3373                 .type           = P_BOOL,
3374                 .p_class        = P_LOCAL,
3375                 .ptr            = &sDefault.bBlockingLocks,
3376                 .special        = NULL,
3377                 .enum_list      = NULL,
3378                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3379         },
3380         {
3381                 .label          = "csc policy",
3382                 .type           = P_ENUM,
3383                 .p_class        = P_LOCAL,
3384                 .ptr            = &sDefault.iCSCPolicy,
3385                 .special        = NULL,
3386                 .enum_list      = enum_csc_policy,
3387                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3388         },
3389         {
3390                 .label          = "fake oplocks",
3391                 .type           = P_BOOL,
3392                 .p_class        = P_LOCAL,
3393                 .ptr            = &sDefault.bFakeOplocks,
3394                 .special        = NULL,
3395                 .enum_list      = NULL,
3396                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
3397         },
3398         {
3399                 .label          = "kernel oplocks",
3400                 .type           = P_BOOL,
3401                 .p_class        = P_GLOBAL,
3402                 .ptr            = &Globals.bKernelOplocks,
3403                 .special        = NULL,
3404                 .enum_list      = NULL,
3405                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL,
3406         },
3407         {
3408                 .label          = "locking",
3409                 .type           = P_BOOL,
3410                 .p_class        = P_LOCAL,
3411                 .ptr            = &sDefault.bLocking,
3412                 .special        = NULL,
3413                 .enum_list      = NULL,
3414                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3415         },
3416         {
3417                 .label          = "lock spin time",
3418                 .type           = P_INTEGER,
3419                 .p_class        = P_GLOBAL,
3420                 .ptr            = &Globals.iLockSpinTime,
3421                 .special        = NULL,
3422                 .enum_list      = NULL,
3423                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL,
3424         },
3425         {
3426                 .label          = "oplocks",
3427                 .type           = P_BOOL,
3428                 .p_class        = P_LOCAL,
3429                 .ptr            = &sDefault.bOpLocks,
3430                 .special        = NULL,
3431                 .enum_list      = NULL,
3432                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3433         },
3434         {
3435                 .label          = "level2 oplocks",
3436                 .type           = P_BOOL,
3437                 .p_class        = P_LOCAL,
3438                 .ptr            = &sDefault.bLevel2OpLocks,
3439                 .special        = NULL,
3440                 .enum_list      = NULL,
3441                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3442         },
3443         {
3444                 .label          = "oplock break wait time",
3445                 .type           = P_INTEGER,
3446                 .p_class        = P_GLOBAL,
3447                 .ptr            = &Globals.oplock_break_wait_time,
3448                 .special        = NULL,
3449                 .enum_list      = NULL,
3450                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL,
3451         },
3452         {
3453                 .label          = "oplock contention limit",
3454                 .type           = P_INTEGER,
3455                 .p_class        = P_LOCAL,
3456                 .ptr            = &sDefault.iOplockContentionLimit,
3457                 .special        = NULL,
3458                 .enum_list      = NULL,
3459                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3460         },
3461         {
3462                 .label          = "posix locking",
3463                 .type           = P_BOOL,
3464                 .p_class        = P_LOCAL,
3465                 .ptr            = &sDefault.bPosixLocking,
3466                 .special        = NULL,
3467                 .enum_list      = NULL,
3468                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3469         },
3470         {
3471                 .label          = "strict locking",
3472                 .type           = P_ENUM,
3473                 .p_class        = P_LOCAL,
3474                 .ptr            = &sDefault.iStrictLocking,
3475                 .special        = NULL,
3476                 .enum_list      = enum_bool_auto,
3477                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3478         },
3479         {
3480                 .label          = "share modes",
3481                 .type           = P_BOOL,
3482                 .p_class        = P_LOCAL,
3483                 .ptr            = &sDefault.bShareModes,
3484                 .special        = NULL,
3485                 .enum_list      = NULL,
3486                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL | FLAG_DEPRECATED,
3487         },
3488
3489         {N_("Ldap Options"), P_SEP, P_SEPARATOR},
3490
3491         {
3492                 .label          = "ldap admin dn",
3493                 .type           = P_STRING,
3494                 .p_class        = P_GLOBAL,
3495                 .ptr            = &Globals.szLdapAdminDn,
3496                 .special        = NULL,
3497                 .enum_list      = NULL,
3498                 .flags          = FLAG_ADVANCED,
3499         },
3500         {
3501                 .label          = "ldap delete dn",
3502                 .type           = P_BOOL,
3503                 .p_class        = P_GLOBAL,
3504                 .ptr            = &Globals.ldap_delete_dn,
3505                 .special        = NULL,
3506                 .enum_list      = NULL,
3507                 .flags          = FLAG_ADVANCED,
3508         },
3509         {
3510                 .label          = "ldap group suffix",
3511                 .type           = P_STRING,
3512                 .p_class        = P_GLOBAL,
3513                 .ptr            = &Globals.szLdapGroupSuffix,
3514                 .special        = NULL,
3515                 .enum_list      = NULL,
3516                 .flags          = FLAG_ADVANCED,
3517         },
3518         {
3519                 .label          = "ldap idmap suffix",
3520                 .type           = P_STRING,
3521                 .p_class        = P_GLOBAL,
3522                 .ptr            = &Globals.szLdapIdmapSuffix,
3523                 .special        = NULL,
3524                 .enum_list      = NULL,
3525                 .flags          = FLAG_ADVANCED,
3526         },
3527         {
3528                 .label          = "ldap machine suffix",
3529                 .type           = P_STRING,
3530                 .p_class        = P_GLOBAL,
3531                 .ptr            = &Globals.szLdapMachineSuffix,
3532                 .special        = NULL,
3533                 .enum_list      = NULL,
3534                 .flags          = FLAG_ADVANCED,
3535         },
3536         {
3537                 .label          = "ldap passwd sync",
3538                 .type           = P_ENUM,
3539                 .p_class        = P_GLOBAL,
3540                 .ptr            = &Globals.ldap_passwd_sync,
3541                 .special        = NULL,
3542                 .enum_list      = enum_ldap_passwd_sync,
3543                 .flags          = FLAG_ADVANCED,
3544         },
3545         {
3546                 .label          = "ldap password sync",
3547                 .type           = P_ENUM,
3548                 .p_class        = P_GLOBAL,
3549                 .ptr            = &Globals.ldap_passwd_sync,
3550                 .special        = NULL,
3551                 .enum_list      = enum_ldap_passwd_sync,
3552                 .flags          = FLAG_HIDE,
3553         },
3554         {
3555                 .label          = "ldap replication sleep",
3556                 .type           = P_INTEGER,
3557                 .p_class        = P_GLOBAL,
3558                 .ptr            = &Globals.ldap_replication_sleep,
3559                 .special        = NULL,
3560                 .enum_list      = NULL,
3561                 .flags          = FLAG_ADVANCED,
3562         },
3563         {
3564                 .label          = "ldap suffix",
3565                 .type           = P_STRING,
3566                 .p_class        = P_GLOBAL,
3567                 .ptr            = &Globals.szLdapSuffix,
3568                 .special        = NULL,
3569                 .enum_list      = NULL,
3570                 .flags          = FLAG_ADVANCED,
3571         },
3572         {
3573                 .label          = "ldap ssl",
3574                 .type           = P_ENUM,
3575                 .p_class        = P_GLOBAL,
3576                 .ptr            = &Globals.ldap_ssl,
3577                 .special        = NULL,
3578                 .enum_list      = enum_ldap_ssl,
3579                 .flags          = FLAG_ADVANCED,
3580         },
3581         {
3582                 .label          = "ldap ssl ads",
3583                 .type           = P_BOOL,
3584                 .p_class        = P_GLOBAL,
3585                 .ptr            = &Globals.ldap_ssl_ads,
3586                 .special        = NULL,
3587                 .enum_list      = NULL,
3588                 .flags          = FLAG_ADVANCED,
3589         },
3590         {
3591                 .label          = "ldap timeout",
3592                 .type           = P_INTEGER,
3593                 .p_class        = P_GLOBAL,
3594                 .ptr            = &Globals.ldap_timeout,
3595                 .special        = NULL,
3596                 .enum_list      = NULL,
3597                 .flags          = FLAG_ADVANCED,
3598         },
3599         {
3600                 .label          = "ldap connection timeout",
3601                 .type           = P_INTEGER,
3602                 .p_class        = P_GLOBAL,
3603                 .ptr            = &Globals.ldap_connection_timeout,
3604                 .special        = NULL,
3605                 .enum_list      = NULL,
3606                 .flags          = FLAG_ADVANCED,
3607         },
3608         {
3609                 .label          = "ldap page size",
3610                 .type           = P_INTEGER,
3611                 .p_class        = P_GLOBAL,
3612                 .ptr            = &Globals.ldap_page_size,
3613                 .special        = NULL,
3614                 .enum_list      = NULL,
3615                 .flags          = FLAG_ADVANCED,
3616         },
3617         {
3618                 .label          = "ldap user suffix",
3619                 .type           = P_STRING,
3620                 .p_class        = P_GLOBAL,
3621                 .ptr            = &Globals.szLdapUserSuffix,
3622                 .special        = NULL,
3623                 .enum_list      = NULL,
3624                 .flags          = FLAG_ADVANCED,
3625         },
3626         {
3627                 .label          = "ldap debug level",
3628                 .type           = P_INTEGER,
3629                 .p_class        = P_GLOBAL,
3630                 .ptr            = &Globals.ldap_debug_level,
3631                 .special        = handle_ldap_debug_level,
3632                 .enum_list      = NULL,
3633                 .flags          = FLAG_ADVANCED,
3634         },
3635         {
3636                 .label          = "ldap debug threshold",
3637                 .type           = P_INTEGER,
3638                 .p_class        = P_GLOBAL,
3639                 .ptr            = &Globals.ldap_debug_threshold,
3640                 .special        = NULL,
3641                 .enum_list      = NULL,
3642                 .flags          = FLAG_ADVANCED,
3643         },
3644
3645         {N_("EventLog Options"), P_SEP, P_SEPARATOR},
3646
3647         {
3648                 .label          = "eventlog list",
3649                 .type           = P_LIST,
3650                 .p_class        = P_GLOBAL,
3651                 .ptr            = &Globals.szEventLogs,
3652                 .special        = NULL,
3653                 .enum_list      = NULL,
3654                 .flags          = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
3655         },
3656
3657         {N_("Miscellaneous Options"), P_SEP, P_SEPARATOR},
3658
3659         {
3660                 .label          = "add share command",
3661                 .type           = P_STRING,
3662                 .p_class        = P_GLOBAL,
3663                 .ptr            = &Globals.szAddShareCommand,
3664                 .special        = NULL,
3665                 .enum_list      = NULL,
3666                 .flags          = FLAG_ADVANCED,
3667         },
3668         {
3669                 .label          = "change share command",
3670                 .type           = P_STRING,
3671                 .p_class        = P_GLOBAL,
3672                 .ptr            = &Globals.szChangeShareCommand,
3673                 .special        = NULL,
3674                 .enum_list      = NULL,
3675                 .flags          = FLAG_ADVANCED,
3676         },
3677         {
3678                 .label          = "delete share command",
3679                 .type           = P_STRING,
3680                 .p_class        = P_GLOBAL,
3681                 .ptr            = &Globals.szDeleteShareCommand,
3682                 .special        = NULL,
3683                 .enum_list      = NULL,
3684                 .flags          = FLAG_ADVANCED,
3685         },
3686         {
3687                 .label          = "config file",
3688                 .type           = P_STRING,
3689                 .p_class        = P_GLOBAL,
3690                 .ptr            = &Globals.szConfigFile,
3691                 .special        = NULL,
3692                 .enum_list      = NULL,
3693                 .flags          = FLAG_HIDE,
3694         },
3695         {
3696                 .label          = "preload",
3697                 .type           = P_STRING,
3698                 .p_class        = P_GLOBAL,
3699                 .ptr            = &Globals.szAutoServices,
3700                 .special        = NULL,
3701                 .enum_list      = NULL,
3702                 .flags          = FLAG_ADVANCED,
3703         },
3704         {
3705                 .label          = "auto services",
3706                 .type           = P_STRING,
3707                 .p_class        = P_GLOBAL,
3708                 .ptr            = &Globals.szAutoServices,
3709                 .special        = NULL,
3710                 .enum_list      = NULL,
3711                 .flags          = FLAG_ADVANCED,
3712         },
3713         {
3714                 .label          = "lock directory",
3715                 .type           = P_STRING,
3716                 .p_class        = P_GLOBAL,
3717                 .ptr            = &Globals.szLockDir,
3718                 .special        = NULL,
3719                 .enum_list      = NULL,
3720                 .flags          = FLAG_ADVANCED,
3721         },
3722         {
3723                 .label          = "lock dir",
3724                 .type           = P_STRING,
3725                 .p_class        = P_GLOBAL,
3726                 .ptr            = &Globals.szLockDir,
3727                 .special        = NULL,
3728                 .enum_list      = NULL,
3729                 .flags          = FLAG_HIDE,
3730         },
3731         {
3732                 .label          = "pid directory",
3733                 .type           = P_STRING,
3734                 .p_class        = P_GLOBAL,
3735                 .ptr            = &Globals.szPidDir,
3736                 .special        = NULL,
3737                 .enum_list      = NULL,
3738                 .flags          = FLAG_ADVANCED,
3739         },
3740 #ifdef WITH_UTMP
3741         {
3742                 .label          = "utmp directory",
3743                 .type           = P_STRING,
3744                 .p_class        = P_GLOBAL,
3745                 .ptr            = &Globals.szUtmpDir,
3746                 .special        = NULL,
3747                 .enum_list      = NULL,
3748                 .flags          = FLAG_ADVANCED,
3749         },
3750         {
3751                 .label          = "wtmp directory",
3752                 .type           = P_STRING,
3753                 .p_class        = P_GLOBAL,
3754                 .ptr            = &Globals.szWtmpDir,
3755                 .special        = NULL,
3756                 .enum_list      = NULL,
3757                 .flags          = FLAG_ADVANCED,
3758         },
3759         {
3760                 .label          = "utmp",
3761                 .type           = P_BOOL,
3762                 .p_class        = P_GLOBAL,
3763                 .ptr            = &Globals.bUtmp,
3764                 .special        = NULL,
3765                 .enum_list      = NULL,
3766                 .flags          = FLAG_ADVANCED,
3767         },
3768 #endif
3769         {
3770                 .label          = "default service",
3771                 .type           = P_STRING,
3772                 .p_class        = P_GLOBAL,
3773                 .ptr            = &Globals.szDefaultService,
3774                 .special        = NULL,
3775                 .enum_list      = NULL,
3776                 .flags          = FLAG_ADVANCED,
3777         },
3778         {
3779                 .label          = "default",
3780                 .type           = P_STRING,
3781                 .p_class        = P_GLOBAL,
3782                 .ptr            = &Globals.szDefaultService,
3783                 .special        = NULL,
3784                 .enum_list      = NULL,
3785                 .flags          = FLAG_ADVANCED,
3786         },
3787         {
3788                 .label          = "message command",
3789                 .type           = P_STRING,
3790                 .p_class        = P_GLOBAL,
3791                 .ptr            = &Globals.szMsgCommand,
3792                 .special        = NULL,
3793                 .enum_list      = NULL,
3794                 .flags          = FLAG_ADVANCED,
3795         },
3796         {
3797                 .label          = "dfree cache time",
3798                 .type           = P_INTEGER,
3799                 .p_class        = P_LOCAL,
3800                 .ptr            = &sDefault.iDfreeCacheTime,
3801                 .special        = NULL,
3802                 .enum_list      = NULL,
3803                 .flags          = FLAG_ADVANCED,
3804         },
3805         {
3806                 .label          = "dfree command",
3807                 .type           = P_STRING,
3808                 .p_class        = P_LOCAL,
3809                 .ptr            = &sDefault.szDfree,
3810                 .special        = NULL,
3811                 .enum_list      = NULL,
3812                 .flags          = FLAG_ADVANCED,
3813         },
3814         {
3815                 .label          = "get quota command",
3816                 .type           = P_STRING,
3817                 .p_class        = P_GLOBAL,
3818                 .ptr            = &Globals.szGetQuota,
3819                 .special        = NULL,
3820                 .enum_list      = NULL,
3821                 .flags          = FLAG_ADVANCED,
3822         },
3823         {
3824                 .label          = "set quota command",
3825                 .type           = P_STRING,
3826                 .p_class        = P_GLOBAL,
3827                 .ptr            = &Globals.szSetQuota,
3828                 .special        = NULL,
3829                 .enum_list      = NULL,
3830                 .flags          = FLAG_ADVANCED,
3831         },
3832         {
3833                 .label          = "remote announce",
3834                 .type           = P_STRING,
3835                 .p_class        = P_GLOBAL,
3836                 .ptr            = &Globals.szRemoteAnnounce,
3837                 .special        = NULL,
3838                 .enum_list      = NULL,
3839                 .flags          = FLAG_ADVANCED,
3840         },
3841         {
3842                 .label          = "remote browse sync",
3843                 .type           = P_STRING,
3844                 .p_class        = P_GLOBAL,
3845                 .ptr            = &Globals.szRemoteBrowseSync,
3846                 .special        = NULL,
3847                 .enum_list      = NULL,
3848                 .flags          = FLAG_ADVANCED,
3849         },
3850         {
3851                 .label          = "socket address",
3852                 .type           = P_STRING,
3853                 .p_class        = P_GLOBAL,
3854                 .ptr            = &Globals.szSocketAddress,
3855                 .special        = NULL,
3856                 .enum_list      = NULL,
3857                 .flags          = FLAG_ADVANCED,
3858         },
3859         {
3860                 .label          = "homedir map",
3861                 .type           = P_STRING,
3862                 .p_class        = P_GLOBAL,
3863                 .ptr            = &Globals.szNISHomeMapName,
3864                 .special        = NULL,
3865                 .enum_list      = NULL,
3866                 .flags          = FLAG_ADVANCED,
3867         },
3868         {
3869                 .label          = "afs username map",
3870                 .type           = P_STRING,
3871                 .p_class        = P_GLOBAL,
3872                 .ptr            = &Globals.szAfsUsernameMap,
3873                 .special        = NULL,
3874                 .enum_list      = NULL,
3875                 .flags          = FLAG_ADVANCED,
3876         },
3877         {
3878                 .label          = "afs token lifetime",
3879                 .type           = P_INTEGER,
3880                 .p_class        = P_GLOBAL,
3881                 .ptr            = &Globals.iAfsTokenLifetime,
3882                 .special        = NULL,
3883                 .enum_list      = NULL,
3884                 .flags          = FLAG_ADVANCED,
3885         },
3886         {
3887                 .label          = "log nt token command",
3888                 .type           = P_STRING,
3889                 .p_class        = P_GLOBAL,
3890                 .ptr            = &Globals.szLogNtTokenCommand,
3891                 .special        = NULL,
3892                 .enum_list      = NULL,
3893                 .flags          = FLAG_ADVANCED,
3894         },
3895         {
3896                 .label          = "time offset",
3897                 .type           = P_INTEGER,
3898                 .p_class        = P_GLOBAL,
3899                 .ptr            = &extra_time_offset,
3900                 .special        = NULL,
3901                 .enum_list      = NULL,
3902                 .flags          = FLAG_ADVANCED,
3903         },
3904         {
3905                 .label          = "NIS homedir",
3906                 .type           = P_BOOL,
3907                 .p_class        = P_GLOBAL,
3908                 .ptr            = &Globals.bNISHomeMap,
3909                 .special        = NULL,
3910                 .enum_list      = NULL,
3911                 .flags          = FLAG_ADVANCED,
3912         },
3913         {
3914                 .label          = "-valid",
3915                 .type           = P_BOOL,
3916                 .p_class        = P_LOCAL,
3917                 .ptr            = &sDefault.valid,
3918                 .special        = NULL,
3919                 .enum_list      = NULL,
3920                 .flags          = FLAG_HIDE,
3921         },
3922         {
3923                 .label          = "copy",
3924                 .type           = P_STRING,
3925                 .p_class        = P_LOCAL,
3926                 .ptr            = &sDefault.szCopy,
3927                 .special        = handle_copy,
3928                 .enum_list      = NULL,
3929                 .flags          = FLAG_HIDE,
3930         },
3931         {
3932                 .label          = "include",
3933                 .type           = P_STRING,
3934                 .p_class        = P_LOCAL,
3935                 .ptr            = &sDefault.szInclude,
3936                 .special        = handle_include,
3937                 .enum_list      = NULL,
3938                 .flags          = FLAG_HIDE,
3939         },
3940         {
3941                 .label          = "preexec",
3942                 .type           = P_STRING,
3943                 .p_class        = P_LOCAL,
3944                 .ptr            = &sDefault.szPreExec,
3945                 .special        = NULL,
3946                 .enum_list      = NULL,
3947                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
3948         },
3949         {
3950                 .label          = "exec",
3951                 .type           = P_STRING,
3952                 .p_class        = P_LOCAL,
3953                 .ptr            = &sDefault.szPreExec,
3954                 .special        = NULL,
3955                 .enum_list      = NULL,
3956                 .flags          = FLAG_ADVANCED,
3957         },
3958         {
3959                 .label          = "preexec close",
3960                 .type           = P_BOOL,
3961                 .p_class        = P_LOCAL,
3962                 .ptr            = &sDefault.bPreexecClose,
3963                 .special        = NULL,
3964                 .enum_list      = NULL,
3965                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
3966         },
3967         {
3968                 .label          = "postexec",
3969                 .type           = P_STRING,
3970                 .p_class        = P_LOCAL,
3971                 .ptr            = &sDefault.szPostExec,
3972                 .special        = NULL,
3973                 .enum_list      = NULL,
3974                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
3975         },
3976         {
3977                 .label          = "root preexec",
3978                 .type           = P_STRING,
3979                 .p_class        = P_LOCAL,
3980                 .ptr            = &sDefault.szRootPreExec,
3981                 .special        = NULL,
3982                 .enum_list      = NULL,
3983                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
3984         },
3985         {
3986                 .label          = "root preexec close",
3987                 .type           = P_BOOL,
3988                 .p_class        = P_LOCAL,
3989                 .ptr            = &sDefault.bRootpreexecClose,
3990                 .special        = NULL,
3991                 .enum_list      = NULL,
3992                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
3993         },
3994         {
3995                 .label          = "root postexec",
3996                 .type           = P_STRING,
3997                 .p_class        = P_LOCAL,
3998                 .ptr            = &sDefault.szRootPostExec,
3999                 .special        = NULL,
4000                 .enum_list      = NULL,
4001                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
4002         },
4003         {
4004                 .label          = "available",
4005                 .type           = P_BOOL,
4006                 .p_class        = P_LOCAL,
4007                 .ptr            = &sDefault.bAvailable,
4008                 .special        = NULL,
4009                 .enum_list      = NULL,
4010                 .flags          = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
4011         },
4012         {
4013                 .label          = "registry shares",
4014                 .type           = P_BOOL,
4015                 .p_class        = P_GLOBAL,
4016                 .ptr            = &Globals.bRegistryShares,
4017                 .special        = NULL,
4018                 .enum_list      = NULL,
4019                 .flags          = FLAG_ADVANCED,
4020         },
4021         {
4022                 .label          = "usershare allow guests",
4023                 .type           = P_BOOL,
4024                 .p_class        = P_GLOBAL,
4025                 .ptr            = &Globals.bUsershareAllowGuests,
4026                 .special        = NULL,
4027                 .enum_list      = NULL,
4028                 .flags          = FLAG_ADVANCED,
4029         },
4030         {
4031                 .label          = "usershare max shares",
4032                 .type           = P_INTEGER,
4033                 .p_class        = P_GLOBAL,
4034                 .ptr            = &Globals.iUsershareMaxShares,
4035                 .special        = NULL,
4036                 .enum_list      = NULL,
4037                 .flags          = FLAG_ADVANCED,
4038         },
4039         {
4040                 .label          = "usershare owner only",
4041                 .type           = P_BOOL,
4042                 .p_class        = P_GLOBAL,
4043                 .ptr            = &Globals.bUsershareOwnerOnly,
4044                 .special        = NULL,
4045                 .enum_list      = NULL,
4046                 .flags          = FLAG_ADVANCED,
4047         },
4048         {
4049                 .label          = "usershare path",
4050                 .type           = P_STRING,
4051                 .p_class        = P_GLOBAL,
4052                 .ptr            = &Globals.szUsersharePath,
4053                 .special        = NULL,
4054                 .enum_list      = NULL,
4055                 .flags          = FLAG_ADVANCED,
4056         },
4057         {
4058                 .label          = "usershare prefix allow list",
4059                 .type           = P_LIST,
4060                 .p_class        = P_GLOBAL,
4061                 .ptr            = &Globals.szUsersharePrefixAllowList,
4062                 .special        = NULL,
4063                 .enum_list      = NULL,
4064                 .flags          = FLAG_ADVANCED,
4065         },
4066         {
4067                 .label          = "usershare prefix deny list",
4068                 .type           = P_LIST,
4069                 .p_class        = P_GLOBAL,
4070                 .ptr            = &Globals.szUsersharePrefixDenyList,
4071                 .special        = NULL,
4072                 .enum_list      = NULL,
4073                 .flags          = FLAG_ADVANCED,
4074         },
4075         {
4076                 .label          = "usershare template share",
4077                 .type           = P_STRING,
4078                 .p_class        = P_GLOBAL,
4079                 .ptr            = &Globals.szUsershareTemplateShare,
4080                 .special        = NULL,
4081                 .enum_list      = NULL,
4082                 .flags          = FLAG_ADVANCED,
4083         },
4084         {
4085                 .label          = "volume",
4086                 .type           = P_STRING,
4087                 .p_class        = P_LOCAL,
4088                 .ptr            = &sDefault.volume,
4089                 .special        = NULL,
4090                 .enum_list      = NULL,
4091                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
4092         },
4093         {
4094                 .label          = "fstype",
4095                 .type           = P_STRING,
4096                 .p_class        = P_LOCAL,
4097                 .ptr            = &sDefault.fstype,
4098                 .special        = NULL,
4099                 .enum_list      = NULL,
4100                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
4101         },
4102         {
4103                 .label          = "set directory",
4104                 .type           = P_BOOLREV,
4105                 .p_class        = P_LOCAL,
4106                 .ptr            = &sDefault.bNo_set_dir,
4107                 .special        = NULL,
4108                 .enum_list      = NULL,
4109                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
4110         },
4111         {
4112                 .label          = "wide links",
4113                 .type           = P_BOOL,
4114                 .p_class        = P_LOCAL,
4115                 .ptr            = &sDefault.bWidelinks,
4116                 .special        = NULL,
4117                 .enum_list      = NULL,
4118                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
4119         },
4120         {
4121                 .label          = "follow symlinks",
4122                 .type           = P_BOOL,
4123                 .p_class        = P_LOCAL,
4124                 .ptr            = &sDefault.bSymlinks,
4125                 .special        = NULL,
4126                 .enum_list      = NULL,
4127                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
4128         },
4129         {
4130                 .label          = "dont descend",
4131                 .type           = P_STRING,
4132                 .p_class        = P_LOCAL,
4133                 .ptr            = &sDefault.szDontdescend,
4134                 .special        = NULL,
4135                 .enum_list      = NULL,
4136                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
4137         },
4138         {
4139                 .label          = "magic script",
4140                 .type           = P_STRING,
4141                 .p_class        = P_LOCAL,
4142                 .ptr            = &sDefault.szMagicScript,
4143                 .special        = NULL,
4144                 .enum_list      = NULL,
4145                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
4146         },
4147         {
4148                 .label          = "magic output",
4149                 .type           = P_STRING,
4150                 .p_class        = P_LOCAL,
4151                 .ptr            = &sDefault.szMagicOutput,
4152                 .special        = NULL,
4153                 .enum_list      = NULL,
4154                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
4155         },
4156         {
4157                 .label          = "delete readonly",
4158                 .type           = P_BOOL,
4159                 .p_class        = P_LOCAL,
4160                 .ptr            = &sDefault.bDeleteReadonly,
4161                 .special        = NULL,
4162                 .enum_list      = NULL,
4163                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
4164         },
4165         {
4166                 .label          = "dos filemode",
4167                 .type           = P_BOOL,
4168                 .p_class        = P_LOCAL,
4169                 .ptr            = &sDefault.bDosFilemode,
4170                 .special        = NULL,
4171                 .enum_list      = NULL,
4172                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
4173         },
4174         {
4175                 .label          = "dos filetimes",
4176                 .type           = P_BOOL,
4177                 .p_class        = P_LOCAL,
4178                 .ptr            = &sDefault.bDosFiletimes,
4179                 .special        = NULL,
4180                 .enum_list      = NULL,
4181                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
4182         },
4183         {
4184                 .label          = "dos filetime resolution",
4185                 .type           = P_BOOL,
4186                 .p_class        = P_LOCAL,
4187                 .ptr            = &sDefault.bDosFiletimeResolution,
4188                 .special        = NULL,
4189                 .enum_list      = NULL,
4190                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
4191         },
4192         {
4193                 .label          = "fake directory create times",
4194                 .type           = P_BOOL,
4195                 .p_class        = P_LOCAL,
4196                 .ptr            = &sDefault.bFakeDirCreateTimes,
4197                 .special        = NULL,
4198                 .enum_list      = NULL,
4199                 .flags          = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
4200         },
4201         {
4202                 .label          = "panic action",
4203                 .type           = P_STRING,
4204                 .p_class        = P_GLOBAL,
4205                 .ptr            = &Globals.szPanicAction,
4206                 .special        = NULL,
4207                 .enum_list      = NULL,
4208                 .flags          = FLAG_ADVANCED,
4209         },
4210
4211         {N_("VFS module options"), P_SEP, P_SEPARATOR},
4212
4213         {
4214                 .label          = "vfs objects",
4215                 .type           = P_LIST,
4216                 .p_class        = P_LOCAL,
4217                 .ptr            = &sDefault.szVfsObjects,
4218                 .special        = NULL,
4219                 .enum_list      = NULL,
4220                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
4221         },
4222         {
4223                 .label          = "vfs object",
4224                 .type           = P_LIST,
4225                 .p_class        = P_LOCAL,
4226                 .ptr            = &sDefault.szVfsObjects,
4227                 .special        = NULL,
4228                 .enum_list      = NULL,
4229                 .flags          = FLAG_HIDE,
4230         },
4231
4232
4233         {N_("MSDFS options"), P_SEP, P_SEPARATOR},
4234
4235         {
4236                 .label          = "msdfs root",
4237                 .type           = P_BOOL,
4238                 .p_class        = P_LOCAL,
4239                 .ptr            = &sDefault.bMSDfsRoot,
4240                 .special        = NULL,
4241                 .enum_list      = NULL,
4242                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
4243         },
4244         {
4245                 .label          = "msdfs proxy",
4246                 .type           = P_STRING,
4247                 .p_class        = P_LOCAL,
4248                 .ptr            = &sDefault.szMSDfsProxy,
4249                 .special        = NULL,
4250                 .enum_list      = NULL,
4251                 .flags          = FLAG_ADVANCED | FLAG_SHARE,
4252         },
4253         {
4254                 .label          = "host msdfs",
4255                 .type           = P_BOOL,
4256                 .p_class        = P_GLOBAL,
4257                 .ptr            = &Globals.bHostMSDfs,
4258                 .special        = NULL,
4259                 .enum_list      = NULL,
4260                 .flags          = FLAG_ADVANCED,
4261         },
4262
4263         {N_("Winbind options"), P_SEP, P_SEPARATOR},
4264
4265         {
4266                 .label          = "passdb expand explicit",
4267                 .type           = P_BOOL,
4268                 .p_class        = P_GLOBAL,
4269                 .ptr            = &Globals.bPassdbExpandExplicit,
4270                 .special        = NULL,
4271                 .enum_list      = NULL,
4272                 .flags          = FLAG_ADVANCED,
4273         },
4274         {
4275                 .label          = "idmap backend",
4276                 .type           = P_STRING,
4277                 .p_class        = P_GLOBAL,
4278                 .ptr            = &Globals.szIdmapBackend,
4279                 .special        = NULL,
4280                 .enum_list      = NULL,
4281                 .flags          = FLAG_ADVANCED,
4282         },
4283         {
4284                 .label          = "idmap alloc backend",
4285                 .type           = P_STRING,
4286                 .p_class        = P_GLOBAL,
4287                 .ptr            = &Globals.szIdmapAllocBackend,
4288                 .special        = NULL,
4289                 .enum_list      = NULL,
4290                 .flags          = FLAG_ADVANCED,
4291         },
4292         {
4293                 .label          = "idmap cache time",
4294                 .type           = P_INTEGER,
4295                 .p_class        = P_GLOBAL,
4296                 .ptr            = &Globals.iIdmapCacheTime,
4297                 .special        = NULL,
4298                 .enum_list      = NULL,
4299                 .flags          = FLAG_ADVANCED,
4300         },
4301         {
4302                 .label          = "idmap negative cache time",
4303                 .type           = P_INTEGER,
4304                 .p_class        = P_GLOBAL,
4305                 .ptr            = &Globals.iIdmapNegativeCacheTime,
4306                 .special        = NULL,
4307                 .enum_list      = NULL,
4308                 .flags          = FLAG_ADVANCED,
4309         },
4310         {
4311                 .label          = "idmap uid",
4312                 .type           = P_STRING,
4313                 .p_class        = P_GLOBAL,
4314                 .ptr            = &Globals.szIdmapUID,
4315                 .special        = handle_idmap_uid,
4316                 .enum_list      = NULL,
4317                 .flags          = FLAG_ADVANCED,
4318         },
4319         {
4320                 .label          = "winbind uid",
4321                 .type           = P_STRING,
4322                 .p_class        = P_GLOBAL,
4323                 .ptr            = &Globals.szIdmapUID,
4324                 .special        = handle_idmap_uid,
4325                 .enum_list      = NULL,
4326                 .flags          = FLAG_HIDE,
4327         },
4328         {
4329                 .label          = "idmap gid",
4330                 .type           = P_STRING,
4331                 .p_class        = P_GLOBAL,
4332                 .ptr            = &Globals.szIdmapGID,
4333                 .special        = handle_idmap_gid,
4334                 .enum_list      = NULL,
4335                 .flags          = FLAG_ADVANCED,
4336         },
4337         {
4338                 .label          = "winbind gid",
4339                 .type           = P_STRING,
4340                 .p_class        = P_GLOBAL,
4341                 .ptr            = &Globals.szIdmapGID,
4342                 .special        = handle_idmap_gid,
4343                 .enum_list      = NULL,
4344                 .flags          = FLAG_HIDE,
4345         },
4346         {
4347                 .label          = "template homedir",
4348                 .type           = P_STRING,
4349                 .p_class        = P_GLOBAL,
4350                 .ptr            = &Globals.szTemplateHomedir,
4351                 .special        = NULL,
4352                 .enum_list      = NULL,
4353                 .flags          = FLAG_ADVANCED,
4354         },
4355         {
4356                 .label          = "template shell",
4357                 .type           = P_STRING,
4358                 .p_class        = P_GLOBAL,
4359                 .ptr            = &Globals.szTemplateShell,
4360                 .special        = NULL,
4361                 .enum_list      = NULL,
4362                 .flags          = FLAG_ADVANCED,
4363         },
4364         {
4365                 .label          = "winbind separator",
4366                 .type           = P_STRING,
4367                 .p_class        = P_GLOBAL,
4368                 .ptr            = &Globals.szWinbindSeparator,
4369                 .special        = NULL,
4370                 .enum_list      = NULL,
4371                 .flags          = FLAG_ADVANCED,
4372         },
4373         {
4374                 .label          = "winbind cache time",
4375                 .type           = P_INTEGER,
4376                 .p_class        = P_GLOBAL,
4377                 .ptr            = &Globals.winbind_cache_time,
4378                 .special        = NULL,
4379                 .enum_list      = NULL,
4380                 .flags          = FLAG_ADVANCED,
4381         },
4382         {
4383                 .label          = "winbind reconnect delay",
4384                 .type           = P_INTEGER,
4385                 .p_class        = P_GLOBAL,
4386                 .ptr            = &Globals.winbind_reconnect_delay,
4387                 .special        = NULL,
4388                 .enum_list      = NULL,
4389                 .flags          = FLAG_ADVANCED,
4390         },
4391         {
4392                 .label          = "winbind enum users",
4393                 .type           = P_BOOL,
4394                 .p_class        = P_GLOBAL,
4395                 .ptr            = &Globals.bWinbindEnumUsers,
4396                 .special        = NULL,
4397                 .enum_list      = NULL,
4398                 .flags          = FLAG_ADVANCED,
4399         },
4400         {
4401                 .label          = "winbind enum groups",
4402                 .type           = P_BOOL,
4403                 .p_class        = P_GLOBAL,
4404                 .ptr            = &Globals.bWinbindEnumGroups,
4405                 .special        = NULL,
4406                 .enum_list      = NULL,
4407                 .flags          = FLAG_ADVANCED,
4408         },
4409         {
4410                 .label          = "winbind use default domain",
4411                 .type           = P_BOOL,
4412                 .p_class        = P_GLOBAL,
4413                 .ptr            = &Globals.bWinbindUseDefaultDomain,
4414                 .special        = NULL,
4415                 .enum_list      = NULL,
4416                 .flags          = FLAG_ADVANCED,
4417         },
4418         {
4419                 .label          = "winbind trusted domains only",
4420                 .type           = P_BOOL,
4421                 .p_class        = P_GLOBAL,
4422                 .ptr            = &Globals.bWinbindTrustedDomainsOnly,
4423                 .special        = NULL,
4424                 .enum_list      = NULL,
4425                 .flags          = FLAG_ADVANCED,
4426         },
4427         {
4428                 .label          = "winbind nested groups",
4429                 .type           = P_BOOL,
4430                 .p_class        = P_GLOBAL,
4431                 .ptr            = &Globals.bWinbindNestedGroups,
4432                 .special        = NULL,
4433                 .enum_list      = NULL,
4434                 .flags          = FLAG_ADVANCED,
4435         },
4436         {
4437                 .label          = "winbind expand groups",
4438                 .type           = P_INTEGER,
4439                 .p_class        = P_GLOBAL,
4440                 .ptr            = &Globals.winbind_expand_groups,
4441                 .special        = NULL,
4442                 .enum_list      = NULL,
4443                 .flags          = FLAG_ADVANCED,
4444         },
4445         {
4446                 .label          = "winbind nss info",
4447                 .type           = P_LIST,
4448                 .p_class        = P_GLOBAL,
4449                 .ptr            = &Globals.szWinbindNssInfo,
4450                 .special        = NULL,
4451                 .enum_list      = NULL,
4452                 .flags          = FLAG_ADVANCED,
4453         },
4454         {
4455                 .label          = "winbind refresh tickets",
4456                 .type           = P_BOOL,
4457                 .p_class        = P_GLOBAL,
4458                 .ptr            = &Globals.bWinbindRefreshTickets,
4459                 .special        = NULL,
4460                 .enum_list      = NULL,
4461                 .flags          = FLAG_ADVANCED,
4462         },
4463         {
4464                 .label          = "winbind offline logon",
4465                 .type           = P_BOOL,
4466                 .p_class        = P_GLOBAL,
4467                 .ptr            = &Globals.bWinbindOfflineLogon,
4468                 .special        = NULL,
4469                 .enum_list      = NULL,
4470                 .flags          = FLAG_ADVANCED,
4471         },
4472         {
4473                 .label          = "winbind normalize names",
4474                 .type           = P_BOOL,
4475                 .p_class        = P_GLOBAL,
4476                 .ptr            = &Globals.bWinbindNormalizeNames,
4477                 .special        = NULL,
4478                 .enum_list      = NULL,
4479                 .flags          = FLAG_ADVANCED,
4480         },
4481         {
4482                 .label          = "winbind rpc only",
4483                 .type           = P_BOOL,
4484                 .p_class        = P_GLOBAL,
4485                 .ptr            = &Globals.bWinbindRpcOnly,
4486                 .special        = NULL,
4487                 .enum_list      = NULL,
4488                 .flags          = FLAG_ADVANCED,
4489         },
4490
4491         {NULL,  P_BOOL,  P_NONE,  NULL,  NULL,  NULL,  0}
4492 };
4493
4494 /***************************************************************************
4495  Initialise the sDefault parameter structure for the printer values.
4496 ***************************************************************************/
4497
4498 static void init_printer_values(struct service *pService)
4499 {
4500         /* choose defaults depending on the type of printing */
4501         switch (pService->iPrinting) {
4502                 case PRINT_BSD:
4503                 case PRINT_AIX:
4504                 case PRINT_LPRNT:
4505                 case PRINT_LPROS2:
4506                         string_set(&pService->szLpqcommand, "lpq -P'%p'");
4507                         string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
4508                         string_set(&pService->szPrintcommand, "lpr -r -P'%p' %s");
4509                         break;
4510
4511                 case PRINT_LPRNG:
4512                 case PRINT_PLP:
4513                         string_set(&pService->szLpqcommand, "lpq -P'%p'");
4514                         string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
4515                         string_set(&pService->szPrintcommand, "lpr -r -P'%p' %s");
4516                         string_set(&pService->szQueuepausecommand, "lpc stop '%p'");
4517                         string_set(&pService->szQueueresumecommand, "lpc start '%p'");
4518                         string_set(&pService->szLppausecommand, "lpc hold '%p' %j");
4519                         string_set(&pService->szLpresumecommand, "lpc release '%p' %j");
4520                         break;
4521
4522                 case PRINT_CUPS:
4523                 case PRINT_IPRINT:
4524 #ifdef HAVE_CUPS
4525                         /* set the lpq command to contain the destination printer
4526                            name only.  This is used by cups_queue_get() */
4527                         string_set(&pService->szLpqcommand, "%p");
4528                         string_set(&pService->szLprmcommand, "");
4529                         string_set(&pService->szPrintcommand, "");
4530                         string_set(&pService->szLppausecommand, "");
4531                         string_set(&pService->szLpresumecommand, "");
4532                         string_set(&pService->szQueuepausecommand, "");
4533                         string_set(&pService->szQueueresumecommand, "");
4534 #else
4535                         string_set(&pService->szLpqcommand, "lpq -P'%p'");
4536                         string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
4537                         string_set(&pService->szPrintcommand, "lpr -P'%p' %s; rm %s");
4538                         string_set(&pService->szLppausecommand, "lp -i '%p-%j' -H hold");
4539                         string_set(&pService->szLpresumecommand, "lp -i '%p-%j' -H resume");
4540                         string_set(&pService->szQueuepausecommand, "disable '%p'");
4541                         string_set(&pService->szQueueresumecommand, "enable '%p'");
4542 #endif /* HAVE_CUPS */
4543                         break;
4544
4545                 case PRINT_SYSV:
4546                 case PRINT_HPUX:
4547                         string_set(&pService->szLpqcommand, "lpstat -o%p");
4548                         string_set(&pService->szLprmcommand, "cancel %p-%j");
4549                         string_set(&pService->szPrintcommand, "lp -c -d%p %s; rm %s");
4550                         string_set(&pService->szQueuepausecommand, "disable %p");
4551                         string_set(&pService->szQueueresumecommand, "enable %p");
4552 #ifndef HPUX
4553                         string_set(&pService->szLppausecommand, "lp -i %p-%j -H hold");
4554                         string_set(&pService->szLpresumecommand, "lp -i %p-%j -H resume");
4555 #endif /* HPUX */
4556                         break;
4557
4558                 case PRINT_QNX:
4559                         string_set(&pService->szLpqcommand, "lpq -P%p");
4560                         string_set(&pService->szLprmcommand, "lprm -P%p %j");
4561                         string_set(&pService->szPrintcommand, "lp -r -P%p %s");
4562                         break;
4563
4564 #ifdef DEVELOPER
4565         case PRINT_TEST:
4566         case PRINT_VLP:
4567                 string_set(&pService->szPrintcommand, "vlp print %p %s");
4568                 string_set(&pService->szLpqcommand, "vlp lpq %p");
4569                 string_set(&pService->szLprmcommand, "vlp lprm %p %j");
4570                 string_set(&pService->szLppausecommand, "vlp lppause %p %j");
4571                 string_set(&pService->szLpresumecommand, "vlp lpresume %p %j");
4572                 string_set(&pService->szQueuepausecommand, "vlp queuepause %p");
4573                 string_set(&pService->szQueueresumecommand, "vlp queueresume %p");
4574                 break;
4575 #endif /* DEVELOPER */
4576
4577         }
4578 }
4579
4580 /***************************************************************************
4581  Initialise the global parameter structure.
4582 ***************************************************************************/
4583
4584 static void init_globals(bool first_time_only)
4585 {
4586         static bool done_init = False;
4587         char *s = NULL;
4588         int i;
4589
4590         /* If requested to initialize only once and we've already done it... */
4591         if (first_time_only && done_init) {
4592                 /* ... then we have nothing more to do */
4593                 return;
4594         }
4595
4596         if (!done_init) {
4597                 /* The logfile can be set before this is invoked. Free it if so. */
4598                 if (Globals.szLogFile != NULL) {
4599                         string_free(&Globals.szLogFile);
4600                         Globals.szLogFile = NULL;
4601                 }
4602                 done_init = True;
4603         } else {
4604                 for (i = 0; parm_table[i].label; i++) {
4605                         if ((parm_table[i].type == P_STRING ||
4606                              parm_table[i].type == P_USTRING) &&
4607                             parm_table[i].ptr)
4608                         {
4609                                 string_free((char **)parm_table[i].ptr);
4610                         }
4611                 }
4612         }
4613
4614         memset((void *)&Globals, '\0', sizeof(Globals));
4615
4616         for (i = 0; parm_table[i].label; i++) {
4617                 if ((parm_table[i].type == P_STRING ||
4618                      parm_table[i].type == P_USTRING) &&
4619                     parm_table[i].ptr)
4620                 {
4621                         string_set((char **)parm_table[i].ptr, "");
4622                 }
4623         }
4624
4625         string_set(&sDefault.fstype, FSTYPE_STRING);
4626         string_set(&sDefault.szPrintjobUsername, "%U");
4627
4628         init_printer_values(&sDefault);
4629
4630
4631         DEBUG(3, ("Initialising global parameters\n"));
4632
4633         string_set(&Globals.szSMBPasswdFile, get_dyn_SMB_PASSWD_FILE());
4634         string_set(&Globals.szPrivateDir, get_dyn_PRIVATE_DIR());
4635
4636         /* use the new 'hash2' method by default, with a prefix of 1 */
4637         string_set(&Globals.szManglingMethod, "hash2");
4638         Globals.mangle_prefix = 1;
4639
4640         string_set(&Globals.szGuestaccount, GUEST_ACCOUNT);
4641
4642         /* using UTF8 by default allows us to support all chars */
4643         string_set(&Globals.unix_charset, DEFAULT_UNIX_CHARSET);
4644
4645 #if defined(HAVE_NL_LANGINFO) && defined(CODESET)
4646         /* If the system supports nl_langinfo(), try to grab the value
4647            from the user's locale */
4648         string_set(&Globals.display_charset, "LOCALE");
4649 #else
4650         string_set(&Globals.display_charset, DEFAULT_DISPLAY_CHARSET);
4651 #endif
4652
4653         /* Use codepage 850 as a default for the dos character set */
4654         string_set(&Globals.dos_charset, DEFAULT_DOS_CHARSET);
4655
4656         /*
4657          * Allow the default PASSWD_CHAT to be overridden in local.h.
4658          */
4659         string_set(&Globals.szPasswdChat, DEFAULT_PASSWD_CHAT);
4660
4661         set_global_myname(myhostname());
4662         string_set(&Globals.szNetbiosName,global_myname());
4663
4664         set_global_myworkgroup(WORKGROUP);
4665         string_set(&Globals.szWorkgroup, lp_workgroup());
4666
4667         string_set(&Globals.szPasswdProgram, "");
4668         string_set(&Globals.szPidDir, get_dyn_PIDDIR());
4669         string_set(&Globals.szLockDir, get_dyn_LOCKDIR());
4670         string_set(&Globals.szSocketAddress, "0.0.0.0");
4671
4672         if (asprintf(&s, "Samba %s", SAMBA_VERSION_STRING) < 0) {
4673                 smb_panic("init_globals: ENOMEM");
4674         }
4675         string_set(&Globals.szServerString, s);
4676         SAFE_FREE(s);
4677         if (asprintf(&s, "%d.%d", DEFAULT_MAJOR_VERSION,
4678                         DEFAULT_MINOR_VERSION) < 0) {
4679                 smb_panic("init_globals: ENOMEM");
4680         }
4681         string_set(&Globals.szAnnounceVersion, s);
4682         SAFE_FREE(s);
4683 #ifdef DEVELOPER
4684         string_set(&Globals.szPanicAction, "/bin/sleep 999999999");
4685 #endif
4686
4687         string_set(&Globals.szSocketOptions, DEFAULT_SOCKET_OPTIONS);
4688
4689         string_set(&Globals.szLogonDrive, "");
4690         /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
4691         string_set(&Globals.szLogonHome, "\\\\%N\\%U");
4692         string_set(&Globals.szLogonPath, "\\\\%N\\%U\\profile");
4693
4694         string_set(&Globals.szNameResolveOrder, "lmhosts wins host bcast");
4695         string_set(&Globals.szPasswordServer, "*");
4696
4697         Globals.AlgorithmicRidBase = BASE_RID;
4698
4699         Globals.bLoadPrinters = True;
4700         Globals.PrintcapCacheTime = 750;        /* 12.5 minutes */
4701
4702         Globals.ConfigBackend = config_backend;
4703
4704         /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
4705         /* Discovered by 2 days of pain by Don McCall @ HP :-). */
4706         Globals.max_xmit = 0x4104;
4707         Globals.max_mux = 50;   /* This is *needed* for profile support. */
4708         Globals.lpqcachetime = 30;      /* changed to handle large print servers better -- jerry */
4709         Globals.bDisableSpoolss = False;
4710         Globals.iMaxSmbdProcesses = 0;/* no limit specified */
4711         Globals.pwordlevel = 0;
4712         Globals.unamelevel = 0;
4713         Globals.deadtime = 0;
4714         Globals.getwd_cache = true;
4715         Globals.bLargeReadwrite = True;
4716         Globals.max_log_size = 5000;
4717         Globals.max_open_files = MAX_OPEN_FILES;
4718         Globals.open_files_db_hash_size = SMB_OPEN_DATABASE_TDB_HASH_SIZE;
4719         Globals.maxprotocol = PROTOCOL_NT1;
4720         Globals.minprotocol = PROTOCOL_CORE;
4721         Globals.security = SEC_USER;
4722         Globals.paranoid_server_security = True;
4723         Globals.bEncryptPasswords = True;
4724         Globals.bUpdateEncrypt = False;
4725         Globals.clientSchannel = Auto;
4726         Globals.serverSchannel = Auto;
4727         Globals.bReadRaw = True;
4728         Globals.bWriteRaw = True;
4729         Globals.bNullPasswords = False;
4730         Globals.bObeyPamRestrictions = False;
4731         Globals.syslog = 1;
4732         Globals.bSyslogOnly = False;
4733         Globals.bTimestampLogs = True;
4734         string_set(&Globals.szLogLevel, "0");
4735         Globals.bDebugPrefixTimestamp = False;
4736         Globals.bDebugHiresTimestamp = False;
4737         Globals.bDebugPid = False;
4738         Globals.bDebugUid = False;
4739         Globals.bDebugClass = False;
4740         Globals.bEnableCoreFiles = True;
4741         Globals.max_ttl = 60 * 60 * 24 * 3;     /* 3 days default. */
4742         Globals.max_wins_ttl = 60 * 60 * 24 * 6;        /* 6 days default. */
4743         Globals.min_wins_ttl = 60 * 60 * 6;     /* 6 hours default. */
4744         Globals.machine_password_timeout = 60 * 60 * 24 * 7;    /* 7 days default. */
4745         Globals.lm_announce = 2;        /* = Auto: send only if LM clients found */
4746         Globals.lm_interval = 60;
4747         Globals.announce_as = ANNOUNCE_AS_NT_SERVER;
4748 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
4749         Globals.bNISHomeMap = False;
4750 #ifdef WITH_NISPLUS_HOME
4751         string_set(&Globals.szNISHomeMapName, "auto_home.org_dir");
4752 #else
4753         string_set(&Globals.szNISHomeMapName, "auto.home");
4754 #endif
4755 #endif
4756         Globals.bTimeServer = False;
4757         Globals.bBindInterfacesOnly = False;
4758         Globals.bUnixPasswdSync = False;
4759         Globals.bPamPasswordChange = False;
4760         Globals.bPasswdChatDebug = False;
4761         Globals.iPasswdChatTimeout = 2; /* 2 second default. */
4762         Globals.bNTPipeSupport = True;  /* Do NT pipes by default. */
4763         Globals.bNTStatusSupport = True; /* Use NT status by default. */
4764         Globals.bStatCache = True;      /* use stat cache by default */
4765         Globals.iMaxStatCacheSize = 256; /* 256k by default */
4766         Globals.restrict_anonymous = 0;
4767         Globals.bClientLanManAuth = False;      /* Do NOT use the LanMan hash if it is available */
4768         Globals.bClientPlaintextAuth = False;   /* Do NOT use a plaintext password even if is requested by the server */
4769         Globals.bLanmanAuth = False;    /* Do NOT use the LanMan hash, even if it is supplied */
4770         Globals.bNTLMAuth = True;       /* Do use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
4771         Globals.bClientNTLMv2Auth = False; /* Client should not use NTLMv2, as we can't tell that the server supports it. */
4772         /* Note, that we will use NTLM2 session security (which is different), if it is available */
4773
4774         Globals.map_to_guest = 0;       /* By Default, "Never" */
4775         Globals.oplock_break_wait_time = 0;     /* By Default, 0 msecs. */
4776         Globals.enhanced_browsing = true;
4777         Globals.iLockSpinTime = WINDOWS_MINIMUM_LOCK_TIMEOUT_MS; /* msec. */
4778 #ifdef MMAP_BLACKLIST
4779         Globals.bUseMmap = False;
4780 #else
4781         Globals.bUseMmap = True;
4782 #endif
4783         Globals.bUnixExtensions = True;
4784         Globals.bResetOnZeroVC = False;
4785
4786         /* hostname lookups can be very expensive and are broken on
4787            a large number of sites (tridge) */
4788         Globals.bHostnameLookups = False;
4789
4790         string_set(&Globals.szPassdbBackend, "smbpasswd");
4791         string_set(&Globals.szLdapSuffix, "");
4792         string_set(&Globals.szLdapMachineSuffix, "");
4793         string_set(&Globals.szLdapUserSuffix, "");
4794         string_set(&Globals.szLdapGroupSuffix, "");
4795         string_set(&Globals.szLdapIdmapSuffix, "");
4796
4797         string_set(&Globals.szLdapAdminDn, "");
4798         Globals.ldap_ssl = LDAP_SSL_START_TLS;
4799         Globals.ldap_ssl_ads = False;
4800         Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
4801         Globals.ldap_delete_dn = False;
4802         Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
4803         Globals.ldap_timeout = LDAP_DEFAULT_TIMEOUT;
4804         Globals.ldap_connection_timeout = LDAP_CONNECTION_DEFAULT_TIMEOUT;
4805         Globals.ldap_page_size = LDAP_PAGE_SIZE;
4806
4807         Globals.ldap_debug_level = 0;
4808         Globals.ldap_debug_threshold = 10;
4809
4810         /* This is what we tell the afs client. in reality we set the token
4811          * to never expire, though, when this runs out the afs client will
4812          * forget the token. Set to 0 to get NEVERDATE.*/
4813         Globals.iAfsTokenLifetime = 604800;
4814         Globals.cups_connection_timeout = CUPS_DEFAULT_CONNECTION_TIMEOUT;
4815
4816 /* these parameters are set to defaults that are more appropriate
4817    for the increasing samba install base:
4818
4819    as a member of the workgroup, that will possibly become a
4820    _local_ master browser (lm = True).  this is opposed to a forced
4821    local master browser startup (pm = True).
4822
4823    doesn't provide WINS server service by default (wsupp = False),
4824    and doesn't provide domain master browser services by default, either.
4825
4826 */
4827
4828         Globals.bMsAddPrinterWizard = True;
4829         Globals.os_level = 20;
4830         Globals.bLocalMaster = True;
4831         Globals.iDomainMaster = Auto;   /* depending on bDomainLogons */
4832         Globals.bDomainLogons = False;
4833         Globals.bBrowseList = True;
4834         Globals.bWINSsupport = False;
4835         Globals.bWINSproxy = False;
4836
4837         TALLOC_FREE(Globals.szInitLogonDelayedHosts);
4838         Globals.InitLogonDelay = 100; /* 100 ms default delay */
4839
4840         Globals.bDNSproxy = True;
4841
4842         /* this just means to use them if they exist */
4843         Globals.bKernelOplocks = True;
4844
4845         Globals.bAllowTrustedDomains = True;
4846         string_set(&Globals.szIdmapBackend, "tdb");
4847
4848         string_set(&Globals.szTemplateShell, "/bin/false");
4849         string_set(&Globals.szTemplateHomedir, "/home/%D/%U");
4850         string_set(&Globals.szWinbindSeparator, "\\");
4851
4852         string_set(&Globals.szCupsServer, "");
4853         string_set(&Globals.szIPrintServer, "");
4854
4855         string_set(&Globals.ctdbdSocket, "");
4856         Globals.szClusterAddresses = NULL;
4857         Globals.clustering = False;
4858
4859         Globals.winbind_cache_time = 300;       /* 5 minutes */
4860         Globals.winbind_reconnect_delay = 30;   /* 30 seconds */
4861         Globals.bWinbindEnumUsers = False;
4862         Globals.bWinbindEnumGroups = False;
4863         Globals.bWinbindUseDefaultDomain = False;
4864         Globals.bWinbindTrustedDomainsOnly = False;
4865         Globals.bWinbindNestedGroups = True;
4866         Globals.winbind_expand_groups = 1;
4867         Globals.szWinbindNssInfo = str_list_make(talloc_autofree_context(), "template", NULL);
4868         Globals.bWinbindRefreshTickets = False;
4869         Globals.bWinbindOfflineLogon = False;
4870
4871         Globals.iIdmapCacheTime = 86400 * 7; /* a week by default */
4872         Globals.iIdmapNegativeCacheTime = 120; /* 2 minutes by default */
4873
4874         Globals.bPassdbExpandExplicit = False;
4875
4876         Globals.name_cache_timeout = 660; /* In seconds */
4877
4878         Globals.bUseSpnego = True;
4879         Globals.bClientUseSpnego = True;
4880
4881         Globals.client_signing = Auto;
4882         Globals.server_signing = False;
4883
4884         Globals.bDeferSharingViolations = True;
4885         string_set(&Globals.smb_ports, SMB_PORTS);
4886
4887         Globals.bEnablePrivileges = True;
4888         Globals.bHostMSDfs        = True;
4889         Globals.bASUSupport       = False;
4890
4891         /* User defined shares. */
4892         if (asprintf(&s, "%s/usershares", get_dyn_STATEDIR()) < 0) {
4893                 smb_panic("init_globals: ENOMEM");
4894         }
4895         string_set(&Globals.szUsersharePath, s);
4896         SAFE_FREE(s);
4897         string_set(&Globals.szUsershareTemplateShare, "");
4898         Globals.iUsershareMaxShares = 0;
4899         /* By default disallow sharing of directories not owned by the sharer. */
4900         Globals.bUsershareOwnerOnly = True;
4901         /* By default disallow guest access to usershares. */
4902         Globals.bUsershareAllowGuests = False;
4903
4904         Globals.iKeepalive = DEFAULT_KEEPALIVE;
4905
4906         /* By default no shares out of the registry */
4907         Globals.bRegistryShares = False;
4908
4909         Globals.iminreceivefile = 0;
4910 }
4911
4912 /*******************************************************************
4913  Convenience routine to grab string parameters into temporary memory
4914  and run standard_sub_basic on them. The buffers can be written to by
4915  callers without affecting the source string.
4916 ********************************************************************/
4917
4918 static char *lp_string(const char *s)
4919 {
4920         char *ret;
4921         TALLOC_CTX *ctx = talloc_tos();
4922
4923         /* The follow debug is useful for tracking down memory problems
4924            especially if you have an inner loop that is calling a lp_*()
4925            function that returns a string.  Perhaps this debug should be
4926            present all the time? */
4927
4928 #if 0
4929         DEBUG(10, ("lp_string(%s)\n", s));
4930 #endif
4931
4932         ret = talloc_sub_basic(ctx,
4933                         get_current_username(),
4934                         current_user_info.domain,
4935                         s);
4936         if (trim_char(ret, '\"', '\"')) {
4937                 if (strchr(ret,'\"') != NULL) {
4938                         TALLOC_FREE(ret);
4939                         ret = talloc_sub_basic(ctx,
4940                                         get_current_username(),
4941                                         current_user_info.domain,
4942                                         s);
4943                 }
4944         }
4945         return ret;
4946 }
4947
4948 /*
4949    In this section all the functions that are used to access the
4950    parameters from the rest of the program are defined
4951 */
4952
4953 #define FN_GLOBAL_STRING(fn_name,ptr) \
4954  char *fn_name(void) {return(lp_string(*(char **)(ptr) ? *(char **)(ptr) : ""));}
4955 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
4956  const char *fn_name(void) {return(*(const char **)(ptr) ? *(const char **)(ptr) : "");}
4957 #define FN_GLOBAL_LIST(fn_name,ptr) \
4958  const char **fn_name(void) {return(*(const char ***)(ptr));}
4959 #define FN_GLOBAL_BOOL(fn_name,ptr) \
4960  bool fn_name(void) {return(*(bool *)(ptr));}
4961 #define FN_GLOBAL_CHAR(fn_name,ptr) \
4962  char fn_name(void) {return(*(char *)(ptr));}
4963 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
4964  int fn_name(void) {return(*(int *)(ptr));}
4965
4966 #define FN_LOCAL_STRING(fn_name,val) \
4967  char *fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
4968 #define FN_LOCAL_CONST_STRING(fn_name,val) \
4969  const char *fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
4970 #define FN_LOCAL_LIST(fn_name,val) \
4971  const char **fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
4972 #define FN_LOCAL_BOOL(fn_name,val) \
4973  bool fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
4974 #define FN_LOCAL_INTEGER(fn_name,val) \
4975  int fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
4976
4977 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
4978  bool fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
4979 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
4980  int fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
4981 #define FN_LOCAL_PARM_STRING(fn_name,val) \
4982  char *fn_name(const struct share_params *p) {return(lp_string((LP_SNUM_OK(p->service) && ServicePtrs[(p->service)]->val) ? ServicePtrs[(p->service)]->val : sDefault.val));}
4983 #define FN_LOCAL_CHAR(fn_name,val) \
4984  char fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
4985
4986 FN_GLOBAL_STRING(lp_smb_ports, &Globals.smb_ports)
4987 FN_GLOBAL_STRING(lp_dos_charset, &Globals.dos_charset)
4988 FN_GLOBAL_STRING(lp_unix_charset, &Globals.unix_charset)
4989 FN_GLOBAL_STRING(lp_display_charset, &Globals.display_charset)
4990 FN_GLOBAL_STRING(lp_logfile, &Globals.szLogFile)
4991 FN_GLOBAL_STRING(lp_configfile, &Globals.szConfigFile)
4992 FN_GLOBAL_STRING(lp_smb_passwd_file, &Globals.szSMBPasswdFile)
4993 FN_GLOBAL_STRING(lp_private_dir, &Globals.szPrivateDir)
4994 FN_GLOBAL_STRING(lp_serverstring, &Globals.szServerString)
4995 FN_GLOBAL_INTEGER(lp_printcap_cache_time, &Globals.PrintcapCacheTime)
4996 FN_GLOBAL_STRING(lp_addport_cmd, &Globals.szAddPortCommand)
4997 FN_GLOBAL_STRING(lp_enumports_cmd, &Globals.szEnumPortsCommand)
4998 FN_GLOBAL_STRING(lp_addprinter_cmd, &Globals.szAddPrinterCommand)
4999 FN_GLOBAL_STRING(lp_deleteprinter_cmd, &Globals.szDeletePrinterCommand)
5000 FN_GLOBAL_STRING(lp_os2_driver_map, &Globals.szOs2DriverMap)
5001 FN_GLOBAL_STRING(lp_lockdir, &Globals.szLockDir)
5002 FN_GLOBAL_STRING(lp_piddir, &Globals.szPidDir)
5003 FN_GLOBAL_STRING(lp_mangling_method, &Globals.szManglingMethod)
5004 FN_GLOBAL_INTEGER(lp_mangle_prefix, &Globals.mangle_prefix)
5005 FN_GLOBAL_STRING(lp_utmpdir, &Globals.szUtmpDir)
5006 FN_GLOBAL_STRING(lp_wtmpdir, &Globals.szWtmpDir)
5007 FN_GLOBAL_BOOL(lp_utmp, &Globals.bUtmp)
5008 FN_GLOBAL_STRING(lp_rootdir, &Globals.szRootdir)
5009 FN_GLOBAL_STRING(lp_defaultservice, &Globals.szDefaultService)
5010 FN_GLOBAL_STRING(lp_msg_command, &Globals.szMsgCommand)
5011 FN_GLOBAL_STRING(lp_get_quota_command, &Globals.szGetQuota)
5012 FN_GLOBAL_STRING(lp_set_quota_command, &Globals.szSetQuota)
5013 FN_GLOBAL_STRING(lp_auto_services, &Globals.szAutoServices)
5014 FN_GLOBAL_STRING(lp_passwd_program, &Globals.szPasswdProgram)
5015 FN_GLOBAL_STRING(lp_passwd_chat, &Globals.szPasswdChat)
5016 FN_GLOBAL_STRING(lp_passwordserver, &Globals.szPasswordServer)
5017 FN_GLOBAL_STRING(lp_name_resolve_order, &Globals.szNameResolveOrder)
5018 FN_GLOBAL_STRING(lp_realm, &Globals.szRealm)
5019 FN_GLOBAL_CONST_STRING(lp_afs_username_map, &Globals.szAfsUsernameMap)
5020 FN_GLOBAL_INTEGER(lp_afs_token_lifetime, &Globals.iAfsTokenLifetime)
5021 FN_GLOBAL_STRING(lp_log_nt_token_command, &Globals.szLogNtTokenCommand)
5022 FN_GLOBAL_STRING(lp_username_map, &Globals.szUsernameMap)
5023 FN_GLOBAL_CONST_STRING(lp_logon_script, &Globals.szLogonScript)
5024 FN_GLOBAL_CONST_STRING(lp_logon_path, &Globals.szLogonPath)
5025 FN_GLOBAL_CONST_STRING(lp_logon_drive, &Globals.szLogonDrive)
5026 FN_GLOBAL_CONST_STRING(lp_logon_home, &Globals.szLogonHome)
5027 FN_GLOBAL_STRING(lp_remote_announce, &Globals.szRemoteAnnounce)
5028 FN_GLOBAL_STRING(lp_remote_browse_sync, &Globals.szRemoteBrowseSync)
5029 FN_GLOBAL_LIST(lp_wins_server_list, &Globals.szWINSservers)
5030 FN_GLOBAL_LIST(lp_interfaces, &Globals.szInterfaces)
5031 FN_GLOBAL_STRING(lp_nis_home_map_name, &Globals.szNISHomeMapName)
5032 static FN_GLOBAL_STRING(lp_announce_version, &Globals.szAnnounceVersion)
5033 FN_GLOBAL_LIST(lp_netbios_aliases, &Globals.szNetbiosAliases)
5034 /* FN_GLOBAL_STRING(lp_passdb_backend, &Globals.szPassdbBackend)
5035  * lp_passdb_backend() should be replace by the this macro again after
5036  * some releases.
5037  * */
5038 const char *lp_passdb_backend(void)
5039 {
5040         char *delim, *quote;
5041
5042         delim = strchr( Globals.szPassdbBackend, ' ');
5043         /* no space at all */
5044         if (delim == NULL) {
5045                 goto out;
5046         }
5047
5048         quote = strchr(Globals.szPassdbBackend, '"');
5049         /* no quote char or non in the first part */
5050         if (quote == NULL || quote > delim) {
5051                 *delim = '\0';
5052                 goto warn;
5053         }
5054
5055         quote = strchr(quote+1, '"');
5056         if (quote == NULL) {
5057                 DEBUG(0, ("WARNING: Your 'passdb backend' configuration is invalid due to a missing second \" char.\n"));
5058                 goto out;
5059         } else if (*(quote+1) == '\0') {
5060                 /* space, fitting quote char, and one backend only */
5061                 goto out;
5062         } else {
5063                 /* terminate string after the fitting quote char */
5064                 *(quote+1) = '\0';
5065         }
5066
5067 warn:
5068         DEBUG(0, ("WARNING: Your 'passdb backend' configuration includes multiple backends.  This\n"
5069                 "is deprecated since Samba 3.0.23.  Please check WHATSNEW.txt or the section 'Passdb\n"
5070                 "Changes' from the ChangeNotes as part of the Samba HOWTO collection.  Only the first\n"
5071                 "backend (%s) is used.  The rest is ignored.\n", Globals.szPassdbBackend));
5072
5073 out:
5074         return Globals.szPassdbBackend;
5075 }
5076 FN_GLOBAL_LIST(lp_preload_modules, &Globals.szPreloadModules)
5077 FN_GLOBAL_STRING(lp_panic_action, &Globals.szPanicAction)
5078 FN_GLOBAL_STRING(lp_adduser_script, &Globals.szAddUserScript)
5079 FN_GLOBAL_STRING(lp_renameuser_script, &Globals.szRenameUserScript)
5080 FN_GLOBAL_STRING(lp_deluser_script, &Globals.szDelUserScript)
5081
5082 FN_GLOBAL_CONST_STRING(lp_guestaccount, &Globals.szGuestaccount)
5083 FN_GLOBAL_STRING(lp_addgroup_script, &Globals.szAddGroupScript)
5084 FN_GLOBAL_STRING(lp_delgroup_script, &Globals.szDelGroupScript)
5085 FN_GLOBAL_STRING(lp_addusertogroup_script, &Globals.szAddUserToGroupScript)
5086 FN_GLOBAL_STRING(lp_deluserfromgroup_script, &Globals.szDelUserFromGroupScript)
5087 FN_GLOBAL_STRING(lp_setprimarygroup_script, &Globals.szSetPrimaryGroupScript)
5088
5089 FN_GLOBAL_STRING(lp_addmachine_script, &Globals.szAddMachineScript)
5090
5091 FN_GLOBAL_STRING(lp_shutdown_script, &Globals.szShutdownScript)
5092 FN_GLOBAL_STRING(lp_abort_shutdown_script, &Globals.szAbortShutdownScript)
5093 FN_GLOBAL_STRING(lp_username_map_script, &Globals.szUsernameMapScript)
5094
5095 FN_GLOBAL_STRING(lp_check_password_script, &Globals.szCheckPasswordScript)
5096
5097 FN_GLOBAL_STRING(lp_wins_hook, &Globals.szWINSHook)
5098 FN_GLOBAL_CONST_STRING(lp_template_homedir, &Globals.szTemplateHomedir)
5099 FN_GLOBAL_CONST_STRING(lp_template_shell, &Globals.szTemplateShell)
5100 FN_GLOBAL_CONST_STRING(lp_winbind_separator, &Globals.szWinbindSeparator)
5101 FN_GLOBAL_INTEGER(lp_acl_compatibility, &Globals.iAclCompat)
5102 FN_GLOBAL_BOOL(lp_winbind_enum_users, &Globals.bWinbindEnumUsers)
5103 FN_GLOBAL_BOOL(lp_winbind_enum_groups, &Globals.bWinbindEnumGroups)
5104 FN_GLOBAL_BOOL(lp_winbind_use_default_domain, &Globals.bWinbindUseDefaultDomain)
5105 FN_GLOBAL_BOOL(lp_winbind_trusted_domains_only, &Globals.bWinbindTrustedDomainsOnly)
5106 FN_GLOBAL_BOOL(lp_winbind_nested_groups, &Globals.bWinbindNestedGroups)
5107 FN_GLOBAL_INTEGER(lp_winbind_expand_groups, &Globals.winbind_expand_groups)
5108 FN_GLOBAL_BOOL(lp_winbind_refresh_tickets, &Globals.bWinbindRefreshTickets)
5109 FN_GLOBAL_BOOL(lp_winbind_offline_logon, &Globals.bWinbindOfflineLogon)
5110 FN_GLOBAL_BOOL(lp_winbind_normalize_names, &Globals.bWinbindNormalizeNames)
5111 FN_GLOBAL_BOOL(lp_winbind_rpc_only, &Globals.bWinbindRpcOnly)
5112
5113 FN_GLOBAL_CONST_STRING(lp_idmap_backend, &Globals.szIdmapBackend)
5114 FN_GLOBAL_STRING(lp_idmap_alloc_backend, &Globals.szIdmapAllocBackend)
5115 FN_GLOBAL_INTEGER(lp_idmap_cache_time, &Globals.iIdmapCacheTime)
5116 FN_GLOBAL_INTEGER(lp_idmap_negative_cache_time, &Globals.iIdmapNegativeCacheTime)
5117 FN_GLOBAL_INTEGER(lp_keepalive, &Globals.iKeepalive)
5118 FN_GLOBAL_BOOL(lp_passdb_expand_explicit, &Globals.bPassdbExpandExplicit)
5119
5120 FN_GLOBAL_STRING(lp_ldap_suffix, &Globals.szLdapSuffix)
5121 FN_GLOBAL_STRING(lp_ldap_admin_dn, &Globals.szLdapAdminDn)
5122 FN_GLOBAL_INTEGER(lp_ldap_ssl, &Globals.ldap_ssl)
5123 FN_GLOBAL_BOOL(lp_ldap_ssl_ads, &Globals.ldap_ssl_ads)
5124 FN_GLOBAL_INTEGER(lp_ldap_passwd_sync, &Globals.ldap_passwd_sync)
5125 FN_GLOBAL_BOOL(lp_ldap_delete_dn, &Globals.ldap_delete_dn)
5126 FN_GLOBAL_INTEGER(lp_ldap_replication_sleep, &Globals.ldap_replication_sleep)
5127 FN_GLOBAL_INTEGER(lp_ldap_timeout, &Globals.ldap_timeout)
5128 FN_GLOBAL_INTEGER(lp_ldap_connection_timeout, &Globals.ldap_connection_timeout)
5129 FN_GLOBAL_INTEGER(lp_ldap_page_size, &Globals.ldap_page_size)
5130 FN_GLOBAL_INTEGER(lp_ldap_debug_level, &Globals.ldap_debug_level)
5131 FN_GLOBAL_INTEGER(lp_ldap_debug_threshold, &Globals.ldap_debug_threshold)
5132 FN_GLOBAL_STRING(lp_add_share_cmd, &Globals.szAddShareCommand)
5133 FN_GLOBAL_STRING(lp_change_share_cmd, &Globals.szChangeShareCommand)
5134 FN_GLOBAL_STRING(lp_delete_share_cmd, &Globals.szDeleteShareCommand)
5135 FN_GLOBAL_STRING(lp_usershare_path, &Globals.szUsersharePath)
5136 FN_GLOBAL_LIST(lp_usershare_prefix_allow_list, &Globals.szUsersharePrefixAllowList)
5137 FN_GLOBAL_LIST(lp_usershare_prefix_deny_list, &Globals.szUsersharePrefixDenyList)
5138
5139 FN_GLOBAL_LIST(lp_eventlog_list, &Globals.szEventLogs)
5140
5141 FN_GLOBAL_BOOL(lp_registry_shares, &Globals.bRegistryShares)
5142 FN_GLOBAL_BOOL(lp_usershare_allow_guests, &Globals.bUsershareAllowGuests)
5143 FN_GLOBAL_BOOL(lp_usershare_owner_only, &Globals.bUsershareOwnerOnly)
5144 FN_GLOBAL_BOOL(lp_disable_netbios, &Globals.bDisableNetbios)
5145 FN_GLOBAL_BOOL(lp_reset_on_zero_vc, &Globals.bResetOnZeroVC)
5146 FN_GLOBAL_BOOL(lp_ms_add_printer_wizard, &Globals.bMsAddPrinterWizard)
5147 FN_GLOBAL_BOOL(lp_dns_proxy, &Globals.bDNSproxy)
5148 FN_GLOBAL_BOOL(lp_wins_support, &Globals.bWINSsupport)
5149 FN_GLOBAL_BOOL(lp_we_are_a_wins_server, &Globals.bWINSsupport)
5150 FN_GLOBAL_BOOL(lp_wins_proxy, &Globals.bWINSproxy)
5151 FN_GLOBAL_BOOL(lp_local_master, &Globals.bLocalMaster)
5152 FN_GLOBAL_BOOL(lp_domain_logons, &Globals.bDomainLogons)
5153 FN_GLOBAL_LIST(lp_init_logon_delayed_hosts, &Globals.szInitLogonDelayedHosts)
5154 FN_GLOBAL_INTEGER(lp_init_logon_delay, &Globals.InitLogonDelay)
5155 FN_GLOBAL_BOOL(lp_load_printers, &Globals.bLoadPrinters)
5156 FN_GLOBAL_BOOL(lp_readraw, &Globals.bReadRaw)
5157 FN_GLOBAL_BOOL(lp_large_readwrite, &Globals.bLargeReadwrite)
5158 FN_GLOBAL_BOOL(lp_writeraw, &Globals.bWriteRaw)
5159 FN_GLOBAL_BOOL(lp_null_passwords, &Globals.bNullPasswords)
5160 FN_GLOBAL_BOOL(lp_obey_pam_restrictions, &Globals.bObeyPamRestrictions)
5161 FN_GLOBAL_BOOL(lp_encrypted_passwords, &Globals.bEncryptPasswords)
5162 FN_GLOBAL_BOOL(lp_update_encrypted, &Globals.bUpdateEncrypt)
5163 FN_GLOBAL_INTEGER(lp_client_schannel, &Globals.clientSchannel)
5164 FN_GLOBAL_INTEGER(lp_server_schannel, &Globals.serverSchannel)
5165 FN_GLOBAL_BOOL(lp_syslog_only, &Globals.bSyslogOnly)
5166 FN_GLOBAL_BOOL(lp_timestamp_logs, &Globals.bTimestampLogs)
5167 FN_GLOBAL_BOOL(lp_debug_prefix_timestamp, &Globals.bDebugPrefixTimestamp)
5168 FN_GLOBAL_BOOL(lp_debug_hires_timestamp, &Globals.bDebugHiresTimestamp)
5169 FN_GLOBAL_BOOL(lp_debug_pid, &Globals.bDebugPid)
5170 FN_GLOBAL_BOOL(lp_debug_uid, &Globals.bDebugUid)
5171 FN_GLOBAL_BOOL(lp_debug_class, &Globals.bDebugClass)
5172 FN_GLOBAL_BOOL(lp_enable_core_files, &Globals.bEnableCoreFiles)
5173 FN_GLOBAL_BOOL(lp_browse_list, &Globals.bBrowseList)
5174 FN_GLOBAL_BOOL(lp_nis_home_map, &Globals.bNISHomeMap)
5175 static FN_GLOBAL_BOOL(lp_time_server, &Globals.bTimeServer)
5176 FN_GLOBAL_BOOL(lp_bind_interfaces_only, &Globals.bBindInterfacesOnly)
5177 FN_GLOBAL_BOOL(lp_pam_password_change, &Globals.bPamPasswordChange)
5178 FN_GLOBAL_BOOL(lp_unix_password_sync, &Globals.bUnixPasswdSync)
5179 FN_GLOBAL_BOOL(lp_passwd_chat_debug, &Globals.bPasswdChatDebug)
5180 FN_GLOBAL_INTEGER(lp_passwd_chat_timeout, &Globals.iPasswdChatTimeout)
5181 FN_GLOBAL_BOOL(lp_nt_pipe_support, &Globals.bNTPipeSupport)
5182 FN_GLOBAL_BOOL(lp_nt_status_support, &Globals.bNTStatusSupport)
5183 FN_GLOBAL_BOOL(lp_stat_cache, &Globals.bStatCache)
5184 FN_GLOBAL_INTEGER(lp_max_stat_cache_size, &Globals.iMaxStatCacheSize)
5185 FN_GLOBAL_BOOL(lp_allow_trusted_domains, &Globals.bAllowTrustedDomains)
5186 FN_GLOBAL_INTEGER(lp_restrict_anonymous, &Globals.restrict_anonymous)
5187 FN_GLOBAL_BOOL(lp_lanman_auth, &Globals.bLanmanAuth)
5188 FN_GLOBAL_BOOL(lp_ntlm_auth, &Globals.bNTLMAuth)
5189 FN_GLOBAL_BOOL(lp_client_plaintext_auth, &Globals.bClientPlaintextAuth)
5190 FN_GLOBAL_BOOL(lp_client_lanman_auth, &Globals.bClientLanManAuth)
5191 FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, &Globals.bClientNTLMv2Auth)
5192 FN_GLOBAL_BOOL(lp_host_msdfs, &Globals.bHostMSDfs)
5193 FN_GLOBAL_BOOL(lp_kernel_oplocks, &Globals.bKernelOplocks)
5194 FN_GLOBAL_BOOL(lp_enhanced_browsing, &Globals.enhanced_browsing)
5195 FN_GLOBAL_BOOL(lp_use_mmap, &Globals.bUseMmap)
5196 FN_GLOBAL_BOOL(lp_unix_extensions, &Globals.bUnixExtensions)
5197 FN_GLOBAL_BOOL(lp_use_spnego, &Globals.bUseSpnego)
5198 FN_GLOBAL_BOOL(lp_client_use_spnego, &Globals.bClientUseSpnego)
5199 FN_GLOBAL_BOOL(lp_hostname_lookups, &Globals.bHostnameLookups)
5200 FN_LOCAL_PARM_BOOL(lp_change_notify, bChangeNotify)
5201 FN_LOCAL_PARM_BOOL(lp_kernel_change_notify, bKernelChangeNotify)
5202 FN_GLOBAL_BOOL(lp_use_kerberos_keytab, &Globals.bUseKerberosKeytab)
5203 FN_GLOBAL_BOOL(lp_defer_sharing_violations, &Globals.bDeferSharingViolations)
5204 FN_GLOBAL_BOOL(lp_enable_privileges, &Globals.bEnablePrivileges)
5205 FN_GLOBAL_BOOL(lp_enable_asu_support, &Globals.bASUSupport)
5206 FN_GLOBAL_INTEGER(lp_os_level, &Globals.os_level)
5207 FN_GLOBAL_INTEGER(lp_max_ttl, &Globals.max_ttl)
5208 FN_GLOBAL_INTEGER(lp_max_wins_ttl, &Globals.max_wins_ttl)
5209 FN_GLOBAL_INTEGER(lp_min_wins_ttl, &Globals.min_wins_ttl)
5210 FN_GLOBAL_INTEGER(lp_max_log_size, &Globals.max_log_size)
5211 FN_GLOBAL_INTEGER(lp_max_open_files, &Globals.max_open_files)
5212 FN_GLOBAL_INTEGER(lp_open_files_db_hash_size, &Globals.open_files_db_hash_size)
5213 FN_GLOBAL_INTEGER(lp_maxxmit, &Globals.max_xmit)
5214 FN_GLOBAL_INTEGER(lp_maxmux, &Globals.max_mux)
5215 FN_GLOBAL_INTEGER(lp_passwordlevel, &Globals.pwordlevel)
5216 FN_GLOBAL_INTEGER(lp_usernamelevel, &Globals.unamelevel)
5217 FN_GLOBAL_INTEGER(lp_deadtime, &Globals.deadtime)
5218 FN_GLOBAL_BOOL(lp_getwd_cache, &Globals.getwd_cache)
5219 FN_GLOBAL_INTEGER(lp_maxprotocol, &Globals.maxprotocol)
5220 FN_GLOBAL_INTEGER(lp_minprotocol, &Globals.minprotocol)
5221 FN_GLOBAL_INTEGER(lp_security, &Globals.security)
5222 FN_GLOBAL_LIST(lp_auth_methods, &Globals.AuthMethods)
5223 FN_GLOBAL_BOOL(lp_paranoid_server_security, &Globals.paranoid_server_security)
5224 FN_GLOBAL_INTEGER(lp_maxdisksize, &Globals.maxdisksize)
5225 FN_GLOBAL_INTEGER(lp_lpqcachetime, &Globals.lpqcachetime)
5226 FN_GLOBAL_INTEGER(lp_max_smbd_processes, &Globals.iMaxSmbdProcesses)
5227 FN_GLOBAL_BOOL(_lp_disable_spoolss, &Globals.bDisableSpoolss)
5228 FN_GLOBAL_INTEGER(lp_syslog, &Globals.syslog)
5229 static FN_GLOBAL_INTEGER(lp_announce_as, &Globals.announce_as)
5230 FN_GLOBAL_INTEGER(lp_lm_announce, &Globals.lm_announce)
5231 FN_GLOBAL_INTEGER(lp_lm_interval, &Globals.lm_interval)
5232 FN_GLOBAL_INTEGER(lp_machine_password_timeout, &Globals.machine_password_timeout)
5233 FN_GLOBAL_INTEGER(lp_map_to_guest, &Globals.map_to_guest)
5234 FN_GLOBAL_INTEGER(lp_oplock_break_wait_time, &Globals.oplock_break_wait_time)
5235 FN_GLOBAL_INTEGER(lp_lock_spin_time, &Globals.iLockSpinTime)
5236 FN_GLOBAL_INTEGER(lp_usershare_max_shares, &Globals.iUsershareMaxShares)
5237 FN_GLOBAL_CONST_STRING(lp_socket_options, &Globals.szSocketOptions)
5238 FN_GLOBAL_INTEGER(lp_config_backend, &Globals.ConfigBackend)
5239
5240 FN_LOCAL_STRING(lp_preexec, szPreExec)
5241 FN_LOCAL_STRING(lp_postexec, szPostExec)
5242 FN_LOCAL_STRING(lp_rootpreexec, szRootPreExec)
5243 FN_LOCAL_STRING(lp_rootpostexec, szRootPostExec)
5244 FN_LOCAL_STRING(lp_servicename, szService)
5245 FN_LOCAL_CONST_STRING(lp_const_servicename, szService)
5246 FN_LOCAL_STRING(lp_pathname, szPath)
5247 FN_LOCAL_STRING(lp_dontdescend, szDontdescend)
5248 FN_LOCAL_STRING(lp_username, szUsername)
5249 FN_LOCAL_LIST(lp_invalid_users, szInvalidUsers)
5250 FN_LOCAL_LIST(lp_valid_users, szValidUsers)
5251 FN_LOCAL_LIST(lp_admin_users, szAdminUsers)
5252 FN_GLOBAL_LIST(lp_svcctl_list, &Globals.szServicesList)
5253 FN_LOCAL_STRING(lp_cups_options, szCupsOptions)
5254 FN_GLOBAL_STRING(lp_cups_server, &Globals.szCupsServer)
5255 FN_GLOBAL_STRING(lp_iprint_server, &Globals.szIPrintServer)
5256 FN_GLOBAL_INTEGER(lp_cups_connection_timeout, &Globals.cups_connection_timeout)
5257 FN_GLOBAL_CONST_STRING(lp_ctdbd_socket, &Globals.ctdbdSocket)
5258 FN_GLOBAL_LIST(lp_cluster_addresses, &Globals.szClusterAddresses)
5259 FN_GLOBAL_BOOL(lp_clustering, &Globals.clustering)
5260 FN_LOCAL_STRING(lp_printcommand, szPrintcommand)
5261 FN_LOCAL_STRING(lp_lpqcommand, szLpqcommand)
5262 FN_LOCAL_STRING(lp_lprmcommand, szLprmcommand)
5263 FN_LOCAL_STRING(lp_lppausecommand, szLppausecommand)
5264 FN_LOCAL_STRING(lp_lpresumecommand, szLpresumecommand)
5265 FN_LOCAL_STRING(lp_queuepausecommand, szQueuepausecommand)
5266 FN_LOCAL_STRING(lp_queueresumecommand, szQueueresumecommand)
5267 static FN_LOCAL_STRING(_lp_printername, szPrintername)
5268 FN_LOCAL_CONST_STRING(lp_printjob_username, szPrintjobUsername)
5269 FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
5270 FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
5271 FN_LOCAL_STRING(lp_magicscript, szMagicScript)
5272 FN_LOCAL_STRING(lp_magicoutput, szMagicOutput)
5273 FN_LOCAL_STRING(lp_comment, comment)
5274 FN_LOCAL_STRING(lp_force_user, force_user)
5275 FN_LOCAL_STRING(lp_force_group, force_group)
5276 FN_LOCAL_LIST(lp_readlist, readlist)
5277 FN_LOCAL_LIST(lp_writelist, writelist)
5278 FN_LOCAL_LIST(lp_printer_admin, printer_admin)
5279 FN_LOCAL_STRING(lp_fstype, fstype)
5280 FN_LOCAL_LIST(lp_vfs_objects, szVfsObjects)
5281 FN_LOCAL_STRING(lp_msdfs_proxy, szMSDfsProxy)
5282 static FN_LOCAL_STRING(lp_volume, volume)
5283 FN_LOCAL_STRING(lp_veto_files, szVetoFiles)
5284 FN_LOCAL_STRING(lp_hide_files, szHideFiles)
5285 FN_LOCAL_STRING(lp_veto_oplocks, szVetoOplockFiles)
5286 FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
5287 FN_LOCAL_STRING(lp_aio_write_behind, szAioWriteBehind)
5288 FN_LOCAL_STRING(lp_dfree_command, szDfree)
5289 FN_LOCAL_BOOL(lp_autoloaded, autoloaded)
5290 FN_LOCAL_BOOL(lp_preexec_close, bPreexecClose)
5291 FN_LOCAL_BOOL(lp_rootpreexec_close, bRootpreexecClose)
5292 FN_LOCAL_INTEGER(lp_casesensitive, iCaseSensitive)
5293 FN_LOCAL_BOOL(lp_preservecase, bCasePreserve)
5294 FN_LOCAL_BOOL(lp_shortpreservecase, bShortCasePreserve)
5295 FN_LOCAL_BOOL(lp_hide_dot_files, bHideDotFiles)
5296 FN_LOCAL_BOOL(lp_hide_special_files, bHideSpecialFiles)
5297 FN_LOCAL_BOOL(lp_hideunreadable, bHideUnReadable)
5298 FN_LOCAL_BOOL(lp_hideunwriteable_files, bHideUnWriteableFiles)
5299 FN_LOCAL_BOOL(lp_browseable, bBrowseable)
5300 FN_LOCAL_BOOL(lp_readonly, bRead_only)
5301 FN_LOCAL_BOOL(lp_no_set_dir, bNo_set_dir)
5302 FN_LOCAL_BOOL(lp_guest_ok, bGuest_ok)
5303 FN_LOCAL_BOOL(lp_guest_only, bGuest_only)
5304 FN_LOCAL_BOOL(lp_administrative_share, bAdministrative_share)
5305 FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
5306 FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
5307 FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
5308 FN_LOCAL_BOOL(lp_store_dos_attributes, bStoreDosAttributes)
5309 FN_LOCAL_BOOL(lp_dmapi_support, bDmapiSupport)
5310 FN_LOCAL_PARM_BOOL(lp_locking, bLocking)
5311 FN_LOCAL_PARM_INTEGER(lp_strict_locking, iStrictLocking)
5312 FN_LOCAL_PARM_BOOL(lp_posix_locking, bPosixLocking)
5313 FN_LOCAL_BOOL(lp_share_modes, bShareModes)
5314 FN_LOCAL_BOOL(lp_oplocks, bOpLocks)
5315 FN_LOCAL_BOOL(lp_level2_oplocks, bLevel2OpLocks)
5316 FN_LOCAL_BOOL(lp_onlyuser, bOnlyUser)
5317 FN_LOCAL_PARM_BOOL(lp_manglednames, bMangledNames)
5318 FN_LOCAL_BOOL(lp_widelinks, bWidelinks)
5319 FN_LOCAL_BOOL(lp_symlinks, bSymlinks)
5320 FN_LOCAL_BOOL(lp_syncalways, bSyncAlways)
5321 FN_LOCAL_BOOL(lp_strict_allocate, bStrictAllocate)
5322 FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
5323 FN_LOCAL_BOOL(lp_map_system, bMap_system)
5324 FN_LOCAL_BOOL(lp_delete_readonly, bDeleteReadonly)
5325 FN_LOCAL_BOOL(lp_fake_oplocks, bFakeOplocks)
5326 FN_LOCAL_BOOL(lp_recursive_veto_delete, bDeleteVetoFiles)
5327 FN_LOCAL_BOOL(lp_dos_filemode, bDosFilemode)
5328 FN_LOCAL_BOOL(lp_dos_filetimes, bDosFiletimes)
5329 FN_LOCAL_BOOL(lp_dos_filetime_resolution, bDosFiletimeResolution)
5330 FN_LOCAL_BOOL(lp_fake_dir_create_times, bFakeDirCreateTimes)
5331 FN_LOCAL_BOOL(lp_blocking_locks, bBlockingLocks)
5332 FN_LOCAL_BOOL(lp_inherit_perms, bInheritPerms)
5333 FN_LOCAL_BOOL(lp_inherit_acls, bInheritACLS)
5334 FN_LOCAL_BOOL(lp_inherit_owner, bInheritOwner)
5335 FN_LOCAL_BOOL(lp_use_client_driver, bUseClientDriver)
5336 FN_LOCAL_BOOL(lp_default_devmode, bDefaultDevmode)
5337 FN_LOCAL_BOOL(lp_force_printername, bForcePrintername)
5338 FN_LOCAL_BOOL(lp_nt_acl_support, bNTAclSupport)
5339 FN_LOCAL_BOOL(lp_force_unknown_acl_user, bForceUnknownAclUser)
5340 FN_LOCAL_BOOL(lp_ea_support, bEASupport)
5341 FN_LOCAL_BOOL(_lp_use_sendfile, bUseSendfile)
5342 FN_LOCAL_BOOL(lp_profile_acls, bProfileAcls)
5343 FN_LOCAL_BOOL(lp_map_acl_inherit, bMap_acl_inherit)
5344 FN_LOCAL_BOOL(lp_afs_share, bAfs_Share)
5345 FN_LOCAL_BOOL(lp_acl_check_permissions, bAclCheckPermissions)
5346 FN_LOCAL_BOOL(lp_acl_group_control, bAclGroupControl)
5347 FN_LOCAL_BOOL(lp_acl_map_full_control, bAclMapFullControl)
5348 FN_LOCAL_INTEGER(lp_create_mask, iCreate_mask)
5349 FN_LOCAL_INTEGER(lp_force_create_mode, iCreate_force_mode)
5350 FN_LOCAL_INTEGER(lp_security_mask, iSecurity_mask)
5351 FN_LOCAL_INTEGER(lp_force_security_mode, iSecurity_force_mode)
5352 FN_LOCAL_INTEGER(lp_dir_mask, iDir_mask)
5353 FN_LOCAL_INTEGER(lp_force_dir_mode, iDir_force_mode)
5354 FN_LOCAL_INTEGER(lp_dir_security_mask, iDir_Security_mask)
5355 FN_LOCAL_INTEGER(lp_force_dir_security_mode, iDir_Security_force_mode)
5356 FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
5357 FN_LOCAL_INTEGER(lp_defaultcase, iDefaultCase)
5358 FN_LOCAL_INTEGER(lp_minprintspace, iMinPrintSpace)
5359 FN_LOCAL_INTEGER(lp_printing, iPrinting)
5360 FN_LOCAL_INTEGER(lp_max_reported_jobs, iMaxReportedPrintJobs)
5361 FN_LOCAL_INTEGER(lp_oplock_contention_limit, iOplockContentionLimit)
5362 FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
5363 FN_LOCAL_INTEGER(lp_write_cache_size, iWriteCacheSize)
5364 FN_LOCAL_INTEGER(lp_block_size, iBlock_size)
5365 FN_LOCAL_INTEGER(lp_dfree_cache_time, iDfreeCacheTime)
5366 FN_LOCAL_INTEGER(lp_allocation_roundup_size, iallocation_roundup_size)
5367 FN_LOCAL_INTEGER(lp_aio_read_size, iAioReadSize)
5368 FN_LOCAL_INTEGER(lp_aio_write_size, iAioWriteSize)
5369 FN_LOCAL_INTEGER(lp_map_readonly, iMap_readonly)
5370 FN_LOCAL_INTEGER(lp_directory_name_cache_size, iDirectoryNameCacheSize)
5371 FN_LOCAL_INTEGER(lp_smb_encrypt, ismb_encrypt)
5372 FN_LOCAL_CHAR(lp_magicchar, magic_char)
5373 FN_GLOBAL_INTEGER(lp_winbind_cache_time, &Globals.winbind_cache_time)
5374 FN_GLOBAL_INTEGER(lp_winbind_reconnect_delay, &Globals.winbind_reconnect_delay)
5375 FN_GLOBAL_LIST(lp_winbind_nss_info, &Globals.szWinbindNssInfo)
5376 FN_GLOBAL_INTEGER(lp_algorithmic_rid_base, &Globals.AlgorithmicRidBase)
5377 FN_GLOBAL_INTEGER(lp_name_cache_timeout, &Globals.name_cache_timeout)
5378 FN_GLOBAL_INTEGER(lp_client_signing, &Globals.client_signing)
5379 FN_GLOBAL_INTEGER(lp_server_signing, &Globals.server_signing)
5380 FN_GLOBAL_INTEGER(lp_client_ldap_sasl_wrapping, &Globals.client_ldap_sasl_wrapping)
5381
5382 /* local prototypes */
5383
5384 static int map_parameter(const char *pszParmName);
5385 static int map_parameter_canonical(const char *pszParmName, bool *inverse);
5386 static bool set_boolean(bool *pb, const char *pszParmValue);
5387 static const char *get_boolean(bool bool_value);
5388 static int getservicebyname(const char *pszServiceName,
5389                             struct service *pserviceDest);
5390 static void copy_service(struct service *pserviceDest,
5391                          struct service *pserviceSource,
5392                          struct bitmap *pcopymapDest);
5393 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
5394                          void *userdata);
5395 static bool do_section(const char *pszSectionName, void *userdata);
5396 static void init_copymap(struct service *pservice);
5397 static bool hash_a_service(const char *name, int number);
5398 static void free_service_byindex(int iService);
5399 static char * canonicalize_servicename(const char *name);
5400 static void show_parameter(int parmIndex);
5401 static bool is_synonym_of(int parm1, int parm2, bool *inverse);
5402
5403 /*
5404  * This is a helper function for parametrical options support.  It returns a
5405  * pointer to parametrical option value if it exists or NULL otherwise. Actual
5406  * parametrical functions are quite simple
5407  */
5408 static struct param_opt_struct *get_parametrics(int snum, const char *type,
5409                                                 const char *option)
5410 {
5411         bool global_section = False;
5412         char* param_key;
5413         struct param_opt_struct *data;
5414
5415         if (snum >= iNumServices) return NULL;
5416
5417         if (snum < 0) {
5418                 data = Globals.param_opt;
5419                 global_section = True;
5420         } else {
5421                 data = ServicePtrs[snum]->param_opt;
5422         }
5423
5424         if (asprintf(&param_key, "%s:%s", type, option) == -1) {
5425                 DEBUG(0,("asprintf failed!\n"));
5426                 return NULL;
5427         }
5428
5429         while (data) {
5430                 if (strwicmp(data->key, param_key) == 0) {
5431                         string_free(&param_key);
5432                         return data;
5433                 }
5434                 data = data->next;
5435         }
5436
5437         if (!global_section) {
5438                 /* Try to fetch the same option but from globals */
5439                 /* but only if we are not already working with Globals */
5440                 data = Globals.param_opt;
5441                 while (data) {
5442                         if (strwicmp(data->key, param_key) == 0) {
5443                                 string_free(&param_key);
5444                                 return data;
5445                         }
5446                         data = data->next;
5447                 }
5448         }
5449
5450         string_free(&param_key);
5451
5452         return NULL;
5453 }
5454
5455
5456 #define MISSING_PARAMETER(name) \
5457     DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
5458
5459 /*******************************************************************
5460 convenience routine to return int parameters.
5461 ********************************************************************/
5462 static int lp_int(const char *s)
5463 {
5464
5465         if (!s || !*s) {
5466                 MISSING_PARAMETER(lp_int);
5467                 return (-1);
5468         }
5469
5470         return (int)strtol(s, NULL, 0);
5471 }
5472
5473 /*******************************************************************
5474 convenience routine to return unsigned long parameters.
5475 ********************************************************************/
5476 static unsigned long lp_ulong(const char *s)
5477 {
5478
5479         if (!s || !*s) {
5480                 MISSING_PARAMETER(lp_ulong);
5481                 return (0);
5482         }
5483
5484         return strtoul(s, NULL, 0);
5485 }
5486
5487 /*******************************************************************
5488 convenience routine to return boolean parameters.
5489 ********************************************************************/
5490 static bool lp_bool(const char *s)
5491 {
5492         bool ret = False;
5493
5494         if (!s || !*s) {
5495                 MISSING_PARAMETER(lp_bool);
5496                 return False;
5497         }
5498
5499         if (!set_boolean(&ret,s)) {
5500                 DEBUG(0,("lp_bool(%s): value is not boolean!\n",s));
5501                 return False;
5502         }
5503
5504         return ret;
5505 }
5506
5507 /*******************************************************************
5508 convenience routine to return enum parameters.
5509 ********************************************************************/
5510 static int lp_enum(const char *s,const struct enum_list *_enum)
5511 {
5512         int i;
5513
5514         if (!s || !*s || !_enum) {
5515                 MISSING_PARAMETER(lp_enum);
5516                 return (-1);
5517         }
5518
5519         for (i=0; _enum[i].name; i++) {
5520                 if (strequal(_enum[i].name,s))
5521                         return _enum[i].value;
5522         }
5523
5524         DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
5525         return (-1);
5526 }
5527
5528 #undef MISSING_PARAMETER
5529
5530 /* DO NOT USE lp_parm_string ANYMORE!!!!
5531  * use lp_parm_const_string or lp_parm_talloc_string
5532  *
5533  * lp_parm_string is only used to let old modules find this symbol
5534  */
5535 #undef lp_parm_string
5536  char *lp_parm_string(const char *servicename, const char *type, const char *option);
5537  char *lp_parm_string(const char *servicename, const char *type, const char *option)
5538 {
5539         return lp_parm_talloc_string(lp_servicenumber(servicename), type, option, NULL);
5540 }
5541
5542 /* Return parametric option from a given service. Type is a part of option before ':' */
5543 /* Parametric option has following syntax: 'Type: option = value' */
5544 /* the returned value is talloced on the talloc_tos() */
5545 char *lp_parm_talloc_string(int snum, const char *type, const char *option, const char *def)
5546 {
5547         struct param_opt_struct *data = get_parametrics(snum, type, option);
5548
5549         if (data == NULL||data->value==NULL) {
5550                 if (def) {
5551                         return lp_string(def);
5552                 } else {
5553                         return NULL;
5554                 }
5555         }
5556
5557         return lp_string(data->value);
5558 }
5559
5560 /* Return parametric option from a given service. Type is a part of option before ':' */
5561 /* Parametric option has following syntax: 'Type: option = value' */
5562 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
5563 {
5564         struct param_opt_struct *data = get_parametrics(snum, type, option);
5565
5566         if (data == NULL||data->value==NULL)
5567                 return def;
5568
5569         return data->value;
5570 }
5571
5572 /* Return parametric option from a given service. Type is a part of option before ':' */
5573 /* Parametric option has following syntax: 'Type: option = value' */
5574
5575 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
5576 {
5577         struct param_opt_struct *data = get_parametrics(snum, type, option);
5578
5579         if (data == NULL||data->value==NULL)
5580                 return (const char **)def;
5581
5582         if (data->list==NULL) {
5583                 data->list = str_list_make(talloc_autofree_context(), data->value, NULL);
5584         }
5585
5586         return (const char **)data->list;
5587 }
5588
5589 /* Return parametric option from a given service. Type is a part of option before ':' */
5590 /* Parametric option has following syntax: 'Type: option = value' */
5591
5592 int lp_parm_int(int snum, const char *type, const char *option, int def)
5593 {
5594         struct param_opt_struct *data = get_parametrics(snum, type, option);
5595
5596         if (data && data->value && *data->value)
5597                 return lp_int(data->value);
5598
5599         return def;
5600 }
5601
5602 /* Return parametric option from a given service. Type is a part of option before ':' */
5603 /* Parametric option has following syntax: 'Type: option = value' */
5604
5605 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
5606 {
5607         struct param_opt_struct *data = get_parametrics(snum, type, option);
5608
5609         if (data && data->value && *data->value)
5610                 return lp_ulong(data->value);
5611
5612         return def;
5613 }
5614
5615 /* Return parametric option from a given service. Type is a part of option before ':' */
5616 /* Parametric option has following syntax: 'Type: option = value' */
5617
5618 bool lp_parm_bool(int snum, const char *type, const char *option, bool def)
5619 {
5620         struct param_opt_struct *data = get_parametrics(snum, type, option);
5621
5622         if (data && data->value && *data->value)
5623                 return lp_bool(data->value);
5624
5625         return def;
5626 }
5627
5628 /* Return parametric option from a given service. Type is a part of option before ':' */
5629 /* Parametric option has following syntax: 'Type: option = value' */
5630
5631 int lp_parm_enum(int snum, const char *type, const char *option,
5632                  const struct enum_list *_enum, int def)
5633 {
5634         struct param_opt_struct *data = get_parametrics(snum, type, option);
5635
5636         if (data && data->value && *data->value && _enum)
5637                 return lp_enum(data->value, _enum);
5638
5639         return def;
5640 }
5641
5642
5643 /***************************************************************************
5644  Initialise a service to the defaults.
5645 ***************************************************************************/
5646
5647 static void init_service(struct service *pservice)
5648 {
5649         memset((char *)pservice, '\0', sizeof(struct service));
5650         copy_service(pservice, &sDefault, NULL);
5651 }
5652
5653 /***************************************************************************
5654  Free the dynamically allocated parts of a service struct.
5655 ***************************************************************************/
5656
5657 static void free_service(struct service *pservice)
5658 {
5659         int i;
5660         struct param_opt_struct *data, *pdata;
5661         if (!pservice)
5662                 return;
5663
5664         if (pservice->szService)
5665                 DEBUG(5, ("free_service: Freeing service %s\n",
5666                        pservice->szService));
5667
5668         string_free(&pservice->szService);
5669         bitmap_free(pservice->copymap);
5670
5671         for (i = 0; parm_table[i].label; i++) {
5672                 if ((parm_table[i].type == P_STRING ||
5673                      parm_table[i].type == P_USTRING) &&
5674                     parm_table[i].p_class == P_LOCAL)
5675                         string_free((char **)
5676                                     (((char *)pservice) +
5677                                      PTR_DIFF(parm_table[i].ptr, &sDefault)));
5678                 else if (parm_table[i].type == P_LIST &&
5679                          parm_table[i].p_class == P_LOCAL)
5680                              TALLOC_FREE(*((char ***)
5681                                            (((char *)pservice) +
5682                                             PTR_DIFF(parm_table[i].ptr,
5683                                                      &sDefault))));
5684         }
5685
5686         data = pservice->param_opt;
5687         if (data)
5688                 DEBUG(5,("Freeing parametrics:\n"));
5689         while (data) {
5690                 DEBUG(5,("[%s = %s]\n", data->key, data->value));
5691                 string_free(&data->key);
5692                 string_free(&data->value);
5693                 TALLOC_FREE(data->list);
5694                 pdata = data->next;
5695                 SAFE_FREE(data);
5696                 data = pdata;
5697         }
5698
5699         ZERO_STRUCTP(pservice);
5700 }
5701
5702
5703 /***************************************************************************
5704  remove a service indexed in the ServicePtrs array from the ServiceHash
5705  and free the dynamically allocated parts
5706 ***************************************************************************/
5707
5708 static void free_service_byindex(int idx)
5709 {
5710         if ( !LP_SNUM_OK(idx) )
5711                 return;
5712
5713         ServicePtrs[idx]->valid = False;
5714         invalid_services[num_invalid_services++] = idx;
5715
5716         /* we have to cleanup the hash record */
5717
5718         if (ServicePtrs[idx]->szService) {
5719                 char *canon_name = canonicalize_servicename(
5720                         ServicePtrs[idx]->szService );
5721
5722                 dbwrap_delete_bystring(ServiceHash, canon_name );
5723                 TALLOC_FREE(canon_name);
5724         }
5725
5726         free_service(ServicePtrs[idx]);
5727 }
5728
5729 /***************************************************************************
5730  Add a new service to the services array initialising it with the given
5731  service.
5732 ***************************************************************************/
5733
5734 static int add_a_service(const struct service *pservice, const char *name)
5735 {
5736         int i;
5737         struct service tservice;
5738         int num_to_alloc = iNumServices + 1;
5739         struct param_opt_struct *data, *pdata;
5740
5741         tservice = *pservice;
5742
5743         /* it might already exist */
5744         if (name) {
5745                 i = getservicebyname(name, NULL);
5746                 if (i >= 0) {
5747                         /* Clean all parametric options for service */
5748                         /* They will be added during parsing again */
5749                         data = ServicePtrs[i]->param_opt;
5750                         while (data) {
5751                                 string_free(&data->key);
5752                                 string_free(&data->value);
5753                                 TALLOC_FREE(data->list);
5754                                 pdata = data->next;
5755                                 SAFE_FREE(data);
5756                                 data = pdata;
5757                         }
5758                         ServicePtrs[i]->param_opt = NULL;
5759                         return (i);
5760                 }
5761         }
5762
5763         /* find an invalid one */
5764         i = iNumServices;
5765         if (num_invalid_services > 0) {
5766                 i = invalid_services[--num_invalid_services];
5767         }
5768
5769         /* if not, then create one */
5770         if (i == iNumServices) {
5771                 struct service **tsp;
5772                 int *tinvalid;
5773
5774                 tsp = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(ServicePtrs, struct service *, num_to_alloc);
5775                 if (tsp == NULL) {
5776                         DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
5777                         return (-1);
5778                 }
5779                 ServicePtrs = tsp;
5780                 ServicePtrs[iNumServices] = SMB_MALLOC_P(struct service);
5781                 if (!ServicePtrs[iNumServices]) {
5782                         DEBUG(0,("add_a_service: out of memory!\n"));
5783                         return (-1);
5784                 }
5785                 iNumServices++;
5786
5787                 /* enlarge invalid_services here for now... */
5788                 tinvalid = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(invalid_services, int,
5789                                              num_to_alloc);
5790                 if (tinvalid == NULL) {
5791                         DEBUG(0,("add_a_service: failed to enlarge "
5792                                  "invalid_services!\n"));
5793                         return (-1);
5794                 }
5795                 invalid_services = tinvalid;
5796         } else {
5797                 free_service_byindex(i);
5798         }
5799
5800         ServicePtrs[i]->valid = True;
5801
5802         init_service(ServicePtrs[i]);
5803         copy_service(ServicePtrs[i], &tservice, NULL);
5804         if (name)
5805                 string_set(&ServicePtrs[i]->szService, name);
5806
5807         DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
5808                 i, ServicePtrs[i]->szService));
5809
5810         if (!hash_a_service(ServicePtrs[i]->szService, i)) {
5811                 return (-1);
5812         }
5813
5814         return (i);
5815 }
5816
5817 /***************************************************************************
5818   Convert a string to uppercase and remove whitespaces.
5819 ***************************************************************************/
5820
5821 static char *canonicalize_servicename(const char *src)
5822 {
5823         char *result;
5824
5825         if ( !src ) {
5826                 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
5827                 return NULL;
5828         }
5829
5830         result = talloc_strdup(talloc_tos(), src);
5831         SMB_ASSERT(result != NULL);
5832
5833         strlower_m(result);
5834         return result;
5835 }
5836
5837 /***************************************************************************
5838   Add a name/index pair for the services array to the hash table.
5839 ***************************************************************************/
5840
5841 static bool hash_a_service(const char *name, int idx)
5842 {
5843         char *canon_name;
5844
5845         if ( !ServiceHash ) {
5846                 DEBUG(10,("hash_a_service: creating servicehash\n"));
5847                 ServiceHash = db_open_rbt(NULL);
5848                 if ( !ServiceHash ) {
5849                         DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
5850                         return False;
5851                 }
5852         }
5853
5854         DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
5855                 idx, name));
5856
5857         canon_name = canonicalize_servicename( name );
5858
5859         dbwrap_store_bystring(ServiceHash, canon_name,
5860                               make_tdb_data((uint8 *)&idx, sizeof(idx)),
5861                               TDB_REPLACE);
5862
5863         TALLOC_FREE(canon_name);
5864
5865         return True;
5866 }
5867
5868 /***************************************************************************
5869  Add a new home service, with the specified home directory, defaults coming
5870  from service ifrom.
5871 ***************************************************************************/
5872
5873 bool lp_add_home(const char *pszHomename, int iDefaultService,
5874                  const char *user, const char *pszHomedir)
5875 {
5876         int i;
5877
5878         i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
5879
5880         if (i < 0)
5881                 return (False);
5882
5883         if (!(*(ServicePtrs[iDefaultService]->szPath))
5884             || strequal(ServicePtrs[iDefaultService]->szPath, lp_pathname(GLOBAL_SECTION_SNUM))) {
5885                 string_set(&ServicePtrs[i]->szPath, pszHomedir);
5886         }
5887
5888         if (!(*(ServicePtrs[i]->comment))) {
5889                 char *comment = NULL;
5890                 if (asprintf(&comment, "Home directory of %s", user) < 0) {
5891                         return false;
5892                 }
5893                 string_set(&ServicePtrs[i]->comment, comment);
5894                 SAFE_FREE(comment);
5895         }
5896
5897         /* set the browseable flag from the global default */
5898
5899         ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
5900
5901         ServicePtrs[i]->autoloaded = True;
5902
5903         DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
5904                user, ServicePtrs[i]->szPath ));
5905
5906         return (True);
5907 }
5908
5909 /***************************************************************************
5910  Add a new service, based on an old one.
5911 ***************************************************************************/
5912
5913 int lp_add_service(const char *pszService, int iDefaultService)
5914 {
5915         if (iDefaultService < 0) {
5916                 return add_a_service(&sDefault, pszService);
5917         }
5918
5919         return (add_a_service(ServicePtrs[iDefaultService], pszService));
5920 }
5921
5922 /***************************************************************************
5923  Add the IPC service.
5924 ***************************************************************************/
5925
5926 static bool lp_add_ipc(const char *ipc_name, bool guest_ok)
5927 {
5928         char *comment = NULL;
5929         int i = add_a_service(&sDefault, ipc_name);
5930
5931         if (i < 0)
5932                 return (False);
5933
5934         if (asprintf(&comment, "IPC Service (%s)",
5935                                 Globals.szServerString) < 0) {
5936                 return (False);
5937         }
5938
5939         string_set(&ServicePtrs[i]->szPath, tmpdir());
5940         string_set(&ServicePtrs[i]->szUsername, "");
5941         string_set(&ServicePtrs[i]->comment, comment);
5942         string_set(&ServicePtrs[i]->fstype, "IPC");
5943         ServicePtrs[i]->iMaxConnections = 0;
5944         ServicePtrs[i]->bAvailable = True;
5945         ServicePtrs[i]->bRead_only = True;
5946         ServicePtrs[i]->bGuest_only = False;
5947         ServicePtrs[i]->bAdministrative_share = True;
5948         ServicePtrs[i]->bGuest_ok = guest_ok;
5949         ServicePtrs[i]->bPrint_ok = False;
5950         ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
5951
5952         DEBUG(3, ("adding IPC service\n"));
5953
5954         SAFE_FREE(comment);
5955         return (True);
5956 }
5957
5958 /***************************************************************************
5959  Add a new printer service, with defaults coming from service iFrom.
5960 ***************************************************************************/
5961
5962 bool lp_add_printer(const char *pszPrintername, int iDefaultService)
5963 {
5964         const char *comment = "From Printcap";
5965         int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
5966
5967         if (i < 0)
5968                 return (False);
5969
5970         /* note that we do NOT default the availability flag to True - */
5971         /* we take it from the default service passed. This allows all */
5972         /* dynamic printers to be disabled by disabling the [printers] */
5973         /* entry (if/when the 'available' keyword is implemented!).    */
5974
5975         /* the printer name is set to the service name. */
5976         string_set(&ServicePtrs[i]->szPrintername, pszPrintername);
5977         string_set(&ServicePtrs[i]->comment, comment);
5978
5979         /* set the browseable flag from the gloabl default */
5980         ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
5981
5982         /* Printers cannot be read_only. */
5983         ServicePtrs[i]->bRead_only = False;
5984         /* No share modes on printer services. */
5985         ServicePtrs[i]->bShareModes = False;
5986         /* No oplocks on printer services. */
5987         ServicePtrs[i]->bOpLocks = False;
5988         /* Printer services must be printable. */
5989         ServicePtrs[i]->bPrint_ok = True;
5990
5991         DEBUG(3, ("adding printer service %s\n", pszPrintername));
5992
5993         return (True);
5994 }
5995
5996
5997 /***************************************************************************
5998  Check whether the given parameter name is valid.
5999  Parametric options (names containing a colon) are considered valid.
6000 ***************************************************************************/
6001
6002 bool lp_parameter_is_valid(const char *pszParmName)
6003 {
6004         return ((map_parameter(pszParmName) != -1) ||
6005                 (strchr(pszParmName, ':') != NULL));
6006 }
6007
6008 /***************************************************************************
6009  Check whether the given name is the name of a global parameter.
6010  Returns True for strings belonging to parameters of class
6011  P_GLOBAL, False for all other strings, also for parametric options
6012  and strings not belonging to any option.
6013 ***************************************************************************/
6014
6015 bool lp_parameter_is_global(const char *pszParmName)
6016 {
6017         int num = map_parameter(pszParmName);
6018
6019         if (num >= 0) {
6020                 return (parm_table[num].p_class == P_GLOBAL);
6021         }
6022
6023         return False;
6024 }
6025
6026 /**************************************************************************
6027  Check whether the given name is the canonical name of a parameter.
6028  Returns False if it is not a valid parameter Name.
6029  For parametric options, True is returned.
6030 **************************************************************************/
6031
6032 bool lp_parameter_is_canonical(const char *parm_name)
6033 {
6034         if (!lp_parameter_is_valid(parm_name)) {
6035                 return False;
6036         }
6037
6038         return (map_parameter(parm_name) ==
6039                 map_parameter_canonical(parm_name, NULL));
6040 }
6041
6042 /**************************************************************************
6043  Determine the canonical name for a parameter.
6044  Indicate when it is an inverse (boolean) synonym instead of a
6045  "usual" synonym.
6046 **************************************************************************/
6047
6048 bool lp_canonicalize_parameter(const char *parm_name, const char **canon_parm,
6049                                bool *inverse)
6050 {
6051         int num;
6052
6053         if (!lp_parameter_is_valid(parm_name)) {
6054                 *canon_parm = NULL;
6055                 return False;
6056         }
6057
6058         num = map_parameter_canonical(parm_name, inverse);
6059         if (num < 0) {
6060                 /* parametric option */
6061                 *canon_parm = parm_name;
6062         } else {
6063                 *canon_parm = parm_table[num].label;
6064         }
6065
6066         return True;
6067
6068 }
6069
6070 /**************************************************************************
6071  Determine the canonical name for a parameter.
6072  Turn the value given into the inverse boolean expression when
6073  the synonym is an invers boolean synonym.
6074
6075  Return True if parm_name is a valid parameter name and
6076  in case it is an invers boolean synonym, if the val string could
6077  successfully be converted to the reverse bool.
6078  Return false in all other cases.
6079 **************************************************************************/
6080
6081 bool lp_canonicalize_parameter_with_value(const char *parm_name,
6082                                           const char *val,
6083                                           const char **canon_parm,
6084                                           const char **canon_val)
6085 {
6086         int num;
6087         bool inverse;
6088
6089         if (!lp_parameter_is_valid(parm_name)) {
6090                 *canon_parm = NULL;
6091                 *canon_val = NULL;
6092                 return False;
6093         }
6094
6095         num = map_parameter_canonical(parm_name, &inverse);
6096         if (num < 0) {
6097                 /* parametric option */
6098                 *canon_parm = parm_name;
6099                 *canon_val = val;
6100         } else {
6101                 *canon_parm = parm_table[num].label;
6102                 if (inverse) {
6103                         if (!lp_invert_boolean(val, canon_val)) {
6104                                 *canon_val = NULL;
6105                                 return False;
6106                         }
6107                 } else {
6108                         *canon_val = val;
6109                 }
6110         }
6111
6112         return True;
6113 }
6114
6115 /***************************************************************************
6116  Map a parameter's string representation to something we can use.
6117  Returns False if the parameter string is not recognised, else TRUE.
6118 ***************************************************************************/
6119
6120 static int map_parameter(const char *pszParmName)
6121 {
6122         int iIndex;
6123
6124         if (*pszParmName == '-' && !strequal(pszParmName, "-valid"))
6125                 return (-1);
6126
6127         for (iIndex = 0; parm_table[iIndex].label; iIndex++)
6128                 if (strwicmp(parm_table[iIndex].label, pszParmName) == 0)
6129                         return (iIndex);
6130
6131         /* Warn only if it isn't parametric option */
6132         if (strchr(pszParmName, ':') == NULL)
6133                 DEBUG(1, ("Unknown parameter encountered: \"%s\"\n", pszParmName));
6134         /* We do return 'fail' for parametric options as well because they are
6135            stored in different storage
6136          */
6137         return (-1);
6138 }
6139
6140 /***************************************************************************
6141  Map a parameter's string representation to the index of the canonical
6142  form of the parameter (it might be a synonym).
6143  Returns -1 if the parameter string is not recognised.
6144 ***************************************************************************/
6145
6146 static int map_parameter_canonical(const char *pszParmName, bool *inverse)
6147 {
6148         int parm_num, canon_num;
6149         bool loc_inverse = False;
6150
6151         parm_num = map_parameter(pszParmName);
6152         if ((parm_num < 0) || !(parm_table[parm_num].flags & FLAG_HIDE)) {
6153                 /* invalid, parametric or no canidate for synonyms ... */
6154                 goto done;
6155         }
6156
6157         for (canon_num = 0; parm_table[canon_num].label; canon_num++) {
6158                 if (is_synonym_of(parm_num, canon_num, &loc_inverse)) {
6159                         parm_num = canon_num;
6160                         goto done;
6161                 }
6162         }
6163
6164 done:
6165         if (inverse != NULL) {
6166                 *inverse = loc_inverse;
6167         }
6168         return parm_num;
6169 }
6170
6171 /***************************************************************************
6172  return true if parameter number parm1 is a synonym of parameter
6173  number parm2 (parm2 being the principal name).
6174  set inverse to True if parm1 is P_BOOLREV and parm2 is P_BOOL,
6175  False otherwise.
6176 ***************************************************************************/
6177
6178 static bool is_synonym_of(int parm1, int parm2, bool *inverse)
6179 {
6180         if ((parm_table[parm1].ptr == parm_table[parm2].ptr) &&
6181             (parm_table[parm1].flags & FLAG_HIDE) &&
6182             !(parm_table[parm2].flags & FLAG_HIDE))
6183         {
6184                 if (inverse != NULL) {
6185                         if ((parm_table[parm1].type == P_BOOLREV) &&
6186                             (parm_table[parm2].type == P_BOOL))
6187                         {
6188                                 *inverse = True;
6189                         } else {
6190                                 *inverse = False;
6191                         }
6192                 }
6193                 return True;
6194         }
6195         return False;
6196 }
6197
6198 /***************************************************************************
6199  Show one parameter's name, type, [values,] and flags.
6200  (helper functions for show_parameter_list)
6201 ***************************************************************************/
6202
6203 static void show_parameter(int parmIndex)
6204 {
6205         int enumIndex, flagIndex;
6206         int parmIndex2;
6207         bool hadFlag;
6208         bool hadSyn;
6209         bool inverse;
6210         const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
6211                 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
6212                 "P_ENUM", "P_SEP"};
6213         unsigned flags[] = { FLAG_BASIC, FLAG_SHARE, FLAG_PRINT, FLAG_GLOBAL,
6214                 FLAG_WIZARD, FLAG_ADVANCED, FLAG_DEVELOPER, FLAG_DEPRECATED,
6215                 FLAG_HIDE, FLAG_DOS_STRING};
6216         const char *flag_names[] = { "FLAG_BASIC", "FLAG_SHARE", "FLAG_PRINT",
6217                 "FLAG_GLOBAL", "FLAG_WIZARD", "FLAG_ADVANCED", "FLAG_DEVELOPER",
6218                 "FLAG_DEPRECATED", "FLAG_HIDE", "FLAG_DOS_STRING", NULL};
6219
6220         printf("%s=%s", parm_table[parmIndex].label,
6221                type[parm_table[parmIndex].type]);
6222         if (parm_table[parmIndex].type == P_ENUM) {
6223                 printf(",");
6224                 for (enumIndex=0;
6225                      parm_table[parmIndex].enum_list[enumIndex].name;
6226                      enumIndex++)
6227                 {
6228                         printf("%s%s",
6229                                enumIndex ? "|" : "",
6230                                parm_table[parmIndex].enum_list[enumIndex].name);
6231                 }
6232         }
6233         printf(",");
6234         hadFlag = False;
6235         for (flagIndex=0; flag_names[flagIndex]; flagIndex++) {
6236                 if (parm_table[parmIndex].flags & flags[flagIndex]) {
6237                         printf("%s%s",
6238                                 hadFlag ? "|" : "",
6239                                 flag_names[flagIndex]);
6240                         hadFlag = True;
6241                 }
6242         }
6243
6244         /* output synonyms */
6245         hadSyn = False;
6246         for (parmIndex2=0; parm_table[parmIndex2].label; parmIndex2++) {
6247                 if (is_synonym_of(parmIndex, parmIndex2, &inverse)) {
6248                         printf(" (%ssynonym of %s)", inverse ? "inverse " : "",
6249                                parm_table[parmIndex2].label);
6250                 } else if (is_synonym_of(parmIndex2, parmIndex, &inverse)) {
6251                         if (!hadSyn) {
6252                                 printf(" (synonyms: ");
6253                                 hadSyn = True;
6254                         } else {
6255                                 printf(", ");
6256                         }
6257                         printf("%s%s", parm_table[parmIndex2].label,
6258                                inverse ? "[i]" : "");
6259                 }
6260         }
6261         if (hadSyn) {
6262                 printf(")");
6263         }
6264
6265         printf("\n");
6266 }
6267
6268 /***************************************************************************
6269  Show all parameter's name, type, [values,] and flags.
6270 ***************************************************************************/
6271
6272 void show_parameter_list(void)
6273 {
6274         int classIndex, parmIndex;
6275         const char *section_names[] = { "local", "global", NULL};
6276
6277         for (classIndex=0; section_names[classIndex]; classIndex++) {
6278                 printf("[%s]\n", section_names[classIndex]);
6279                 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
6280                         if (parm_table[parmIndex].p_class == classIndex) {
6281                                 show_parameter(parmIndex);
6282                         }
6283                 }
6284         }
6285 }
6286
6287 /***************************************************************************
6288  Set a boolean variable from the text value stored in the passed string.
6289  Returns True in success, False if the passed string does not correctly
6290  represent a boolean.
6291 ***************************************************************************/
6292
6293 static bool set_boolean(bool *pb, const char *pszParmValue)
6294 {
6295         bool bRetval;
6296         bool value;
6297
6298         bRetval = True;
6299         value = False;
6300         if (strwicmp(pszParmValue, "yes") == 0 ||
6301             strwicmp(pszParmValue, "true") == 0 ||
6302             strwicmp(pszParmValue, "1") == 0)
6303                 value = True;
6304         else if (strwicmp(pszParmValue, "no") == 0 ||
6305                     strwicmp(pszParmValue, "False") == 0 ||
6306                     strwicmp(pszParmValue, "0") == 0)
6307                 value = False;
6308         else {
6309                 DEBUG(2,
6310                       ("ERROR: Badly formed boolean in configuration file: \"%s\".\n",
6311                        pszParmValue));
6312                 bRetval = False;
6313         }
6314
6315         if ((pb != NULL) && (bRetval != False)) {
6316                 *pb = value;
6317         }
6318
6319         return (bRetval);
6320 }
6321
6322
6323 /***************************************************************************
6324  Check if a given string correctly represents a boolean value.
6325 ***************************************************************************/
6326
6327 bool lp_string_is_valid_boolean(const char *parm_value)
6328 {
6329         return set_boolean(NULL, parm_value);
6330 }
6331
6332 /***************************************************************************
6333  Get the standard string representation of a boolean value ("yes" or "no")
6334 ***************************************************************************/
6335
6336 static const char *get_boolean(bool bool_value)
6337 {
6338         static const char *yes_str = "yes";
6339         static const char *no_str = "no";
6340
6341         return (bool_value ? yes_str : no_str);
6342 }
6343
6344 /***************************************************************************
6345  Provide the string of the negated boolean value associated to the boolean
6346  given as a string. Returns False if the passed string does not correctly
6347  represent a boolean.
6348 ***************************************************************************/
6349
6350 bool lp_invert_boolean(const char *str, const char **inverse_str)
6351 {
6352         bool val;
6353
6354         if (!set_boolean(&val, str)) {
6355                 return False;
6356         }
6357
6358         *inverse_str = get_boolean(!val);
6359         return True;
6360 }
6361
6362 /***************************************************************************
6363  Provide the canonical string representation of a boolean value given
6364  as a string. Return True on success, False if the string given does
6365  not correctly represent a boolean.
6366 ***************************************************************************/
6367
6368 bool lp_canonicalize_boolean(const char *str, const char**canon_str)
6369 {
6370         bool val;
6371
6372         if (!set_boolean(&val, str)) {
6373                 return False;
6374         }
6375
6376         *canon_str = get_boolean(val);
6377         return True;
6378 }
6379
6380 /***************************************************************************
6381 Find a service by name. Otherwise works like get_service.
6382 ***************************************************************************/
6383
6384 static int getservicebyname(const char *pszServiceName, struct service *pserviceDest)
6385 {
6386         int iService = -1;
6387         char *canon_name;
6388         TDB_DATA data;
6389
6390         if (ServiceHash == NULL) {
6391                 return -1;
6392         }
6393
6394         canon_name = canonicalize_servicename(pszServiceName);
6395
6396         data = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name);
6397
6398         if ((data.dptr != NULL) && (data.dsize == sizeof(iService))) {
6399                 iService = *(int *)data.dptr;
6400         }
6401
6402         TALLOC_FREE(canon_name);
6403
6404         if ((iService != -1) && (LP_SNUM_OK(iService))
6405             && (pserviceDest != NULL)) {
6406                 copy_service(pserviceDest, ServicePtrs[iService], NULL);
6407         }
6408
6409         return (iService);
6410 }
6411
6412 /***************************************************************************
6413  Copy a service structure to another.
6414  If pcopymapDest is NULL then copy all fields
6415 ***************************************************************************/
6416
6417 static void copy_service(struct service *pserviceDest, struct service *pserviceSource,
6418                          struct bitmap *pcopymapDest)
6419 {
6420         int i;
6421         bool bcopyall = (pcopymapDest == NULL);
6422         struct param_opt_struct *data, *pdata, *paramo;
6423         bool not_added;
6424
6425         for (i = 0; parm_table[i].label; i++)
6426                 if (parm_table[i].ptr && parm_table[i].p_class == P_LOCAL &&
6427                     (bcopyall || bitmap_query(pcopymapDest,i))) {
6428                         void *def_ptr = parm_table[i].ptr;
6429                         void *src_ptr =
6430                                 ((char *)pserviceSource) + PTR_DIFF(def_ptr,
6431                                                                     &sDefault);
6432                         void *dest_ptr =
6433                                 ((char *)pserviceDest) + PTR_DIFF(def_ptr,
6434                                                                   &sDefault);
6435
6436                         switch (parm_table[i].type) {
6437                                 case P_BOOL:
6438                                 case P_BOOLREV:
6439                                         *(bool *)dest_ptr = *(bool *)src_ptr;
6440                                         break;
6441
6442                                 case P_INTEGER:
6443                                 case P_ENUM:
6444                                 case P_OCTAL:
6445                                         *(int *)dest_ptr = *(int *)src_ptr;
6446                                         break;
6447
6448                                 case P_CHAR:
6449                                         *(char *)dest_ptr = *(char *)src_ptr;
6450                                         break;
6451
6452                                 case P_STRING:
6453                                         string_set((char **)dest_ptr,
6454                                                    *(char **)src_ptr);
6455                                         break;
6456
6457                                 case P_USTRING:
6458                                         string_set((char **)dest_ptr,
6459                                                    *(char **)src_ptr);
6460                                         strupper_m(*(char **)dest_ptr);
6461                                         break;
6462                                 case P_LIST:
6463                                         TALLOC_FREE(*((char ***)dest_ptr));
6464                                         str_list_copy(NULL, (char ***)dest_ptr,
6465                                                       *(const char ***)src_ptr);
6466                                         break;
6467                                 default:
6468                                         break;
6469                         }
6470                 }
6471
6472         if (bcopyall) {
6473                 init_copymap(pserviceDest);
6474                 if (pserviceSource->copymap)
6475                         bitmap_copy(pserviceDest->copymap,
6476                                     pserviceSource->copymap);
6477         }
6478
6479         data = pserviceSource->param_opt;
6480         while (data) {
6481                 not_added = True;
6482                 pdata = pserviceDest->param_opt;
6483                 /* Traverse destination */
6484                 while (pdata) {
6485                         /* If we already have same option, override it */
6486                         if (strwicmp(pdata->key, data->key) == 0) {
6487                                 string_free(&pdata->value);
6488                                 TALLOC_FREE(data->list);
6489                                 pdata->value = SMB_STRDUP(data->value);
6490                                 not_added = False;
6491                                 break;
6492                         }
6493                         pdata = pdata->next;
6494                 }
6495                 if (not_added) {
6496                     paramo = SMB_XMALLOC_P(struct param_opt_struct);
6497                     paramo->key = SMB_STRDUP(data->key);
6498                     paramo->value = SMB_STRDUP(data->value);
6499                     paramo->list = NULL;
6500                     DLIST_ADD(pserviceDest->param_opt, paramo);
6501                 }
6502                 data = data->next;
6503         }
6504 }
6505
6506 /***************************************************************************
6507 Check a service for consistency. Return False if the service is in any way
6508 incomplete or faulty, else True.
6509 ***************************************************************************/
6510
6511 bool service_ok(int iService)
6512 {
6513         bool bRetval;
6514
6515         bRetval = True;
6516         if (ServicePtrs[iService]->szService[0] == '\0') {
6517                 DEBUG(0, ("The following message indicates an internal error:\n"));
6518                 DEBUG(0, ("No service name in service entry.\n"));
6519                 bRetval = False;
6520         }
6521
6522         /* The [printers] entry MUST be printable. I'm all for flexibility, but */
6523         /* I can't see why you'd want a non-printable printer service...        */
6524         if (strwicmp(ServicePtrs[iService]->szService, PRINTERS_NAME) == 0) {
6525                 if (!ServicePtrs[iService]->bPrint_ok) {
6526                         DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
6527                                ServicePtrs[iService]->szService));
6528                         ServicePtrs[iService]->bPrint_ok = True;
6529                 }
6530                 /* [printers] service must also be non-browsable. */
6531                 if (ServicePtrs[iService]->bBrowseable)
6532                         ServicePtrs[iService]->bBrowseable = False;
6533         }
6534
6535         if (ServicePtrs[iService]->szPath[0] == '\0' &&
6536             strwicmp(ServicePtrs[iService]->szService, HOMES_NAME) != 0 &&
6537             ServicePtrs[iService]->szMSDfsProxy[0] == '\0'
6538             ) {
6539                 DEBUG(0, ("WARNING: No path in service %s - making it unavailable!\n",
6540                         ServicePtrs[iService]->szService));
6541                 ServicePtrs[iService]->bAvailable = False;
6542         }
6543
6544         /* If a service is flagged unavailable, log the fact at level 1. */
6545         if (!ServicePtrs[iService]->bAvailable)
6546                 DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
6547                           ServicePtrs[iService]->szService));
6548
6549         return (bRetval);
6550 }
6551
6552 static struct smbconf_ctx *lp_smbconf_ctx(void)
6553 {
6554         WERROR werr;
6555         static struct smbconf_ctx *conf_ctx = NULL;
6556
6557         if (conf_ctx == NULL) {
6558                 werr = smbconf_init(NULL, &conf_ctx, "registry:");
6559                 if (!W_ERROR_IS_OK(werr)) {
6560                         DEBUG(1, ("error initializing registry configuration: "
6561                                   "%s\n", dos_errstr(werr)));
6562                         conf_ctx = NULL;
6563                 }
6564         }
6565
6566         return conf_ctx;
6567 }
6568
6569 static bool process_registry_service(struct smbconf_service *service)
6570 {
6571         uint32_t count;
6572         bool ret;
6573
6574         if (service == NULL) {
6575                 return false;
6576         }
6577
6578         ret = do_section(service->name, NULL);
6579         if (ret != true) {
6580                 return false;
6581         }
6582         for (count = 0; count < service->num_params; count++) {
6583                 ret = do_parameter(service->param_names[count],
6584                                    service->param_values[count],
6585                                    NULL);
6586                 if (ret != true) {
6587                         return false;
6588                 }
6589         }
6590         if (iServiceIndex >= 0) {
6591                 return  service_ok(iServiceIndex);
6592         }
6593         return true;
6594 }
6595
6596 /*
6597  * process_registry_globals
6598  */
6599 static bool process_registry_globals(void)
6600 {
6601         WERROR werr;
6602         struct smbconf_service *service = NULL;
6603         TALLOC_CTX *mem_ctx = talloc_stackframe();
6604         struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
6605         bool ret = false;
6606
6607         if (conf_ctx == NULL) {
6608                 goto done;
6609         }
6610
6611         add_to_file_list(INCLUDE_REGISTRY_NAME, INCLUDE_REGISTRY_NAME);
6612
6613         ret = do_parameter("registry shares", "yes", NULL);
6614         if (!ret) {
6615                 goto done;
6616         }
6617
6618         if (!smbconf_share_exists(conf_ctx, GLOBAL_NAME)) {
6619                 /* nothing to read from the registry yet but make sure lp_load
6620                  * doesn't return false */
6621                 ret = true;
6622                 goto done;
6623         }
6624
6625         werr = smbconf_get_share(conf_ctx, mem_ctx, GLOBAL_NAME, &service);
6626         if (!W_ERROR_IS_OK(werr)) {
6627                 goto done;
6628         }
6629
6630         ret = process_registry_service(service);
6631         if (!ret) {
6632                 goto done;
6633         }
6634
6635         /* store the csn */
6636         smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
6637
6638 done:
6639         TALLOC_FREE(mem_ctx);
6640         return ret;
6641 }
6642
6643 static bool process_registry_shares(void)
6644 {
6645         WERROR werr;
6646         uint32_t count;
6647         struct smbconf_service **service = NULL;
6648         uint32_t num_shares = 0;
6649         TALLOC_CTX *mem_ctx = talloc_stackframe();
6650         struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
6651         bool ret = false;
6652
6653         if (conf_ctx == NULL) {
6654                 goto done;
6655         }
6656
6657         werr = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &service);
6658         if (!W_ERROR_IS_OK(werr)) {
6659                 goto done;
6660         }
6661
6662         ret = true;
6663
6664         for (count = 0; count < num_shares; count++) {
6665                 if (strequal(service[count]->name, GLOBAL_NAME)) {
6666                         continue;
6667                 }
6668                 ret = process_registry_service(service[count]);
6669                 if (!ret) {
6670                         goto done;
6671                 }
6672         }
6673
6674         /* store the csn */
6675         smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
6676
6677 done:
6678         TALLOC_FREE(mem_ctx);
6679         return ret;
6680 }
6681
6682 #define MAX_INCLUDE_DEPTH 100
6683
6684 static uint8_t include_depth;
6685
6686 static struct file_lists {
6687         struct file_lists *next;
6688         char *name;
6689         char *subfname;
6690         time_t modtime;
6691 } *file_lists = NULL;
6692
6693 /*******************************************************************
6694  Keep a linked list of all config files so we know when one has changed
6695  it's date and needs to be reloaded.
6696 ********************************************************************/
6697
6698 static void add_to_file_list(const char *fname, const char *subfname)
6699 {
6700         struct file_lists *f = file_lists;
6701
6702         while (f) {
6703                 if (f->name && !strcmp(f->name, fname))
6704                         break;
6705                 f = f->next;
6706         }
6707
6708         if (!f) {
6709                 f = SMB_MALLOC_P(struct file_lists);
6710                 if (!f)
6711                         return;
6712                 f->next = file_lists;
6713                 f->name = SMB_STRDUP(fname);
6714                 if (!f->name) {
6715                         SAFE_FREE(f);
6716                         return;
6717                 }
6718                 f->subfname = SMB_STRDUP(subfname);
6719                 if (!f->subfname) {
6720                         SAFE_FREE(f);
6721                         return;
6722                 }
6723                 file_lists = f;
6724                 f->modtime = file_modtime(subfname);
6725         } else {
6726                 time_t t = file_modtime(subfname);
6727                 if (t)
6728                         f->modtime = t;
6729         }
6730 }
6731
6732 /**
6733  * Utility function for outsiders to check if we're running on registry.
6734  */
6735 bool lp_config_backend_is_registry(void)
6736 {
6737         return (lp_config_backend() == CONFIG_BACKEND_REGISTRY);
6738 }
6739
6740 /**
6741  * Utility function to check if the config backend is FILE.
6742  */
6743 bool lp_config_backend_is_file(void)
6744 {
6745         return (lp_config_backend() == CONFIG_BACKEND_FILE);
6746 }
6747
6748 /*******************************************************************
6749  Check if a config file has changed date.
6750 ********************************************************************/
6751
6752 bool lp_file_list_changed(void)
6753 {
6754         struct file_lists *f = file_lists;
6755
6756         DEBUG(6, ("lp_file_list_changed()\n"));
6757
6758         while (f) {
6759                 char *n2 = NULL;
6760                 time_t mod_time;
6761
6762                 if (strequal(f->name, INCLUDE_REGISTRY_NAME)) {
6763                         struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
6764
6765                         if (conf_ctx == NULL) {
6766                                 return false;
6767                         }
6768                         if (smbconf_changed(conf_ctx, &conf_last_csn, NULL,
6769                                             NULL))
6770                         {
6771                                 DEBUGADD(6, ("registry config changed\n"));
6772                                 return true;
6773                         }
6774                 } else {
6775                         n2 = alloc_sub_basic(get_current_username(),
6776                                             current_user_info.domain,
6777                                             f->name);
6778                         if (!n2) {
6779                                 return false;
6780                         }
6781                         DEBUGADD(6, ("file %s -> %s  last mod_time: %s\n",
6782                                      f->name, n2, ctime(&f->modtime)));
6783
6784                         mod_time = file_modtime(n2);
6785
6786                         if (mod_time &&
6787                             ((f->modtime != mod_time) ||
6788                              (f->subfname == NULL) ||
6789                              (strcmp(n2, f->subfname) != 0)))
6790                         {
6791                                 DEBUGADD(6,
6792                                          ("file %s modified: %s\n", n2,
6793                                           ctime(&mod_time)));
6794                                 f->modtime = mod_time;
6795                                 SAFE_FREE(f->subfname);
6796                                 f->subfname = n2; /* Passing ownership of
6797                                                      return from alloc_sub_basic
6798                                                      above. */
6799                                 return true;
6800                         }
6801                         SAFE_FREE(n2);
6802                 }
6803                 f = f->next;
6804         }
6805         return (False);
6806 }
6807
6808
6809 /***************************************************************************
6810  Run standard_sub_basic on netbios name... needed because global_myname
6811  is not accessed through any lp_ macro.
6812  Note: We must *NOT* use string_set() here as ptr points to global_myname.
6813 ***************************************************************************/
6814
6815 static bool handle_netbios_name(int snum, const char *pszParmValue, char **ptr)
6816 {
6817         bool ret;
6818         char *netbios_name = alloc_sub_basic(get_current_username(),
6819                                         current_user_info.domain,
6820                                         pszParmValue);
6821
6822         ret = set_global_myname(netbios_name);
6823         SAFE_FREE(netbios_name);
6824         string_set(&Globals.szNetbiosName,global_myname());
6825
6826         DEBUG(4, ("handle_netbios_name: set global_myname to: %s\n",
6827                global_myname()));
6828
6829         return ret;
6830 }
6831
6832 static bool handle_charset(int snum, const char *pszParmValue, char **ptr)
6833 {
6834         if (strcmp(*ptr, pszParmValue) != 0) {
6835                 string_set(ptr, pszParmValue);
6836                 init_iconv();
6837         }
6838         return True;
6839 }
6840
6841
6842
6843 static bool handle_workgroup(int snum, const char *pszParmValue, char **ptr)
6844 {
6845         bool ret;
6846
6847         ret = set_global_myworkgroup(pszParmValue);
6848         string_set(&Globals.szWorkgroup,lp_workgroup());
6849
6850         return ret;
6851 }
6852
6853 static bool handle_netbios_scope(int snum, const char *pszParmValue, char **ptr)
6854 {
6855         bool ret;
6856
6857         ret = set_global_scope(pszParmValue);
6858         string_set(&Globals.szNetbiosScope,global_scope());
6859
6860         return ret;
6861 }
6862
6863 static bool handle_netbios_aliases(int snum, const char *pszParmValue, char **ptr)
6864 {
6865         TALLOC_FREE(Globals.szNetbiosAliases);
6866         Globals.szNetbiosAliases = str_list_make(talloc_autofree_context(), pszParmValue, NULL);
6867         return set_netbios_aliases((const char **)Globals.szNetbiosAliases);
6868 }
6869
6870 /***************************************************************************
6871  Handle the include operation.
6872 ***************************************************************************/
6873 static bool bAllowIncludeRegistry = true;
6874
6875 static bool handle_include(int snum, const char *pszParmValue, char **ptr)
6876 {
6877         char *fname;
6878
6879         if (include_depth >= MAX_INCLUDE_DEPTH) {
6880                 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
6881                           include_depth));
6882                 return false;
6883         }
6884
6885         if (strequal(pszParmValue, INCLUDE_REGISTRY_NAME)) {
6886                 if (!bAllowIncludeRegistry) {
6887                         return true;
6888                 }
6889                 if (bInGlobalSection) {
6890                         bool ret;
6891                         include_depth++;
6892                         ret = process_registry_globals();
6893                         include_depth--;
6894                         return ret;
6895                 } else {
6896                         DEBUG(1, ("\"include = registry\" only effective "
6897                                   "in %s section\n", GLOBAL_NAME));
6898                         return false;
6899                 }
6900         }
6901
6902         fname = alloc_sub_basic(get_current_username(),
6903                                 current_user_info.domain,
6904                                 pszParmValue);
6905
6906         add_to_file_list(pszParmValue, fname);
6907
6908         string_set(ptr, fname);
6909
6910         if (file_exist(fname, NULL)) {
6911                 bool ret;
6912                 include_depth++;
6913                 ret = pm_process(fname, do_section, do_parameter, NULL);
6914                 include_depth--;
6915                 SAFE_FREE(fname);
6916                 return ret;
6917         }
6918
6919         DEBUG(2, ("Can't find include file %s\n", fname));
6920         SAFE_FREE(fname);
6921         return true;
6922 }
6923
6924 /***************************************************************************
6925  Handle the interpretation of the copy parameter.
6926 ***************************************************************************/
6927
6928 static bool handle_copy(int snum, const char *pszParmValue, char **ptr)
6929 {
6930         bool bRetval;
6931         int iTemp;
6932         struct service serviceTemp;
6933
6934         string_set(ptr, pszParmValue);
6935
6936         init_service(&serviceTemp);
6937
6938         bRetval = False;
6939
6940         DEBUG(3, ("Copying service from service %s\n", pszParmValue));
6941
6942         if ((iTemp = getservicebyname(pszParmValue, &serviceTemp)) >= 0) {
6943                 if (iTemp == iServiceIndex) {
6944                         DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
6945                 } else {
6946                         copy_service(ServicePtrs[iServiceIndex],
6947                                      &serviceTemp,
6948                                      ServicePtrs[iServiceIndex]->copymap);
6949                         bRetval = True;
6950                 }
6951         } else {
6952                 DEBUG(0, ("Unable to copy service - source not found: %s\n", pszParmValue));
6953                 bRetval = False;
6954         }
6955
6956         free_service(&serviceTemp);
6957         return (bRetval);
6958 }
6959
6960 static bool handle_ldap_debug_level(int snum, const char *pszParmValue, char **ptr)
6961 {
6962         Globals.ldap_debug_level = lp_int(pszParmValue);
6963         init_ldap_debugging();
6964         return true;
6965 }
6966
6967 /***************************************************************************
6968  Handle idmap/non unix account uid and gid allocation parameters.  The format of these
6969  parameters is:
6970
6971  [global]
6972
6973         idmap uid = 1000-1999
6974         idmap gid = 700-899
6975
6976  We only do simple parsing checks here.  The strings are parsed into useful
6977  structures in the idmap daemon code.
6978
6979 ***************************************************************************/
6980
6981 /* Some lp_ routines to return idmap [ug]id information */
6982
6983 static uid_t idmap_uid_low, idmap_uid_high;
6984 static gid_t idmap_gid_low, idmap_gid_high;
6985
6986 bool lp_idmap_uid(uid_t *low, uid_t *high)
6987 {
6988         if (idmap_uid_low == 0 || idmap_uid_high == 0)
6989                 return False;
6990
6991         if (low)
6992                 *low = idmap_uid_low;
6993
6994         if (high)
6995                 *high = idmap_uid_high;
6996
6997         return True;
6998 }
6999
7000 bool lp_idmap_gid(gid_t *low, gid_t *high)
7001 {
7002         if (idmap_gid_low == 0 || idmap_gid_high == 0)
7003                 return False;
7004
7005         if (low)
7006                 *low = idmap_gid_low;
7007
7008         if (high)
7009                 *high = idmap_gid_high;
7010
7011         return True;
7012 }
7013
7014 /* Do some simple checks on "idmap [ug]id" parameter values */
7015
7016 static bool handle_idmap_uid(int snum, const char *pszParmValue, char **ptr)
7017 {
7018         uint32 low, high;
7019
7020         if (sscanf(pszParmValue, "%u - %u", &low, &high) != 2 || high < low)
7021                 return False;
7022
7023         /* Parse OK */
7024
7025         string_set(ptr, pszParmValue);
7026
7027         idmap_uid_low = low;
7028         idmap_uid_high = high;
7029
7030         return True;
7031 }
7032
7033 static bool handle_idmap_gid(int snum, const char *pszParmValue, char **ptr)
7034 {
7035         uint32 low, high;
7036
7037         if (sscanf(pszParmValue, "%u - %u", &low, &high) != 2 || high < low)
7038                 return False;
7039
7040         /* Parse OK */
7041
7042         string_set(ptr, pszParmValue);
7043
7044         idmap_gid_low = low;
7045         idmap_gid_high = high;
7046
7047         return True;
7048 }
7049
7050 /***************************************************************************
7051  Handle the DEBUG level list.
7052 ***************************************************************************/
7053
7054 static bool handle_debug_list( int snum, const char *pszParmValueIn, char **ptr )
7055 {
7056         string_set(ptr, pszParmValueIn);
7057         return debug_parse_levels(pszParmValueIn);
7058 }
7059
7060 /***************************************************************************
7061  Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
7062 ***************************************************************************/
7063
7064 static const char *append_ldap_suffix( const char *str )
7065 {
7066         const char *suffix_string;
7067
7068
7069         suffix_string = talloc_asprintf(talloc_tos(), "%s,%s", str,
7070                                         Globals.szLdapSuffix );
7071         if ( !suffix_string ) {
7072                 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
7073                 return "";
7074         }
7075
7076         return suffix_string;
7077 }
7078
7079 const char *lp_ldap_machine_suffix(void)
7080 {
7081         if (Globals.szLdapMachineSuffix[0])
7082                 return append_ldap_suffix(Globals.szLdapMachineSuffix);
7083
7084         return lp_string(Globals.szLdapSuffix);
7085 }
7086
7087 const char *lp_ldap_user_suffix(void)
7088 {
7089         if (Globals.szLdapUserSuffix[0])
7090                 return append_ldap_suffix(Globals.szLdapUserSuffix);
7091
7092         return lp_string(Globals.szLdapSuffix);
7093 }
7094
7095 const char *lp_ldap_group_suffix(void)
7096 {
7097         if (Globals.szLdapGroupSuffix[0])
7098                 return append_ldap_suffix(Globals.szLdapGroupSuffix);
7099
7100         return lp_string(Globals.szLdapSuffix);
7101 }
7102
7103 const char *lp_ldap_idmap_suffix(void)
7104 {
7105         if (Globals.szLdapIdmapSuffix[0])
7106                 return append_ldap_suffix(Globals.szLdapIdmapSuffix);
7107
7108         return lp_string(Globals.szLdapSuffix);
7109 }
7110
7111 /****************************************************************************
7112  set the value for a P_ENUM
7113  ***************************************************************************/
7114
7115 static void lp_set_enum_parm( struct parm_struct *parm, const char *pszParmValue,
7116                               int *ptr )
7117 {
7118         int i;
7119
7120         for (i = 0; parm->enum_list[i].name; i++) {
7121                 if ( strequal(pszParmValue, parm->enum_list[i].name)) {
7122                         *ptr = parm->enum_list[i].value;
7123                         return;
7124                 }
7125         }
7126         DEBUG(0, ("WARNING: Ignoring invalid value '%s' for parameter '%s'\n",
7127                   pszParmValue, parm->label));
7128 }
7129
7130 /***************************************************************************
7131 ***************************************************************************/
7132
7133 static bool handle_printing(int snum, const char *pszParmValue, char **ptr)
7134 {
7135         static int parm_num = -1;
7136         struct service *s;
7137
7138         if ( parm_num == -1 )
7139                 parm_num = map_parameter( "printing" );
7140
7141         lp_set_enum_parm( &parm_table[parm_num], pszParmValue, (int*)ptr );
7142
7143         if ( snum < 0 )
7144                 s = &sDefault;
7145         else
7146                 s = ServicePtrs[snum];
7147
7148         init_printer_values( s );
7149
7150         return True;
7151 }
7152
7153
7154 /***************************************************************************
7155  Initialise a copymap.
7156 ***************************************************************************/
7157
7158 static void init_copymap(struct service *pservice)
7159 {
7160         int i;
7161         if (pservice->copymap) {
7162                 bitmap_free(pservice->copymap);
7163         }
7164         pservice->copymap = bitmap_allocate(NUMPARAMETERS);
7165         if (!pservice->copymap)
7166                 DEBUG(0,
7167                       ("Couldn't allocate copymap!! (size %d)\n",
7168                        (int)NUMPARAMETERS));
7169         else
7170                 for (i = 0; i < NUMPARAMETERS; i++)
7171                         bitmap_set(pservice->copymap, i);
7172 }
7173
7174 /***************************************************************************
7175  Return the local pointer to a parameter given the service number and the
7176  pointer into the default structure.
7177 ***************************************************************************/
7178
7179 void *lp_local_ptr(int snum, void *ptr)
7180 {
7181         return (void *)(((char *)ServicePtrs[snum]) + PTR_DIFF(ptr, &sDefault));
7182 }
7183
7184 /***************************************************************************
7185  Process a parameter for a particular service number. If snum < 0
7186  then assume we are in the globals.
7187 ***************************************************************************/
7188
7189 bool lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
7190 {
7191         int parmnum, i;
7192         void *parm_ptr = NULL;  /* where we are going to store the result */
7193         void *def_ptr = NULL;
7194         struct param_opt_struct *paramo, *data;
7195         bool not_added;
7196
7197         parmnum = map_parameter(pszParmName);
7198
7199         if (parmnum < 0) {
7200                 TALLOC_CTX *frame;
7201
7202                 if (strchr(pszParmName, ':') == NULL) {
7203                         DEBUG(0, ("Ignoring unknown parameter \"%s\"\n",
7204                                   pszParmName));
7205                         return (True);
7206                 }
7207
7208                 /*
7209                  * We've got a parametric option
7210                  */
7211
7212                 frame = talloc_stackframe();
7213
7214                 not_added = True;
7215                 data = (snum < 0)
7216                         ? Globals.param_opt : ServicePtrs[snum]->param_opt;
7217                 /* Traverse destination */
7218                 while (data) {
7219                         /* If we already have same option, override it */
7220                         if (strwicmp(data->key, pszParmName) == 0) {
7221                                 string_free(&data->value);
7222                                 TALLOC_FREE(data->list);
7223                                 data->value = SMB_STRDUP(pszParmValue);
7224                                 not_added = False;
7225                                 break;
7226                         }
7227                         data = data->next;
7228                 }
7229                 if (not_added) {
7230                         paramo = SMB_XMALLOC_P(struct param_opt_struct);
7231                         paramo->key = SMB_STRDUP(pszParmName);
7232                         paramo->value = SMB_STRDUP(pszParmValue);
7233                         paramo->list = NULL;
7234                         if (snum < 0) {
7235                                 DLIST_ADD(Globals.param_opt, paramo);
7236                         } else {
7237                                 DLIST_ADD(ServicePtrs[snum]->param_opt,
7238                                           paramo);
7239                         }
7240                 }
7241
7242                 TALLOC_FREE(frame);
7243                 return (True);
7244         }
7245
7246         if (parm_table[parmnum].flags & FLAG_DEPRECATED) {
7247                 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
7248                           pszParmName));
7249         }
7250
7251         def_ptr = parm_table[parmnum].ptr;
7252
7253         /* we might point at a service, the default service or a global */
7254         if (snum < 0) {
7255                 parm_ptr = def_ptr;
7256         } else {
7257                 if (parm_table[parmnum].p_class == P_GLOBAL) {
7258                         DEBUG(0,
7259                               ("Global parameter %s found in service section!\n",
7260                                pszParmName));
7261                         return (True);
7262                 }
7263                 parm_ptr =
7264                         ((char *)ServicePtrs[snum]) + PTR_DIFF(def_ptr,
7265                                                             &sDefault);
7266         }
7267
7268         if (snum >= 0) {
7269                 if (!ServicePtrs[snum]->copymap)
7270                         init_copymap(ServicePtrs[snum]);
7271
7272                 /* this handles the aliases - set the copymap for other entries with
7273                    the same data pointer */
7274                 for (i = 0; parm_table[i].label; i++)
7275                         if (parm_table[i].ptr == parm_table[parmnum].ptr)
7276                                 bitmap_clear(ServicePtrs[snum]->copymap, i);
7277         }
7278
7279         /* if it is a special case then go ahead */
7280         if (parm_table[parmnum].special) {
7281                 return parm_table[parmnum].special(snum, pszParmValue,
7282                                                    (char **)parm_ptr);
7283         }
7284
7285         /* now switch on the type of variable it is */
7286         switch (parm_table[parmnum].type)
7287         {
7288                 case P_BOOL:
7289                         *(bool *)parm_ptr = lp_bool(pszParmValue);
7290                         break;
7291
7292                 case P_BOOLREV:
7293                         *(bool *)parm_ptr = !lp_bool(pszParmValue);
7294                         break;
7295
7296                 case P_INTEGER:
7297                         *(int *)parm_ptr = lp_int(pszParmValue);
7298                         break;
7299
7300                 case P_CHAR:
7301                         *(char *)parm_ptr = *pszParmValue;
7302                         break;
7303
7304                 case P_OCTAL:
7305                         i = sscanf(pszParmValue, "%o", (int *)parm_ptr);
7306                         if ( i != 1 ) {
7307                             DEBUG ( 0, ("Invalid octal number %s\n", pszParmName ));
7308                         }
7309                         break;
7310
7311                 case P_LIST:
7312                         TALLOC_FREE(*((char ***)parm_ptr));
7313                         *(char ***)parm_ptr = str_list_make(
7314                                 talloc_autofree_context(), pszParmValue, NULL);
7315                         break;
7316
7317                 case P_STRING:
7318                         string_set((char **)parm_ptr, pszParmValue);
7319                         break;
7320
7321                 case P_USTRING:
7322                         string_set((char **)parm_ptr, pszParmValue);
7323                         strupper_m(*(char **)parm_ptr);
7324                         break;
7325
7326                 case P_ENUM:
7327                         lp_set_enum_parm( &parm_table[parmnum], pszParmValue, (int*)parm_ptr );
7328                         break;
7329                 case P_SEP:
7330                         break;
7331         }
7332
7333         return (True);
7334 }
7335
7336 /***************************************************************************
7337  Process a parameter.
7338 ***************************************************************************/
7339
7340 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
7341                          void *userdata)
7342 {
7343         if (!bInGlobalSection && bGlobalOnly)
7344                 return (True);
7345
7346         DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
7347
7348         return (lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
7349                                 pszParmName, pszParmValue));
7350 }
7351
7352 /***************************************************************************
7353  Print a parameter of the specified type.
7354 ***************************************************************************/
7355
7356 static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
7357 {
7358         int i;
7359         switch (p->type)
7360         {
7361                 case P_ENUM:
7362                         for (i = 0; p->enum_list[i].name; i++) {
7363                                 if (*(int *)ptr == p->enum_list[i].value) {
7364                                         fprintf(f, "%s",
7365                                                 p->enum_list[i].name);
7366                                         break;
7367                                 }
7368                         }
7369                         break;
7370
7371                 case P_BOOL:
7372                         fprintf(f, "%s", BOOLSTR(*(bool *)ptr));
7373                         break;
7374
7375                 case P_BOOLREV:
7376                         fprintf(f, "%s", BOOLSTR(!*(bool *)ptr));
7377                         break;
7378
7379                 case P_INTEGER:
7380                         fprintf(f, "%d", *(int *)ptr);
7381                         break;
7382
7383                 case P_CHAR:
7384                         fprintf(f, "%c", *(char *)ptr);
7385                         break;
7386
7387                 case P_OCTAL: {
7388                         char *o = octal_string(*(int *)ptr);
7389                         fprintf(f, "%s", o);
7390                         TALLOC_FREE(o);
7391                         break;
7392                 }
7393
7394                 case P_LIST:
7395                         if ((char ***)ptr && *(char ***)ptr) {
7396                                 char **list = *(char ***)ptr;
7397                                 for (; *list; list++) {
7398                                         /* surround strings with whitespace in double quotes */
7399                                         if ( strchr_m( *list, ' ' ) )
7400                                                 fprintf(f, "\"%s\"%s", *list, ((*(list+1))?", ":""));
7401                                         else
7402                                                 fprintf(f, "%s%s", *list, ((*(list+1))?", ":""));
7403                                 }
7404                         }
7405                         break;
7406
7407                 case P_STRING:
7408                 case P_USTRING:
7409                         if (*(char **)ptr) {
7410                                 fprintf(f, "%s", *(char **)ptr);
7411                         }
7412                         break;
7413                 case P_SEP:
7414                         break;
7415         }
7416 }
7417
7418 /***************************************************************************
7419  Check if two parameters are equal.
7420 ***************************************************************************/
7421
7422 static bool equal_parameter(parm_type type, void *ptr1, void *ptr2)
7423 {
7424         switch (type) {
7425                 case P_BOOL:
7426                 case P_BOOLREV:
7427                         return (*((bool *)ptr1) == *((bool *)ptr2));
7428
7429                 case P_INTEGER:
7430                 case P_ENUM:
7431                 case P_OCTAL:
7432                         return (*((int *)ptr1) == *((int *)ptr2));
7433
7434                 case P_CHAR:
7435                         return (*((char *)ptr1) == *((char *)ptr2));
7436
7437                 case P_LIST:
7438                         return str_list_compare(*(char ***)ptr1, *(char ***)ptr2);
7439
7440                 case P_STRING:
7441                 case P_USTRING:
7442                 {
7443                         char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
7444                         if (p1 && !*p1)
7445                                 p1 = NULL;
7446                         if (p2 && !*p2)
7447                                 p2 = NULL;
7448                         return (p1 == p2 || strequal(p1, p2));
7449                 }
7450                 case P_SEP:
7451                         break;
7452         }
7453         return (False);
7454 }
7455
7456 /***************************************************************************
7457  Initialize any local varients in the sDefault table.
7458 ***************************************************************************/
7459
7460 void init_locals(void)
7461 {
7462         /* None as yet. */
7463 }
7464
7465 /***************************************************************************
7466  Process a new section (service). At this stage all sections are services.
7467  Later we'll have special sections that permit server parameters to be set.
7468  Returns True on success, False on failure.
7469 ***************************************************************************/
7470
7471 static bool do_section(const char *pszSectionName, void *userdata)
7472 {
7473         bool bRetval;
7474         bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
7475                          (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
7476         bRetval = False;
7477
7478         /* if we were in a global section then do the local inits */
7479         if (bInGlobalSection && !isglobal)
7480                 init_locals();
7481
7482         /* if we've just struck a global section, note the fact. */
7483         bInGlobalSection = isglobal;
7484
7485         /* check for multiple global sections */
7486         if (bInGlobalSection) {
7487                 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
7488                 return (True);
7489         }
7490
7491         if (!bInGlobalSection && bGlobalOnly)
7492                 return (True);
7493
7494         /* if we have a current service, tidy it up before moving on */
7495         bRetval = True;
7496
7497         if (iServiceIndex >= 0)
7498                 bRetval = service_ok(iServiceIndex);
7499
7500         /* if all is still well, move to the next record in the services array */
7501         if (bRetval) {
7502                 /* We put this here to avoid an odd message order if messages are */
7503                 /* issued by the post-processing of a previous section. */
7504                 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
7505
7506                 if ((iServiceIndex = add_a_service(&sDefault, pszSectionName))
7507                     < 0) {
7508                         DEBUG(0, ("Failed to add a new service\n"));
7509                         return (False);
7510                 }
7511         }
7512
7513         return (bRetval);
7514 }
7515
7516
7517 /***************************************************************************
7518  Determine if a partcular base parameter is currentl set to the default value.
7519 ***************************************************************************/
7520
7521 static bool is_default(int i)
7522 {
7523         if (!defaults_saved)
7524                 return False;
7525         switch (parm_table[i].type) {
7526                 case P_LIST:
7527                         return str_list_compare (parm_table[i].def.lvalue,
7528                                                 *(char ***)parm_table[i].ptr);
7529                 case P_STRING:
7530                 case P_USTRING:
7531                         return strequal(parm_table[i].def.svalue,
7532                                         *(char **)parm_table[i].ptr);
7533                 case P_BOOL:
7534                 case P_BOOLREV:
7535                         return parm_table[i].def.bvalue ==
7536                                 *(bool *)parm_table[i].ptr;
7537                 case P_CHAR:
7538                         return parm_table[i].def.cvalue ==
7539                                 *(char *)parm_table[i].ptr;
7540                 case P_INTEGER:
7541                 case P_OCTAL:
7542                 case P_ENUM:
7543                         return parm_table[i].def.ivalue ==
7544                                 *(int *)parm_table[i].ptr;
7545                 case P_SEP:
7546                         break;
7547         }
7548         return False;
7549 }
7550
7551 /***************************************************************************
7552 Display the contents of the global structure.
7553 ***************************************************************************/
7554
7555 static void dump_globals(FILE *f)
7556 {
7557         int i;
7558         struct param_opt_struct *data;
7559
7560         fprintf(f, "[global]\n");
7561
7562         for (i = 0; parm_table[i].label; i++)
7563                 if (parm_table[i].p_class == P_GLOBAL &&
7564                     parm_table[i].ptr &&
7565                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
7566                         if (defaults_saved && is_default(i))
7567                                 continue;
7568                         fprintf(f, "\t%s = ", parm_table[i].label);
7569                         print_parameter(&parm_table[i], parm_table[i].ptr, f);
7570                         fprintf(f, "\n");
7571         }
7572         if (Globals.param_opt != NULL) {
7573                 data = Globals.param_opt;
7574                 while(data) {
7575                         fprintf(f, "\t%s = %s\n", data->key, data->value);
7576                         data = data->next;
7577                 }
7578         }
7579
7580 }
7581
7582 /***************************************************************************
7583  Return True if a local parameter is currently set to the global default.
7584 ***************************************************************************/
7585
7586 bool lp_is_default(int snum, struct parm_struct *parm)
7587 {
7588         int pdiff = PTR_DIFF(parm->ptr, &sDefault);
7589
7590         return equal_parameter(parm->type,
7591                                ((char *)ServicePtrs[snum]) + pdiff,
7592                                ((char *)&sDefault) + pdiff);
7593 }
7594
7595 /***************************************************************************
7596  Display the contents of a single services record.
7597 ***************************************************************************/
7598
7599 static void dump_a_service(struct service *pService, FILE * f)
7600 {
7601         int i;
7602         struct param_opt_struct *data;
7603
7604         if (pService != &sDefault)
7605                 fprintf(f, "[%s]\n", pService->szService);
7606
7607         for (i = 0; parm_table[i].label; i++) {
7608
7609                 if (parm_table[i].p_class == P_LOCAL &&
7610                     parm_table[i].ptr &&
7611                     (*parm_table[i].label != '-') &&
7612                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
7613                 {
7614
7615                         int pdiff = PTR_DIFF(parm_table[i].ptr, &sDefault);
7616
7617                         if (pService == &sDefault) {
7618                                 if (defaults_saved && is_default(i))
7619                                         continue;
7620                         } else {
7621                                 if (equal_parameter(parm_table[i].type,
7622                                                     ((char *)pService) +
7623                                                     pdiff,
7624                                                     ((char *)&sDefault) +
7625                                                     pdiff))
7626                                         continue;
7627                         }
7628
7629                         fprintf(f, "\t%s = ", parm_table[i].label);
7630                         print_parameter(&parm_table[i],
7631                                         ((char *)pService) + pdiff, f);
7632                         fprintf(f, "\n");
7633                 }
7634         }
7635
7636                 if (pService->param_opt != NULL) {
7637                         data = pService->param_opt;
7638                         while(data) {
7639                                 fprintf(f, "\t%s = %s\n", data->key, data->value);
7640                                 data = data->next;
7641                         }
7642                 }
7643 }
7644
7645 /***************************************************************************
7646  Display the contents of a parameter of a single services record.
7647 ***************************************************************************/
7648
7649 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
7650 {
7651         int i;
7652         bool result = False;
7653         parm_class p_class;
7654         unsigned flag = 0;
7655         fstring local_parm_name;
7656         char *parm_opt;
7657         const char *parm_opt_value;
7658
7659         /* check for parametrical option */
7660         fstrcpy( local_parm_name, parm_name);
7661         parm_opt = strchr( local_parm_name, ':');
7662
7663         if (parm_opt) {
7664                 *parm_opt = '\0';
7665                 parm_opt++;
7666                 if (strlen(parm_opt)) {
7667                         parm_opt_value = lp_parm_const_string( snum,
7668                                 local_parm_name, parm_opt, NULL);
7669                         if (parm_opt_value) {
7670                                 printf( "%s\n", parm_opt_value);
7671                                 result = True;
7672                         }
7673                 }
7674                 return result;
7675         }
7676
7677         /* check for a key and print the value */
7678         if (isGlobal) {
7679                 p_class = P_GLOBAL;
7680                 flag = FLAG_GLOBAL;
7681         } else
7682                 p_class = P_LOCAL;
7683
7684         for (i = 0; parm_table[i].label; i++) {
7685                 if (strwicmp(parm_table[i].label, parm_name) == 0 &&
7686                     (parm_table[i].p_class == p_class || parm_table[i].flags & flag) &&
7687                     parm_table[i].ptr &&
7688                     (*parm_table[i].label != '-') &&
7689                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
7690                 {
7691                         void *ptr;
7692
7693                         if (isGlobal) {
7694                                 ptr = parm_table[i].ptr;
7695                         } else {
7696                                 struct service *pService = ServicePtrs[snum];
7697                                 ptr = ((char *)pService) +
7698                                         PTR_DIFF(parm_table[i].ptr, &sDefault);
7699                         }
7700
7701                         print_parameter(&parm_table[i],
7702                                         ptr, f);
7703                         fprintf(f, "\n");
7704                         result = True;
7705                         break;
7706                 }
7707         }
7708
7709         return result;
7710 }
7711
7712 /***************************************************************************
7713  Return info about the requested parameter (given as a string).
7714  Return NULL when the string is not a valid parameter name.
7715 ***************************************************************************/
7716
7717 struct parm_struct *lp_get_parameter(const char *param_name)
7718 {
7719         int num = map_parameter(param_name);
7720
7721         if (num < 0) {
7722                 return NULL;
7723         }
7724
7725         return &parm_table[num];
7726 }
7727
7728 /***************************************************************************
7729  Return info about the next parameter in a service.
7730  snum==GLOBAL_SECTION_SNUM gives the globals.
7731  Return NULL when out of parameters.
7732 ***************************************************************************/
7733
7734 struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters)
7735 {
7736         if (snum < 0) {
7737                 /* do the globals */
7738                 for (; parm_table[*i].label; (*i)++) {
7739                         if (parm_table[*i].p_class == P_SEPARATOR)
7740                                 return &parm_table[(*i)++];
7741
7742                         if (!parm_table[*i].ptr
7743                             || (*parm_table[*i].label == '-'))
7744                                 continue;
7745
7746                         if ((*i) > 0
7747                             && (parm_table[*i].ptr ==
7748                                 parm_table[(*i) - 1].ptr))
7749                                 continue;
7750
7751                         if (is_default(*i) && !allparameters)
7752                                 continue;
7753
7754                         return &parm_table[(*i)++];
7755                 }
7756         } else {
7757                 struct service *pService = ServicePtrs[snum];
7758
7759                 for (; parm_table[*i].label; (*i)++) {
7760                         if (parm_table[*i].p_class == P_SEPARATOR)
7761                                 return &parm_table[(*i)++];
7762
7763                         if (parm_table[*i].p_class == P_LOCAL &&
7764                             parm_table[*i].ptr &&
7765                             (*parm_table[*i].label != '-') &&
7766                             ((*i) == 0 ||
7767                              (parm_table[*i].ptr !=
7768                               parm_table[(*i) - 1].ptr)))
7769                         {
7770                                 int pdiff =
7771                                         PTR_DIFF(parm_table[*i].ptr,
7772                                                  &sDefault);
7773
7774                                 if (allparameters ||
7775                                     !equal_parameter(parm_table[*i].type,
7776                                                      ((char *)pService) +
7777                                                      pdiff,
7778                                                      ((char *)&sDefault) +
7779                                                      pdiff))
7780                                 {
7781                                         return &parm_table[(*i)++];
7782                                 }
7783                         }
7784                 }
7785         }
7786
7787         return NULL;
7788 }
7789
7790
7791 #if 0
7792 /***************************************************************************
7793  Display the contents of a single copy structure.
7794 ***************************************************************************/
7795 static void dump_copy_map(bool *pcopymap)
7796 {
7797         int i;
7798         if (!pcopymap)
7799                 return;
7800
7801         printf("\n\tNon-Copied parameters:\n");
7802
7803         for (i = 0; parm_table[i].label; i++)
7804                 if (parm_table[i].p_class == P_LOCAL &&
7805                     parm_table[i].ptr && !pcopymap[i] &&
7806                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
7807                 {
7808                         printf("\t\t%s\n", parm_table[i].label);
7809                 }
7810 }
7811 #endif
7812
7813 /***************************************************************************
7814  Return TRUE if the passed service number is within range.
7815 ***************************************************************************/
7816
7817 bool lp_snum_ok(int iService)
7818 {
7819         return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
7820 }
7821
7822 /***************************************************************************
7823  Auto-load some home services.
7824 ***************************************************************************/
7825
7826 static void lp_add_auto_services(char *str)
7827 {
7828         char *s;
7829         char *p;
7830         int homes;
7831         char *saveptr;
7832
7833         if (!str)
7834                 return;
7835
7836         s = SMB_STRDUP(str);
7837         if (!s)
7838                 return;
7839
7840         homes = lp_servicenumber(HOMES_NAME);
7841
7842         for (p = strtok_r(s, LIST_SEP, &saveptr); p;
7843              p = strtok_r(NULL, LIST_SEP, &saveptr)) {
7844                 char *home;
7845
7846                 if (lp_servicenumber(p) >= 0)
7847                         continue;
7848
7849                 home = get_user_home_dir(talloc_tos(), p);
7850
7851                 if (home && homes >= 0)
7852                         lp_add_home(p, homes, p, home);
7853
7854                 TALLOC_FREE(home);
7855         }
7856         SAFE_FREE(s);
7857 }
7858
7859 /***************************************************************************
7860  Auto-load one printer.
7861 ***************************************************************************/
7862
7863 void lp_add_one_printer(const char *name, const char *comment, void *pdata)
7864 {
7865         int printers = lp_servicenumber(PRINTERS_NAME);
7866         int i;
7867
7868         if (lp_servicenumber(name) < 0) {
7869                 lp_add_printer(name, printers);
7870                 if ((i = lp_servicenumber(name)) >= 0) {
7871                         string_set(&ServicePtrs[i]->comment, comment);
7872                         ServicePtrs[i]->autoloaded = True;
7873                 }
7874         }
7875 }
7876
7877 /***************************************************************************
7878  Have we loaded a services file yet?
7879 ***************************************************************************/
7880
7881 bool lp_loaded(void)
7882 {
7883         return (bLoaded);
7884 }
7885
7886 /***************************************************************************
7887  Unload unused services.
7888 ***************************************************************************/
7889
7890 void lp_killunused(bool (*snumused) (int))
7891 {
7892         int i;
7893         for (i = 0; i < iNumServices; i++) {
7894                 if (!VALID(i))
7895                         continue;
7896
7897                 /* don't kill autoloaded or usershare services */
7898                 if ( ServicePtrs[i]->autoloaded ||
7899                                 ServicePtrs[i]->usershare == USERSHARE_VALID) {
7900                         continue;
7901                 }
7902
7903                 if (!snumused || !snumused(i)) {
7904                         free_service_byindex(i);
7905                 }
7906         }
7907 }
7908
7909 /**
7910  * Kill all except autoloaded and usershare services - convenience wrapper
7911  */
7912 void lp_kill_all_services(void)
7913 {
7914         lp_killunused(NULL);
7915 }
7916
7917 /***************************************************************************
7918  Unload a service.
7919 ***************************************************************************/
7920
7921 void lp_killservice(int iServiceIn)
7922 {
7923         if (VALID(iServiceIn)) {
7924                 free_service_byindex(iServiceIn);
7925         }
7926 }
7927
7928 /***************************************************************************
7929  Save the curent values of all global and sDefault parameters into the
7930  defaults union. This allows swat and testparm to show only the
7931  changed (ie. non-default) parameters.
7932 ***************************************************************************/
7933
7934 static void lp_save_defaults(void)
7935 {
7936         int i;
7937         for (i = 0; parm_table[i].label; i++) {
7938                 if (i > 0 && parm_table[i].ptr == parm_table[i - 1].ptr)
7939                         continue;
7940                 switch (parm_table[i].type) {
7941                         case P_LIST:
7942                                 str_list_copy(
7943                                         NULL, &(parm_table[i].def.lvalue),
7944                                         *(const char ***)parm_table[i].ptr);
7945                                 break;
7946                         case P_STRING:
7947                         case P_USTRING:
7948                                 if (parm_table[i].ptr) {
7949                                         parm_table[i].def.svalue = SMB_STRDUP(*(char **)parm_table[i].ptr);
7950                                 } else {
7951                                         parm_table[i].def.svalue = NULL;
7952                                 }
7953                                 break;
7954                         case P_BOOL:
7955                         case P_BOOLREV:
7956                                 parm_table[i].def.bvalue =
7957                                         *(bool *)parm_table[i].ptr;
7958                                 break;
7959                         case P_CHAR:
7960                                 parm_table[i].def.cvalue =
7961                                         *(char *)parm_table[i].ptr;
7962                                 break;
7963                         case P_INTEGER:
7964                         case P_OCTAL:
7965                         case P_ENUM:
7966                                 parm_table[i].def.ivalue =
7967                                         *(int *)parm_table[i].ptr;
7968                                 break;
7969                         case P_SEP:
7970                                 break;
7971                 }
7972         }
7973         defaults_saved = True;
7974 }
7975
7976 /*******************************************************************
7977  Set the server type we will announce as via nmbd.
7978 ********************************************************************/
7979
7980 static const struct srv_role_tab {
7981         uint32 role;
7982         const char *role_str;
7983 } srv_role_tab [] = {
7984         { ROLE_STANDALONE, "ROLE_STANDALONE" },
7985         { ROLE_DOMAIN_MEMBER, "ROLE_DOMAIN_MEMBER" },
7986         { ROLE_DOMAIN_BDC, "ROLE_DOMAIN_BDC" },
7987         { ROLE_DOMAIN_PDC, "ROLE_DOMAIN_PDC" },
7988         { 0, NULL }
7989 };
7990
7991 const char* server_role_str(uint32 role)
7992 {
7993         int i = 0;
7994         for (i=0; srv_role_tab[i].role_str; i++) {
7995                 if (role == srv_role_tab[i].role) {
7996                         return srv_role_tab[i].role_str;
7997                 }
7998         }
7999         return NULL;
8000 }
8001
8002 static void set_server_role(void)
8003 {
8004         server_role = ROLE_STANDALONE;
8005
8006         switch (lp_security()) {
8007                 case SEC_SHARE:
8008                         if (lp_domain_logons())
8009                                 DEBUG(0, ("Server's Role (logon server) conflicts with share-level security\n"));
8010                         break;
8011                 case SEC_SERVER:
8012                         if (lp_domain_logons())
8013                                 DEBUG(0, ("Server's Role (logon server) conflicts with server-level security\n"));
8014                         /* this used to be considered ROLE_DOMAIN_MEMBER but that's just wrong */
8015                         server_role = ROLE_STANDALONE;
8016                         break;
8017                 case SEC_DOMAIN:
8018                         if (lp_domain_logons()) {
8019                                 DEBUG(1, ("Server's Role (logon server) NOT ADVISED with domain-level security\n"));
8020                                 server_role = ROLE_DOMAIN_BDC;
8021                                 break;
8022                         }
8023                         server_role = ROLE_DOMAIN_MEMBER;
8024                         break;
8025                 case SEC_ADS:
8026                         if (lp_domain_logons()) {
8027                                 server_role = ROLE_DOMAIN_PDC;
8028                                 break;
8029                         }
8030                         server_role = ROLE_DOMAIN_MEMBER;
8031                         break;
8032                 case SEC_USER:
8033                         if (lp_domain_logons()) {
8034
8035                                 if (Globals.iDomainMaster) /* auto or yes */
8036                                         server_role = ROLE_DOMAIN_PDC;
8037                                 else
8038                                         server_role = ROLE_DOMAIN_BDC;
8039                         }
8040                         break;
8041                 default:
8042                         DEBUG(0, ("Server's Role undefined due to unknown security mode\n"));
8043                         break;
8044         }
8045
8046         DEBUG(10, ("set_server_role: role = %s\n", server_role_str(server_role)));
8047 }
8048
8049 /***********************************************************
8050  If we should send plaintext/LANMAN passwords in the clinet
8051 ************************************************************/
8052
8053 static void set_allowed_client_auth(void)
8054 {
8055         if (Globals.bClientNTLMv2Auth) {
8056                 Globals.bClientLanManAuth = False;
8057         }
8058         if (!Globals.bClientLanManAuth) {
8059                 Globals.bClientPlaintextAuth = False;
8060         }
8061 }
8062
8063 /***************************************************************************
8064  JRA.
8065  The following code allows smbd to read a user defined share file.
8066  Yes, this is my intent. Yes, I'm comfortable with that...
8067
8068  THE FOLLOWING IS SECURITY CRITICAL CODE.
8069
8070  It washes your clothes, it cleans your house, it guards you while you sleep...
8071  Do not f%^k with it....
8072 ***************************************************************************/
8073
8074 #define MAX_USERSHARE_FILE_SIZE (10*1024)
8075
8076 /***************************************************************************
8077  Check allowed stat state of a usershare file.
8078  Ensure we print out who is dicking with us so the admin can
8079  get their sorry ass fired.
8080 ***************************************************************************/
8081
8082 static bool check_usershare_stat(const char *fname, SMB_STRUCT_STAT *psbuf)
8083 {
8084         if (!S_ISREG(psbuf->st_mode)) {
8085                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
8086                         "not a regular file\n",
8087                         fname, (unsigned int)psbuf->st_uid ));
8088                 return False;
8089         }
8090
8091         /* Ensure this doesn't have the other write bit set. */
8092         if (psbuf->st_mode & S_IWOTH) {
8093                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
8094                         "public write. Refusing to allow as a usershare file.\n",
8095                         fname, (unsigned int)psbuf->st_uid ));
8096                 return False;
8097         }
8098
8099         /* Should be 10k or less. */
8100         if (psbuf->st_size > MAX_USERSHARE_FILE_SIZE) {
8101                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
8102                         "too large (%u) to be a user share file.\n",
8103                         fname, (unsigned int)psbuf->st_uid,
8104                         (unsigned int)psbuf->st_size ));
8105                 return False;
8106         }
8107
8108         return True;
8109 }
8110
8111 /***************************************************************************
8112  Parse the contents of a usershare file.
8113 ***************************************************************************/
8114
8115 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
8116                         SMB_STRUCT_STAT *psbuf,
8117                         const char *servicename,
8118                         int snum,
8119                         char **lines,
8120                         int numlines,
8121                         char **pp_sharepath,
8122                         char **pp_comment,
8123                         SEC_DESC **ppsd,
8124                         bool *pallow_guest)
8125 {
8126         const char **prefixallowlist = lp_usershare_prefix_allow_list();
8127         const char **prefixdenylist = lp_usershare_prefix_deny_list();
8128         int us_vers;
8129         SMB_STRUCT_DIR *dp;
8130         SMB_STRUCT_STAT sbuf;
8131         char *sharepath = NULL;
8132         char *comment = NULL;
8133
8134         *pp_sharepath = NULL;
8135         *pp_comment = NULL;
8136
8137         *pallow_guest = False;
8138
8139         if (numlines < 4) {
8140                 return USERSHARE_MALFORMED_FILE;
8141         }
8142
8143         if (strcmp(lines[0], "#VERSION 1") == 0) {
8144                 us_vers = 1;
8145         } else if (strcmp(lines[0], "#VERSION 2") == 0) {
8146                 us_vers = 2;
8147                 if (numlines < 5) {
8148                         return USERSHARE_MALFORMED_FILE;
8149                 }
8150         } else {
8151                 return USERSHARE_BAD_VERSION;
8152         }
8153
8154         if (strncmp(lines[1], "path=", 5) != 0) {
8155                 return USERSHARE_MALFORMED_PATH;
8156         }
8157
8158         sharepath = talloc_strdup(ctx, &lines[1][5]);
8159         if (!sharepath) {
8160                 return USERSHARE_POSIX_ERR;
8161         }
8162         trim_string(sharepath, " ", " ");
8163
8164         if (strncmp(lines[2], "comment=", 8) != 0) {
8165                 return USERSHARE_MALFORMED_COMMENT_DEF;
8166         }
8167
8168         comment = talloc_strdup(ctx, &lines[2][8]);
8169         if (!comment) {
8170                 return USERSHARE_POSIX_ERR;
8171         }
8172         trim_string(comment, " ", " ");
8173         trim_char(comment, '"', '"');
8174
8175         if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
8176                 return USERSHARE_MALFORMED_ACL_DEF;
8177         }
8178
8179         if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
8180                 return USERSHARE_ACL_ERR;
8181         }
8182
8183         if (us_vers == 2) {
8184                 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
8185                         return USERSHARE_MALFORMED_ACL_DEF;
8186                 }
8187                 if (lines[4][9] == 'y') {
8188                         *pallow_guest = True;
8189                 }
8190         }
8191
8192         if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->szPath) == 0)) {
8193                 /* Path didn't change, no checks needed. */
8194                 *pp_sharepath = sharepath;
8195                 *pp_comment = comment;
8196                 return USERSHARE_OK;
8197         }
8198
8199         /* The path *must* be absolute. */
8200         if (sharepath[0] != '/') {
8201                 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
8202                         servicename, sharepath));
8203                 return USERSHARE_PATH_NOT_ABSOLUTE;
8204         }
8205
8206         /* If there is a usershare prefix deny list ensure one of these paths
8207            doesn't match the start of the user given path. */
8208         if (prefixdenylist) {
8209                 int i;
8210                 for ( i=0; prefixdenylist[i]; i++ ) {
8211                         DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
8212                                 servicename, i, prefixdenylist[i], sharepath ));
8213                         if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
8214                                 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
8215                                         "usershare prefix deny list entries.\n",
8216                                         servicename, sharepath));
8217                                 return USERSHARE_PATH_IS_DENIED;
8218                         }
8219                 }
8220         }
8221
8222         /* If there is a usershare prefix allow list ensure one of these paths
8223            does match the start of the user given path. */
8224
8225         if (prefixallowlist) {
8226                 int i;
8227                 for ( i=0; prefixallowlist[i]; i++ ) {
8228                         DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
8229                                 servicename, i, prefixallowlist[i], sharepath ));
8230                         if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
8231                                 break;
8232                         }
8233                 }
8234                 if (prefixallowlist[i] == NULL) {
8235                         DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
8236                                 "usershare prefix allow list entries.\n",
8237                                 servicename, sharepath));
8238                         return USERSHARE_PATH_NOT_ALLOWED;
8239                 }
8240         }
8241
8242         /* Ensure this is pointing to a directory. */
8243         dp = sys_opendir(sharepath);
8244
8245         if (!dp) {
8246                 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
8247                         servicename, sharepath));
8248                 return USERSHARE_PATH_NOT_DIRECTORY;
8249         }
8250
8251         /* Ensure the owner of the usershare file has permission to share
8252            this directory. */
8253
8254         if (sys_stat(sharepath, &sbuf) == -1) {
8255                 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
8256                         servicename, sharepath, strerror(errno) ));
8257                 sys_closedir(dp);
8258                 return USERSHARE_POSIX_ERR;
8259         }
8260
8261         sys_closedir(dp);
8262
8263         if (!S_ISDIR(sbuf.st_mode)) {
8264                 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
8265                         servicename, sharepath ));
8266                 return USERSHARE_PATH_NOT_DIRECTORY;
8267         }
8268
8269         /* Check if sharing is restricted to owner-only. */
8270         /* psbuf is the stat of the usershare definition file,
8271            sbuf is the stat of the target directory to be shared. */
8272
8273         if (lp_usershare_owner_only()) {
8274                 /* root can share anything. */
8275                 if ((psbuf->st_uid != 0) && (sbuf.st_uid != psbuf->st_uid)) {
8276                         return USERSHARE_PATH_NOT_ALLOWED;
8277                 }
8278         }
8279
8280         *pp_sharepath = sharepath;
8281         *pp_comment = comment;
8282         return USERSHARE_OK;
8283 }
8284
8285 /***************************************************************************
8286  Deal with a usershare file.
8287  Returns:
8288         >= 0 - snum
8289         -1 - Bad name, invalid contents.
8290            - service name already existed and not a usershare, problem
8291             with permissions to share directory etc.
8292 ***************************************************************************/
8293
8294 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
8295 {
8296         SMB_STRUCT_STAT sbuf;
8297         SMB_STRUCT_STAT lsbuf;
8298         char *fname = NULL;
8299         char *sharepath = NULL;
8300         char *comment = NULL;
8301         fstring service_name;
8302         char **lines = NULL;
8303         int numlines = 0;
8304         int fd = -1;
8305         int iService = -1;
8306         TALLOC_CTX *ctx = NULL;
8307         SEC_DESC *psd = NULL;
8308         bool guest_ok = False;
8309
8310         /* Ensure share name doesn't contain invalid characters. */
8311         if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
8312                 DEBUG(0,("process_usershare_file: share name %s contains "
8313                         "invalid characters (any of %s)\n",
8314                         file_name, INVALID_SHARENAME_CHARS ));
8315                 return -1;
8316         }
8317
8318         fstrcpy(service_name, file_name);
8319
8320         if (asprintf(&fname, "%s/%s", dir_name, file_name) < 0) {
8321         }
8322
8323         /* Minimize the race condition by doing an lstat before we
8324            open and fstat. Ensure this isn't a symlink link. */
8325
8326         if (sys_lstat(fname, &lsbuf) != 0) {
8327                 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
8328                         fname, strerror(errno) ));
8329                 SAFE_FREE(fname);
8330                 return -1;
8331         }
8332
8333         /* This must be a regular file, not a symlink, directory or
8334            other strange filetype. */
8335         if (!check_usershare_stat(fname, &lsbuf)) {
8336                 SAFE_FREE(fname);
8337                 return -1;
8338         }
8339
8340         {
8341                 char *canon_name = canonicalize_servicename(service_name);
8342                 TDB_DATA data = dbwrap_fetch_bystring(
8343                         ServiceHash, canon_name, canon_name);
8344
8345                 iService = -1;
8346
8347                 if ((data.dptr != NULL) && (data.dsize == sizeof(iService))) {
8348                         iService = *(int *)data.dptr;
8349                 }
8350                 TALLOC_FREE(canon_name);
8351         }
8352
8353         if (iService != -1 && ServicePtrs[iService]->usershare_last_mod == lsbuf.st_mtime) {
8354                 /* Nothing changed - Mark valid and return. */
8355                 DEBUG(10,("process_usershare_file: service %s not changed.\n",
8356                         service_name ));
8357                 ServicePtrs[iService]->usershare = USERSHARE_VALID;
8358                 SAFE_FREE(fname);
8359                 return iService;
8360         }
8361
8362         /* Try and open the file read only - no symlinks allowed. */
8363 #ifdef O_NOFOLLOW
8364         fd = sys_open(fname, O_RDONLY|O_NOFOLLOW, 0);
8365 #else
8366         fd = sys_open(fname, O_RDONLY, 0);
8367 #endif
8368
8369         if (fd == -1) {
8370                 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
8371                         fname, strerror(errno) ));
8372                 SAFE_FREE(fname);
8373                 return -1;
8374         }
8375
8376         /* Now fstat to be *SURE* it's a regular file. */
8377         if (sys_fstat(fd, &sbuf) != 0) {
8378                 close(fd);
8379                 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
8380                         fname, strerror(errno) ));
8381                 SAFE_FREE(fname);
8382                 return -1;
8383         }
8384
8385         /* Is it the same dev/inode as was lstated ? */
8386         if (lsbuf.st_dev != sbuf.st_dev || lsbuf.st_ino != sbuf.st_ino) {
8387                 close(fd);
8388                 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
8389                         "Symlink spoofing going on ?\n", fname ));
8390                 SAFE_FREE(fname);
8391                 return -1;
8392         }
8393
8394         /* This must be a regular file, not a symlink, directory or
8395            other strange filetype. */
8396         if (!check_usershare_stat(fname, &sbuf)) {
8397                 SAFE_FREE(fname);
8398                 return -1;
8399         }
8400
8401         lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE);
8402
8403         close(fd);
8404         if (lines == NULL) {
8405                 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
8406                         fname, (unsigned int)sbuf.st_uid ));
8407                 SAFE_FREE(fname);
8408                 return -1;
8409         }
8410
8411         SAFE_FREE(fname);
8412
8413         /* Should we allow printers to be shared... ? */
8414         ctx = talloc_init("usershare_sd_xctx");
8415         if (!ctx) {
8416                 file_lines_free(lines);
8417                 return 1;
8418         }
8419
8420         if (parse_usershare_file(ctx, &sbuf, service_name,
8421                         iService, lines, numlines, &sharepath,
8422                         &comment, &psd, &guest_ok) != USERSHARE_OK) {
8423                 talloc_destroy(ctx);
8424                 file_lines_free(lines);
8425                 return -1;
8426         }
8427
8428         file_lines_free(lines);
8429
8430         /* Everything ok - add the service possibly using a template. */
8431         if (iService < 0) {
8432                 const struct service *sp = &sDefault;
8433                 if (snum_template != -1) {
8434                         sp = ServicePtrs[snum_template];
8435                 }
8436
8437                 if ((iService = add_a_service(sp, service_name)) < 0) {
8438                         DEBUG(0, ("process_usershare_file: Failed to add "
8439                                 "new service %s\n", service_name));
8440                         talloc_destroy(ctx);
8441                         return -1;
8442                 }
8443
8444                 /* Read only is controlled by usershare ACL below. */
8445                 ServicePtrs[iService]->bRead_only = False;
8446         }
8447
8448         /* Write the ACL of the new/modified share. */
8449         if (!set_share_security(service_name, psd)) {
8450                  DEBUG(0, ("process_usershare_file: Failed to set share "
8451                         "security for user share %s\n",
8452                         service_name ));
8453                 lp_remove_service(iService);
8454                 talloc_destroy(ctx);
8455                 return -1;
8456         }
8457
8458         /* If from a template it may be marked invalid. */
8459         ServicePtrs[iService]->valid = True;
8460
8461         /* Set the service as a valid usershare. */
8462         ServicePtrs[iService]->usershare = USERSHARE_VALID;
8463
8464         /* Set guest access. */
8465         if (lp_usershare_allow_guests()) {
8466                 ServicePtrs[iService]->bGuest_ok = guest_ok;
8467         }
8468
8469         /* And note when it was loaded. */
8470         ServicePtrs[iService]->usershare_last_mod = sbuf.st_mtime;
8471         string_set(&ServicePtrs[iService]->szPath, sharepath);
8472         string_set(&ServicePtrs[iService]->comment, comment);
8473
8474         talloc_destroy(ctx);
8475
8476         return iService;
8477 }
8478
8479 /***************************************************************************
8480  Checks if a usershare entry has been modified since last load.
8481 ***************************************************************************/
8482
8483 static bool usershare_exists(int iService, time_t *last_mod)
8484 {
8485         SMB_STRUCT_STAT lsbuf;
8486         const char *usersharepath = Globals.szUsersharePath;
8487         char *fname;
8488
8489         if (asprintf(&fname, "%s/%s",
8490                                 usersharepath,
8491                                 ServicePtrs[iService]->szService) < 0) {
8492                 return false;
8493         }
8494
8495         if (sys_lstat(fname, &lsbuf) != 0) {
8496                 SAFE_FREE(fname);
8497                 return false;
8498         }
8499
8500         if (!S_ISREG(lsbuf.st_mode)) {
8501                 SAFE_FREE(fname);
8502                 return false;
8503         }
8504
8505         SAFE_FREE(fname);
8506         *last_mod = lsbuf.st_mtime;
8507         return true;
8508 }
8509
8510 /***************************************************************************
8511  Load a usershare service by name. Returns a valid servicenumber or -1.
8512 ***************************************************************************/
8513
8514 int load_usershare_service(const char *servicename)
8515 {
8516         SMB_STRUCT_STAT sbuf;
8517         const char *usersharepath = Globals.szUsersharePath;
8518         int max_user_shares = Globals.iUsershareMaxShares;
8519         int snum_template = -1;
8520
8521         if (*usersharepath == 0 ||  max_user_shares == 0) {
8522                 return -1;
8523         }
8524
8525         if (sys_stat(usersharepath, &sbuf) != 0) {
8526                 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
8527                         usersharepath, strerror(errno) ));
8528                 return -1;
8529         }
8530
8531         if (!S_ISDIR(sbuf.st_mode)) {
8532                 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
8533                         usersharepath ));
8534                 return -1;
8535         }
8536
8537         /*
8538          * This directory must be owned by root, and have the 't' bit set.
8539          * It also must not be writable by "other".
8540          */
8541
8542 #ifdef S_ISVTX
8543         if (sbuf.st_uid != 0 || !(sbuf.st_mode & S_ISVTX) || (sbuf.st_mode & S_IWOTH)) {
8544 #else
8545         if (sbuf.st_uid != 0 || (sbuf.st_mode & S_IWOTH)) {
8546 #endif
8547                 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
8548                         "or does not have the sticky bit 't' set or is writable by anyone.\n",
8549                         usersharepath ));
8550                 return -1;
8551         }
8552
8553         /* Ensure the template share exists if it's set. */
8554         if (Globals.szUsershareTemplateShare[0]) {
8555                 /* We can't use lp_servicenumber here as we are recommending that
8556                    template shares have -valid=False set. */
8557                 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
8558                         if (ServicePtrs[snum_template]->szService &&
8559                                         strequal(ServicePtrs[snum_template]->szService,
8560                                                 Globals.szUsershareTemplateShare)) {
8561                                 break;
8562                         }
8563                 }
8564
8565                 if (snum_template == -1) {
8566                         DEBUG(0,("load_usershare_service: usershare template share %s "
8567                                 "does not exist.\n",
8568                                 Globals.szUsershareTemplateShare ));
8569                         return -1;
8570                 }
8571         }
8572
8573         return process_usershare_file(usersharepath, servicename, snum_template);
8574 }
8575
8576 /***************************************************************************
8577  Load all user defined shares from the user share directory.
8578  We only do this if we're enumerating the share list.
8579  This is the function that can delete usershares that have
8580  been removed.
8581 ***************************************************************************/
8582
8583 int load_usershare_shares(void)
8584 {
8585         SMB_STRUCT_DIR *dp;
8586         SMB_STRUCT_STAT sbuf;
8587         SMB_STRUCT_DIRENT *de;
8588         int num_usershares = 0;
8589         int max_user_shares = Globals.iUsershareMaxShares;
8590         unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
8591         unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
8592         unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
8593         int iService;
8594         int snum_template = -1;
8595         const char *usersharepath = Globals.szUsersharePath;
8596         int ret = lp_numservices();
8597
8598         if (max_user_shares == 0 || *usersharepath == '\0') {
8599                 return lp_numservices();
8600         }
8601
8602         if (sys_stat(usersharepath, &sbuf) != 0) {
8603                 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
8604                         usersharepath, strerror(errno) ));
8605                 return ret;
8606         }
8607
8608         /*
8609          * This directory must be owned by root, and have the 't' bit set.
8610          * It also must not be writable by "other".
8611          */
8612
8613 #ifdef S_ISVTX
8614         if (sbuf.st_uid != 0 || !(sbuf.st_mode & S_ISVTX) || (sbuf.st_mode & S_IWOTH)) {
8615 #else
8616         if (sbuf.st_uid != 0 || (sbuf.st_mode & S_IWOTH)) {
8617 #endif
8618                 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
8619                         "or does not have the sticky bit 't' set or is writable by anyone.\n",
8620                         usersharepath ));
8621                 return ret;
8622         }
8623
8624         /* Ensure the template share exists if it's set. */
8625         if (Globals.szUsershareTemplateShare[0]) {
8626                 /* We can't use lp_servicenumber here as we are recommending that
8627                    template shares have -valid=False set. */
8628                 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
8629                         if (ServicePtrs[snum_template]->szService &&
8630                                         strequal(ServicePtrs[snum_template]->szService,
8631                                                 Globals.szUsershareTemplateShare)) {
8632                                 break;
8633                         }
8634                 }
8635
8636                 if (snum_template == -1) {
8637                         DEBUG(0,("load_usershare_shares: usershare template share %s "
8638                                 "does not exist.\n",
8639                                 Globals.szUsershareTemplateShare ));
8640                         return ret;
8641                 }
8642         }
8643
8644         /* Mark all existing usershares as pending delete. */
8645         for (iService = iNumServices - 1; iService >= 0; iService--) {
8646                 if (VALID(iService) && ServicePtrs[iService]->usershare) {
8647                         ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
8648                 }
8649         }
8650
8651         dp = sys_opendir(usersharepath);
8652         if (!dp) {
8653                 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
8654                         usersharepath, strerror(errno) ));
8655                 return ret;
8656         }
8657
8658         for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
8659                         (de = sys_readdir(dp));
8660                         num_dir_entries++ ) {
8661                 int r;
8662                 const char *n = de->d_name;
8663
8664                 /* Ignore . and .. */
8665                 if (*n == '.') {
8666                         if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
8667                                 continue;
8668                         }
8669                 }
8670
8671                 if (n[0] == ':') {
8672                         /* Temporary file used when creating a share. */
8673                         num_tmp_dir_entries++;
8674                 }
8675
8676                 /* Allow 20% tmp entries. */
8677                 if (num_tmp_dir_entries > allowed_tmp_entries) {
8678                         DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
8679                                 "in directory %s\n",
8680                                 num_tmp_dir_entries, usersharepath));
8681                         break;
8682                 }
8683
8684                 r = process_usershare_file(usersharepath, n, snum_template);
8685                 if (r == 0) {
8686                         /* Update the services count. */
8687                         num_usershares++;
8688                         if (num_usershares >= max_user_shares) {
8689                                 DEBUG(0,("load_usershare_shares: max user shares reached "
8690                                         "on file %s in directory %s\n",
8691                                         n, usersharepath ));
8692                                 break;
8693                         }
8694                 } else if (r == -1) {
8695                         num_bad_dir_entries++;
8696                 }
8697
8698                 /* Allow 20% bad entries. */
8699                 if (num_bad_dir_entries > allowed_bad_entries) {
8700                         DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
8701                                 "in directory %s\n",
8702                                 num_bad_dir_entries, usersharepath));
8703                         break;
8704                 }
8705
8706                 /* Allow 20% bad entries. */
8707                 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
8708                         DEBUG(0,("load_usershare_shares: too many total entries (%u) "
8709                         "in directory %s\n",
8710                         num_dir_entries, usersharepath));
8711                         break;
8712                 }
8713         }
8714
8715         sys_closedir(dp);
8716
8717         /* Sweep through and delete any non-refreshed usershares that are
8718            not currently in use. */
8719         for (iService = iNumServices - 1; iService >= 0; iService--) {
8720                 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
8721                         if (conn_snum_used(iService)) {
8722                                 continue;
8723                         }
8724                         /* Remove from the share ACL db. */
8725                         DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
8726                                 lp_servicename(iService) ));
8727                         delete_share_security(lp_servicename(iService));
8728                         free_service_byindex(iService);
8729                 }
8730         }
8731
8732         return lp_numservices();
8733 }
8734
8735 /********************************************************
8736  Destroy global resources allocated in this file
8737 ********************************************************/
8738
8739 void gfree_loadparm(void)
8740 {
8741         struct file_lists *f;
8742         struct file_lists *next;
8743         int i;
8744
8745         /* Free the file lists */
8746
8747         f = file_lists;
8748         while( f ) {
8749                 next = f->next;
8750                 SAFE_FREE( f->name );
8751                 SAFE_FREE( f->subfname );
8752                 SAFE_FREE( f );
8753                 f = next;
8754         }
8755         file_lists = NULL;
8756
8757         /* Free resources allocated to services */
8758
8759         for ( i = 0; i < iNumServices; i++ ) {
8760                 if ( VALID(i) ) {
8761                         free_service_byindex(i);
8762                 }
8763         }
8764
8765         SAFE_FREE( ServicePtrs );
8766         iNumServices = 0;
8767
8768         /* Now release all resources allocated to global
8769            parameters and the default service */
8770
8771         for (i = 0; parm_table[i].label; i++)
8772         {
8773                 if ( parm_table[i].type == P_STRING
8774                         || parm_table[i].type == P_USTRING )
8775                 {
8776                         string_free( (char**)parm_table[i].ptr );
8777                 }
8778                 else if (parm_table[i].type == P_LIST) {
8779                         TALLOC_FREE( *((char***)parm_table[i].ptr) );
8780                 }
8781         }
8782 }
8783
8784
8785 /***************************************************************************
8786  Allow client apps to specify that they are a client
8787 ***************************************************************************/
8788 void lp_set_in_client(bool b)
8789 {
8790     in_client = b;
8791 }
8792
8793
8794 /***************************************************************************
8795  Determine if we're running in a client app
8796 ***************************************************************************/
8797 bool lp_is_in_client(void)
8798 {
8799     return in_client;
8800 }
8801
8802
8803
8804
8805 /***************************************************************************
8806  Load the services array from the services file. Return True on success,
8807  False on failure.
8808 ***************************************************************************/
8809
8810 bool lp_load_ex(const char *pszFname,
8811                 bool global_only,
8812                 bool save_defaults,
8813                 bool add_ipc,
8814                 bool initialize_globals,
8815                 bool allow_include_registry,
8816                 bool allow_registry_shares)
8817 {
8818         char *n2 = NULL;
8819         bool bRetval;
8820         struct param_opt_struct *data, *pdata;
8821
8822         bRetval = False;
8823
8824         DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
8825
8826         bInGlobalSection = True;
8827         bGlobalOnly = global_only;
8828         bAllowIncludeRegistry = allow_include_registry;
8829
8830         init_globals(! initialize_globals);
8831         debug_init();
8832
8833         if (save_defaults) {
8834                 init_locals();
8835                 lp_save_defaults();
8836         }
8837
8838         /* We get sections first, so have to start 'behind' to make up */
8839         iServiceIndex = -1;
8840
8841         if (Globals.param_opt != NULL) {
8842                 data = Globals.param_opt;
8843                 while (data) {
8844                         string_free(&data->key);
8845                         string_free(&data->value);
8846                         TALLOC_FREE(data->list);
8847                         pdata = data->next;
8848                         SAFE_FREE(data);
8849                         data = pdata;
8850                 }
8851                 Globals.param_opt = NULL;
8852         }
8853
8854         if (lp_config_backend_is_file()) {
8855                 n2 = alloc_sub_basic(get_current_username(),
8856                                         current_user_info.domain,
8857                                         pszFname);
8858                 if (!n2) {
8859                         smb_panic("lp_load_ex: out of memory");
8860                 }
8861
8862                 add_to_file_list(pszFname, n2);
8863
8864                 bRetval = pm_process(n2, do_section, do_parameter, NULL);
8865                 SAFE_FREE(n2);
8866
8867                 /* finish up the last section */
8868                 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
8869                 if (bRetval) {
8870                         if (iServiceIndex >= 0) {
8871                                 bRetval = service_ok(iServiceIndex);
8872                         }
8873                 }
8874
8875                 if (lp_config_backend_is_registry()) {
8876                         /* config backend changed to registry in config file */
8877                         /*
8878                          * We need to use this extra global variable here to
8879                          * survive restart: init_globals uses this as a default
8880                          * for ConfigBackend. Otherwise, init_globals would
8881                          *  send us into an endless loop here.
8882                          */
8883                         config_backend = CONFIG_BACKEND_REGISTRY;
8884                         /* start over */
8885                         DEBUG(1, ("lp_load_ex: changing to config backend "
8886                                   "registry\n"));
8887                         init_globals(false);
8888                         lp_kill_all_services();
8889                         return lp_load_ex(pszFname, global_only, save_defaults,
8890                                           add_ipc, initialize_globals,
8891                                           allow_include_registry,
8892                                           allow_registry_shares);
8893                 }
8894         } else if (lp_config_backend_is_registry()) {
8895                 bRetval = process_registry_globals();
8896         } else {
8897                 DEBUG(0, ("Illegal config  backend given: %d\n",
8898                           lp_config_backend()));
8899                 bRetval = false;
8900         }
8901
8902         if (bRetval && lp_registry_shares() && allow_registry_shares) {
8903                 bRetval = process_registry_shares();
8904         }
8905
8906         lp_add_auto_services(lp_auto_services());
8907
8908         if (add_ipc) {
8909                 /* When 'restrict anonymous = 2' guest connections to ipc$
8910                    are denied */
8911                 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
8912                 if ( lp_enable_asu_support() ) {
8913                         lp_add_ipc("ADMIN$", false);
8914                 }
8915         }
8916
8917         set_server_role();
8918         set_default_server_announce_type();
8919         set_allowed_client_auth();
8920
8921         bLoaded = True;
8922
8923         /* Now we check bWINSsupport and set szWINSserver to 127.0.0.1 */
8924         /* if bWINSsupport is true and we are in the client            */
8925         if (lp_is_in_client() && Globals.bWINSsupport) {
8926                 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
8927         }
8928
8929         init_iconv();
8930
8931         bAllowIncludeRegistry = true;
8932
8933         return (bRetval);
8934 }
8935
8936 bool lp_load(const char *pszFname,
8937              bool global_only,
8938              bool save_defaults,
8939              bool add_ipc,
8940              bool initialize_globals)
8941 {
8942         return lp_load_ex(pszFname,
8943                           global_only,
8944                           save_defaults,
8945                           add_ipc,
8946                           initialize_globals,
8947                           true, false);
8948 }
8949
8950 bool lp_load_initial_only(const char *pszFname)
8951 {
8952         return lp_load_ex(pszFname,
8953                           true,
8954                           false,
8955                           false,
8956                           true,
8957                           false,
8958                           false);
8959 }
8960
8961 bool lp_load_with_registry_shares(const char *pszFname,
8962                                   bool global_only,
8963                                   bool save_defaults,
8964                                   bool add_ipc,
8965                                   bool initialize_globals)
8966 {
8967         return lp_load_ex(pszFname,
8968                           global_only,
8969                           save_defaults,
8970                           add_ipc,
8971                           initialize_globals,
8972                           true,
8973                           true);
8974 }
8975
8976 /***************************************************************************
8977  Return the max number of services.
8978 ***************************************************************************/
8979
8980 int lp_numservices(void)
8981 {
8982         return (iNumServices);
8983 }
8984
8985 /***************************************************************************
8986 Display the contents of the services array in human-readable form.
8987 ***************************************************************************/
8988
8989 void lp_dump(FILE *f, bool show_defaults, int maxtoprint)
8990 {
8991         int iService;
8992
8993         if (show_defaults)
8994                 defaults_saved = False;
8995
8996         dump_globals(f);
8997
8998         dump_a_service(&sDefault, f);
8999
9000         for (iService = 0; iService < maxtoprint; iService++) {
9001                 fprintf(f,"\n");
9002                 lp_dump_one(f, show_defaults, iService);
9003         }
9004 }
9005
9006 /***************************************************************************
9007 Display the contents of one service in human-readable form.
9008 ***************************************************************************/
9009
9010 void lp_dump_one(FILE * f, bool show_defaults, int snum)
9011 {
9012         if (VALID(snum)) {
9013                 if (ServicePtrs[snum]->szService[0] == '\0')
9014                         return;
9015                 dump_a_service(ServicePtrs[snum], f);
9016         }
9017 }
9018
9019 /***************************************************************************
9020 Return the number of the service with the given name, or -1 if it doesn't
9021 exist. Note that this is a DIFFERENT ANIMAL from the internal function
9022 getservicebyname()! This works ONLY if all services have been loaded, and
9023 does not copy the found service.
9024 ***************************************************************************/
9025
9026 int lp_servicenumber(const char *pszServiceName)
9027 {
9028         int iService;
9029         fstring serviceName;
9030
9031         if (!pszServiceName) {
9032                 return GLOBAL_SECTION_SNUM;
9033         }
9034
9035         for (iService = iNumServices - 1; iService >= 0; iService--) {
9036                 if (VALID(iService) && ServicePtrs[iService]->szService) {
9037                         /*
9038                          * The substitution here is used to support %U is
9039                          * service names
9040                          */
9041                         fstrcpy(serviceName, ServicePtrs[iService]->szService);
9042                         standard_sub_basic(get_current_username(),
9043                                            current_user_info.domain,
9044                                            serviceName,sizeof(serviceName));
9045                         if (strequal(serviceName, pszServiceName)) {
9046                                 break;
9047                         }
9048                 }
9049         }
9050
9051         if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
9052                 time_t last_mod;
9053
9054                 if (!usershare_exists(iService, &last_mod)) {
9055                         /* Remove the share security tdb entry for it. */
9056                         delete_share_security(lp_servicename(iService));
9057                         /* Remove it from the array. */
9058                         free_service_byindex(iService);
9059                         /* Doesn't exist anymore. */
9060                         return GLOBAL_SECTION_SNUM;
9061                 }
9062
9063                 /* Has it been modified ? If so delete and reload. */
9064                 if (ServicePtrs[iService]->usershare_last_mod < last_mod) {
9065                         /* Remove it from the array. */
9066                         free_service_byindex(iService);
9067                         /* and now reload it. */
9068                         iService = load_usershare_service(pszServiceName);
9069                 }
9070         }
9071
9072         if (iService < 0) {
9073                 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
9074                 return GLOBAL_SECTION_SNUM;
9075         }
9076
9077         return (iService);
9078 }
9079
9080 bool share_defined(const char *service_name)
9081 {
9082         return (lp_servicenumber(service_name) != -1);
9083 }
9084
9085 struct share_params *get_share_params(TALLOC_CTX *mem_ctx,
9086                                       const char *sharename)
9087 {
9088         struct share_params *result;
9089         char *sname;
9090         int snum;
9091
9092         if (!(sname = SMB_STRDUP(sharename))) {
9093                 return NULL;
9094         }
9095
9096         snum = find_service(sname);
9097         SAFE_FREE(sname);
9098
9099         if (snum < 0) {
9100                 return NULL;
9101         }
9102
9103         if (!(result = TALLOC_P(mem_ctx, struct share_params))) {
9104                 DEBUG(0, ("talloc failed\n"));
9105                 return NULL;
9106         }
9107
9108         result->service = snum;
9109         return result;
9110 }
9111
9112 struct share_iterator *share_list_all(TALLOC_CTX *mem_ctx)
9113 {
9114         struct share_iterator *result;
9115
9116         if (!(result = TALLOC_P(mem_ctx, struct share_iterator))) {
9117                 DEBUG(0, ("talloc failed\n"));
9118                 return NULL;
9119         }
9120
9121         result->next_id = 0;
9122         return result;
9123 }
9124
9125 struct share_params *next_share(struct share_iterator *list)
9126 {
9127         struct share_params *result;
9128
9129         while (!lp_snum_ok(list->next_id) &&
9130                (list->next_id < lp_numservices())) {
9131                 list->next_id += 1;
9132         }
9133
9134         if (list->next_id >= lp_numservices()) {
9135                 return NULL;
9136         }
9137
9138         if (!(result = TALLOC_P(list, struct share_params))) {
9139                 DEBUG(0, ("talloc failed\n"));
9140                 return NULL;
9141         }
9142
9143         result->service = list->next_id;
9144         list->next_id += 1;
9145         return result;
9146 }
9147
9148 struct share_params *next_printer(struct share_iterator *list)
9149 {
9150         struct share_params *result;
9151
9152         while ((result = next_share(list)) != NULL) {
9153                 if (lp_print_ok(result->service)) {
9154                         break;
9155                 }
9156         }
9157         return result;
9158 }
9159
9160 /*
9161  * This is a hack for a transition period until we transformed all code from
9162  * service numbers to struct share_params.
9163  */
9164
9165 struct share_params *snum2params_static(int snum)
9166 {
9167         static struct share_params result;
9168         result.service = snum;
9169         return &result;
9170 }
9171
9172 /*******************************************************************
9173  A useful volume label function.
9174 ********************************************************************/
9175
9176 const char *volume_label(int snum)
9177 {
9178         char *ret;
9179         const char *label = lp_volume(snum);
9180         if (!*label) {
9181                 label = lp_servicename(snum);
9182         }
9183
9184         /* This returns a 33 byte guarenteed null terminated string. */
9185         ret = talloc_strndup(talloc_tos(), label, 32);
9186         if (!ret) {
9187                 return "";
9188         }
9189         return ret;
9190 }
9191
9192 /*******************************************************************
9193  Set the server type we will announce as via nmbd.
9194 ********************************************************************/
9195
9196 static void set_default_server_announce_type(void)
9197 {
9198         default_server_announce = 0;
9199         default_server_announce |= SV_TYPE_WORKSTATION;
9200         default_server_announce |= SV_TYPE_SERVER;
9201         default_server_announce |= SV_TYPE_SERVER_UNIX;
9202
9203         /* note that the flag should be set only if we have a
9204            printer service but nmbd doesn't actually load the
9205            services so we can't tell   --jerry */
9206
9207         default_server_announce |= SV_TYPE_PRINTQ_SERVER;
9208
9209         switch (lp_announce_as()) {
9210                 case ANNOUNCE_AS_NT_SERVER:
9211                         default_server_announce |= SV_TYPE_SERVER_NT;
9212                         /* fall through... */
9213                 case ANNOUNCE_AS_NT_WORKSTATION:
9214                         default_server_announce |= SV_TYPE_NT;
9215                         break;
9216                 case ANNOUNCE_AS_WIN95:
9217                         default_server_announce |= SV_TYPE_WIN95_PLUS;
9218                         break;
9219                 case ANNOUNCE_AS_WFW:
9220                         default_server_announce |= SV_TYPE_WFW;
9221                         break;
9222                 default:
9223                         break;
9224         }
9225
9226         switch (lp_server_role()) {
9227                 case ROLE_DOMAIN_MEMBER:
9228                         default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
9229                         break;
9230                 case ROLE_DOMAIN_PDC:
9231                         default_server_announce |= SV_TYPE_DOMAIN_CTRL;
9232                         break;
9233                 case ROLE_DOMAIN_BDC:
9234                         default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
9235                         break;
9236                 case ROLE_STANDALONE:
9237                 default:
9238                         break;
9239         }
9240         if (lp_time_server())
9241                 default_server_announce |= SV_TYPE_TIME_SOURCE;
9242
9243         if (lp_host_msdfs())
9244                 default_server_announce |= SV_TYPE_DFS_SERVER;
9245 }
9246
9247 /***********************************************************
9248  returns role of Samba server
9249 ************************************************************/
9250
9251 int lp_server_role(void)
9252 {
9253         return server_role;
9254 }
9255
9256 /***********************************************************
9257  If we are PDC then prefer us as DMB
9258 ************************************************************/
9259
9260 bool lp_domain_master(void)
9261 {
9262         if (Globals.iDomainMaster == Auto)
9263                 return (lp_server_role() == ROLE_DOMAIN_PDC);
9264
9265         return (bool)Globals.iDomainMaster;
9266 }
9267
9268 /***********************************************************
9269  If we are DMB then prefer us as LMB
9270 ************************************************************/
9271
9272 bool lp_preferred_master(void)
9273 {
9274         if (Globals.iPreferredMaster == Auto)
9275                 return (lp_local_master() && lp_domain_master());
9276
9277         return (bool)Globals.iPreferredMaster;
9278 }
9279
9280 /*******************************************************************
9281  Remove a service.
9282 ********************************************************************/
9283
9284 void lp_remove_service(int snum)
9285 {
9286         ServicePtrs[snum]->valid = False;
9287         invalid_services[num_invalid_services++] = snum;
9288 }
9289
9290 /*******************************************************************
9291  Copy a service.
9292 ********************************************************************/
9293
9294 void lp_copy_service(int snum, const char *new_name)
9295 {
9296         do_section(new_name, NULL);
9297         if (snum >= 0) {
9298                 snum = lp_servicenumber(new_name);
9299                 if (snum >= 0)
9300                         lp_do_parameter(snum, "copy", lp_servicename(snum));
9301         }
9302 }
9303
9304
9305 /*******************************************************************
9306  Get the default server type we will announce as via nmbd.
9307 ********************************************************************/
9308
9309 int lp_default_server_announce(void)
9310 {
9311         return default_server_announce;
9312 }
9313
9314 /*******************************************************************
9315  Split the announce version into major and minor numbers.
9316 ********************************************************************/
9317
9318 int lp_major_announce_version(void)
9319 {
9320         static bool got_major = False;
9321         static int major_version = DEFAULT_MAJOR_VERSION;
9322         char *vers;
9323         char *p;
9324
9325         if (got_major)
9326                 return major_version;
9327
9328         got_major = True;
9329         if ((vers = lp_announce_version()) == NULL)
9330                 return major_version;
9331
9332         if ((p = strchr_m(vers, '.')) == 0)
9333                 return major_version;
9334
9335         *p = '\0';
9336         major_version = atoi(vers);
9337         return major_version;
9338 }
9339
9340 int lp_minor_announce_version(void)
9341 {
9342         static bool got_minor = False;
9343         static int minor_version = DEFAULT_MINOR_VERSION;
9344         char *vers;
9345         char *p;
9346
9347         if (got_minor)
9348                 return minor_version;
9349
9350         got_minor = True;
9351         if ((vers = lp_announce_version()) == NULL)
9352                 return minor_version;
9353
9354         if ((p = strchr_m(vers, '.')) == 0)
9355                 return minor_version;
9356
9357         p++;
9358         minor_version = atoi(p);
9359         return minor_version;
9360 }
9361
9362 /***********************************************************
9363  Set the global name resolution order (used in smbclient).
9364 ************************************************************/
9365
9366 void lp_set_name_resolve_order(const char *new_order)
9367 {
9368         string_set(&Globals.szNameResolveOrder, new_order);
9369 }
9370
9371 const char *lp_printername(int snum)
9372 {
9373         const char *ret = _lp_printername(snum);
9374         if (ret == NULL || (ret != NULL && *ret == '\0'))
9375                 ret = lp_const_servicename(snum);
9376
9377         return ret;
9378 }
9379
9380
9381 /***********************************************************
9382  Allow daemons such as winbindd to fix their logfile name.
9383 ************************************************************/
9384
9385 void lp_set_logfile(const char *name)
9386 {
9387         string_set(&Globals.szLogFile, name);
9388         debug_set_logfile(name);
9389 }
9390
9391 /*******************************************************************
9392  Return the max print jobs per queue.
9393 ********************************************************************/
9394
9395 int lp_maxprintjobs(int snum)
9396 {
9397         int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
9398         if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
9399                 maxjobs = PRINT_MAX_JOBID - 1;
9400
9401         return maxjobs;
9402 }
9403
9404 const char *lp_printcapname(void)
9405 {
9406         if ((Globals.szPrintcapname != NULL) &&
9407             (Globals.szPrintcapname[0] != '\0'))
9408                 return Globals.szPrintcapname;
9409
9410         if (sDefault.iPrinting == PRINT_CUPS) {
9411 #ifdef HAVE_CUPS
9412                 return "cups";
9413 #else
9414                 return "lpstat";
9415 #endif
9416         }
9417
9418         if (sDefault.iPrinting == PRINT_BSD)
9419                 return "/etc/printcap";
9420
9421         return PRINTCAP_NAME;
9422 }
9423
9424 /*******************************************************************
9425  Ensure we don't use sendfile if server smb signing is active.
9426 ********************************************************************/
9427
9428 static uint32 spoolss_state;
9429
9430 bool lp_disable_spoolss( void )
9431 {
9432         if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
9433                 spoolss_state = _lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
9434
9435         return spoolss_state == SVCCTL_STOPPED ? True : False;
9436 }
9437
9438 void lp_set_spoolss_state( uint32 state )
9439 {
9440         SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
9441
9442         spoolss_state = state;
9443 }
9444
9445 uint32 lp_get_spoolss_state( void )
9446 {
9447         return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
9448 }
9449
9450 /*******************************************************************
9451  Ensure we don't use sendfile if server smb signing is active.
9452 ********************************************************************/
9453
9454 bool lp_use_sendfile(int snum)
9455 {
9456         /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
9457         if (Protocol < PROTOCOL_NT1) {
9458                 return False;
9459         }
9460         return (_lp_use_sendfile(snum) &&
9461                         (get_remote_arch() != RA_WIN95) &&
9462                         !srv_is_signing_active());
9463 }
9464
9465 /*******************************************************************
9466  Turn off sendfile if we find the underlying OS doesn't support it.
9467 ********************************************************************/
9468
9469 void set_use_sendfile(int snum, bool val)
9470 {
9471         if (LP_SNUM_OK(snum))
9472                 ServicePtrs[snum]->bUseSendfile = val;
9473         else
9474                 sDefault.bUseSendfile = val;
9475 }
9476
9477 /*******************************************************************
9478  Turn off storing DOS attributes if this share doesn't support it.
9479 ********************************************************************/
9480
9481 void set_store_dos_attributes(int snum, bool val)
9482 {
9483         if (!LP_SNUM_OK(snum))
9484                 return;
9485         ServicePtrs[(snum)]->bStoreDosAttributes = val;
9486 }
9487
9488 void lp_set_mangling_method(const char *new_method)
9489 {
9490         string_set(&Globals.szManglingMethod, new_method);
9491 }
9492
9493 /*******************************************************************
9494  Global state for POSIX pathname processing.
9495 ********************************************************************/
9496
9497 static bool posix_pathnames;
9498
9499 bool lp_posix_pathnames(void)
9500 {
9501         return posix_pathnames;
9502 }
9503
9504 /*******************************************************************
9505  Change everything needed to ensure POSIX pathname processing (currently
9506  not much).
9507 ********************************************************************/
9508
9509 void lp_set_posix_pathnames(void)
9510 {
9511         posix_pathnames = True;
9512 }
9513
9514 /*******************************************************************
9515  Global state for POSIX lock processing - CIFS unix extensions.
9516 ********************************************************************/
9517
9518 bool posix_default_lock_was_set;
9519 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
9520
9521 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
9522 {
9523         if (posix_default_lock_was_set) {
9524                 return posix_cifsx_locktype;
9525         } else {
9526                 return fsp->posix_open ? POSIX_LOCK : WINDOWS_LOCK;
9527         }
9528 }
9529
9530 /*******************************************************************
9531 ********************************************************************/
9532
9533 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
9534 {
9535         posix_default_lock_was_set = True;
9536         posix_cifsx_locktype = val;
9537 }
9538
9539 int lp_min_receive_file_size(void)
9540 {
9541         if (Globals.iminreceivefile < 0) {
9542                 return 0;
9543         }
9544         return MIN(Globals.iminreceivefile, BUFFER_SIZE);
9545 }
9546
9547 /*******************************************************************
9548  If socket address is an empty character string, it is necessary to
9549  define it as "0.0.0.0".
9550 ********************************************************************/
9551
9552 const char *lp_socket_address(void)
9553 {
9554         char *sock_addr = Globals.szSocketAddress;
9555
9556         if (sock_addr[0] == '\0'){
9557                 string_set(&Globals.szSocketAddress, "0.0.0.0");
9558         }
9559         return  Globals.szSocketAddress;
9560 }