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