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