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