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