source/param/loadparm.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Parameter loading functions
   4    Copyright (C) Karl Auer 1993-1998
   5
   6    Largely re-written by Andrew Tridgell, September 1994
   7
   8    Copyright (C) Simo Sorce 2001
   9    Copyright (C) Alexander Bokovoy 2002
  10    Copyright (C) Stefan (metze) Metzmacher 2002
  11    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
  12
  13    This program is free software; you can redistribute it and/or modify
  14    it under the terms of the GNU General Public License as published by
  15    the Free Software Foundation; either version 3 of the License, or
  16    (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25 */
  26
  27 /*
  28  *  Load parameters.
  29  *
  30  *  This module provides suitable callback functions for the params
  31  *  module. It builds the internal table of service details which is
  32  *  then used by the rest of the server.
  33  *
  34  * To add a parameter:
  35  *
  36  * 1) add it to the global or service structure definition
  37  * 2) add it to the parm_table
  38  * 3) add it to the list of available functions (eg: using FN_GLOBAL_STRING())
  39  * 4) If it's a global then initialise it in init_globals. If a local
  40  *    (ie. service) parameter then initialise it in the sDefault structure
  41  *
  42  *
  43  * Notes:
  44  *   The configuration file is processed sequentially for speed. It is NOT
  45  *   accessed randomly as happens in 'real' Windows. For this reason, there
  46  *   is a fair bit of sequence-dependent code here - ie., code which assumes
  47  *   that certain things happen before others. In particular, the code which
  48  *   happens at the boundary between sections is delicately poised, so be
  49  *   careful!
  50  *
  51  */
  52
  53 #include "includes.h"
  54
  55 BOOL in_client = False;         /* Not in the client by default */
  56 BOOL bLoaded = False;
  57
  58 extern pstring user_socket_options;
  59 extern enum protocol_types Protocol;
  60 extern userdom_struct current_user_info;
  61
  62 #ifndef GLOBAL_NAME
  63 #define GLOBAL_NAME "global"
  64 #endif
  65
  66 #ifndef PRINTERS_NAME
  67 #define PRINTERS_NAME "printers"
  68 #endif
  69
  70 #ifndef HOMES_NAME
  71 #define HOMES_NAME "homes"
  72 #endif
  73
  74 /* the special value for the include parameter
  75  * to be interpreted not as a file name but to
  76  * trigger loading of the global smb.conf options
  77  * from registry. */
  78 #ifndef INCLUDE_REGISTRY_NAME
  79 #define INCLUDE_REGISTRY_NAME "registry"
  80 #endif
  81
  82 static int regdb_last_seqnum = 0;
  83 static BOOL include_registry_globals = False;
  84
  85 /* some helpful bits */
  86 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && (ServicePtrs != NULL) && ServicePtrs[(i)]->valid)
  87 #define VALID(i) (ServicePtrs != NULL && ServicePtrs[i]->valid)
  88
  89 #define USERSHARE_VALID 1
  90 #define USERSHARE_PENDING_DELETE 2
  91
  92 BOOL use_getwd_cache = True;
  93
  94 extern int extra_time_offset;
  95
  96 static BOOL defaults_saved = False;
  97
  98 typedef struct _param_opt_struct param_opt_struct;
  99 struct _param_opt_struct {
 100         param_opt_struct *prev, *next;
 101         char *key;
 102         char *value;
 103         char **list;
 104 };
 105
 106 /*
 107  * This structure describes global (ie., server-wide) parameters.
 108  */
 109 typedef struct {
 110         char *smb_ports;
 111         char *dos_charset;
 112         char *unix_charset;
 113         char *display_charset;
 114         char *szPrintcapname;
 115         char *szAddPortCommand;
 116         char *szEnumPortsCommand;
 117         char *szAddPrinterCommand;
 118         char *szDeletePrinterCommand;
 119         char *szOs2DriverMap;
 120         char *szLockDir;
 121         char *szPidDir;
 122         char *szRootdir;
 123         char *szDefaultService;
 124         char *szGetQuota;
 125         char *szSetQuota;
 126         char *szMsgCommand;
 127         char *szServerString;
 128         char *szAutoServices;
 129         char *szPasswdProgram;
 130         char *szPasswdChat;
 131         char *szLogFile;
 132         char *szConfigFile;
 133         char *szSMBPasswdFile;
 134         char *szPrivateDir;
 135         char *szPassdbBackend;
 136         char **szPreloadModules;
 137         char *szPasswordServer;
 138         char *szSocketOptions;
 139         char *szRealm;
 140         char *szAfsUsernameMap;
 141         int iAfsTokenLifetime;
 142         char *szLogNtTokenCommand;
 143         char *szUsernameMap;
 144         char *szLogonScript;
 145         char *szLogonPath;
 146         char *szLogonDrive;
 147         char *szLogonHome;
 148         char **szWINSservers;
 149         char **szInterfaces;
 150         char *szRemoteAnnounce;
 151         char *szRemoteBrowseSync;
 152         char *szSocketAddress;
 153         char *szNISHomeMapName;
 154         char *szAnnounceVersion;        /* This is initialised in init_globals */
 155         char *szWorkgroup;
 156         char *szNetbiosName;
 157         char **szNetbiosAliases;
 158         char *szNetbiosScope;
 159         char *szNameResolveOrder;
 160         char *szPanicAction;
 161         char *szAddUserScript;
 162         char *szRenameUserScript;
 163         char *szDelUserScript;
 164         char *szAddGroupScript;
 165         char *szDelGroupScript;
 166         char *szAddUserToGroupScript;
 167         char *szDelUserFromGroupScript;
 168         char *szSetPrimaryGroupScript;
 169         char *szAddMachineScript;
 170         char *szShutdownScript;
 171         char *szAbortShutdownScript;
 172         char *szUsernameMapScript;
 173         char *szCheckPasswordScript;
 174         char *szWINSHook;
 175         char *szUtmpDir;
 176         char *szWtmpDir;
 177         BOOL bUtmp;
 178         char *szIdmapUID;
 179         char *szIdmapGID;
 180         BOOL bPassdbExpandExplicit;
 181         int AlgorithmicRidBase;
 182         char *szTemplateHomedir;
 183         char *szTemplateShell;
 184         char *szWinbindSeparator;
 185         BOOL bWinbindEnumUsers;
 186         BOOL bWinbindEnumGroups;
 187         BOOL bWinbindUseDefaultDomain;
 188         BOOL bWinbindTrustedDomainsOnly;
 189         BOOL bWinbindNestedGroups;
 190         int  winbind_expand_groups;
 191         BOOL bWinbindRefreshTickets;
 192         BOOL bWinbindOfflineLogon;
 193         BOOL bWinbindNormalizeNames;
 194         BOOL bWinbindRpcOnly;
 195         char **szIdmapDomains;
 196         char **szIdmapBackend; /* deprecated */
 197         char *szIdmapAllocBackend;
 198         char *szAddShareCommand;
 199         char *szChangeShareCommand;
 200         char *szDeleteShareCommand;
 201         char **szEventLogs;
 202         char *szGuestaccount;
 203         char *szManglingMethod;
 204         char **szServicesList;
 205         char *szUsersharePath;
 206         char *szUsershareTemplateShare;
 207         char **szUsersharePrefixAllowList;
 208         char **szUsersharePrefixDenyList;
 209         int mangle_prefix;
 210         int max_log_size;
 211         char *szLogLevel;
 212         int max_xmit;
 213         int max_mux;
 214         int max_open_files;
 215         int open_files_db_hash_size;
 216         int pwordlevel;
 217         int unamelevel;
 218         int deadtime;
 219         int maxprotocol;
 220         int minprotocol;
 221         int security;
 222         char **AuthMethods;
 223         BOOL paranoid_server_security;
 224         int maxdisksize;
 225         int lpqcachetime;
 226         int iMaxSmbdProcesses;
 227         BOOL bDisableSpoolss;
 228         int syslog;
 229         int os_level;
 230         int enhanced_browsing;
 231         int max_ttl;
 232         int max_wins_ttl;
 233         int min_wins_ttl;
 234         int lm_announce;
 235         int lm_interval;
 236         int announce_as;        /* This is initialised in init_globals */
 237         int machine_password_timeout;
 238         int map_to_guest;
 239         int oplock_break_wait_time;
 240         int winbind_cache_time;
 241         int winbind_max_idle_children;
 242         char **szWinbindNssInfo;
 243         int iLockSpinTime;
 244         char *szLdapMachineSuffix;
 245         char *szLdapUserSuffix;
 246         char *szLdapIdmapSuffix;
 247         char *szLdapGroupSuffix;
 248         int ldap_ssl;
 249         char *szLdapSuffix;
 250         char *szLdapAdminDn;
 251         int iAclCompat;
 252         char *szCupsServer;
 253         char *szIPrintServer;
 254         char *ctdbdSocket;
 255         BOOL clustering;
 256         int ldap_passwd_sync;
 257         int ldap_replication_sleep;
 258         int ldap_timeout; /* This is initialised in init_globals */
 259         int ldap_page_size;
 260         BOOL ldap_delete_dn;
 261         BOOL bMsAddPrinterWizard;
 262         BOOL bDNSproxy;
 263         BOOL bWINSsupport;
 264         BOOL bWINSproxy;
 265         BOOL bLocalMaster;
 266         BOOL bPreferredMaster;
 267         BOOL bDomainMaster;
 268         BOOL bDomainLogons;
 269         BOOL bEncryptPasswords;
 270         BOOL bUpdateEncrypt;
 271         int  clientSchannel;
 272         int  serverSchannel;
 273         BOOL bNullPasswords;
 274         BOOL bObeyPamRestrictions;
 275         BOOL bLoadPrinters;
 276         int PrintcapCacheTime;
 277         BOOL bLargeReadwrite;
 278         BOOL bReadRaw;
 279         BOOL bWriteRaw;
 280         BOOL bReadbmpx;
 281         BOOL bSyslogOnly;
 282         BOOL bBrowseList;
 283         BOOL bNISHomeMap;
 284         BOOL bTimeServer;
 285         BOOL bBindInterfacesOnly;
 286         BOOL bPamPasswordChange;
 287         BOOL bUnixPasswdSync;
 288         BOOL bPasswdChatDebug;
 289         int iPasswdChatTimeout;
 290         BOOL bTimestampLogs;
 291         BOOL bNTSmbSupport;
 292         BOOL bNTPipeSupport;
 293         BOOL bNTStatusSupport;
 294         BOOL bStatCache;
 295         int iMaxStatCacheSize;
 296         BOOL bKernelOplocks;
 297         BOOL bAllowTrustedDomains;
 298         BOOL bLanmanAuth;
 299         BOOL bNTLMAuth;
 300         BOOL bUseSpnego;
 301         BOOL bClientLanManAuth;
 302         BOOL bClientNTLMv2Auth;
 303         BOOL bClientPlaintextAuth;
 304         BOOL bClientUseSpnego;
 305         BOOL bDebugPrefixTimestamp;
 306         BOOL bDebugHiresTimestamp;
 307         BOOL bDebugPid;
 308         BOOL bDebugUid;
 309         BOOL bEnableCoreFiles;
 310         BOOL bHostMSDfs;
 311         BOOL bUseMmap;
 312         BOOL bHostnameLookups;
 313         BOOL bUnixExtensions;
 314         BOOL bDisableNetbios;
 315         BOOL bUseKerberosKeytab;
 316         BOOL bDeferSharingViolations;
 317         BOOL bEnablePrivileges;
 318         BOOL bASUSupport;
 319         BOOL bUsershareOwnerOnly;
 320         BOOL bUsershareAllowGuests;
 321         BOOL bRegistryShares;
 322         int restrict_anonymous;
 323         int name_cache_timeout;
 324         int client_signing;
 325         int server_signing;
 326         int iUsershareMaxShares;
 327         int iIdmapCacheTime;
 328         int iIdmapNegativeCacheTime;
 329
 330         BOOL bResetOnZeroVC;
 331         int iKeepalive;
 332         param_opt_struct *param_opt;
 333 } global;
 334
 335 static global Globals;
 336
 337 /*
 338  * This structure describes a single service.
 339  */
 340 typedef struct {
 341         BOOL valid;
 342         BOOL autoloaded;
 343         int usershare;
 344         time_t usershare_last_mod;
 345         char *szService;
 346         char *szPath;
 347         char *szUsername;
 348         char **szInvalidUsers;
 349         char **szValidUsers;
 350         char **szAdminUsers;
 351         char *szCopy;
 352         char *szInclude;
 353         char *szPreExec;
 354         char *szPostExec;
 355         char *szRootPreExec;
 356         char *szRootPostExec;
 357         char *szCupsOptions;
 358         char *szPrintcommand;
 359         char *szLpqcommand;
 360         char *szLprmcommand;
 361         char *szLppausecommand;
 362         char *szLpresumecommand;
 363         char *szQueuepausecommand;
 364         char *szQueueresumecommand;
 365         char *szPrintername;
 366         char *szPrintjobUsername;
 367         char *szDontdescend;
 368         char **szHostsallow;
 369         char **szHostsdeny;
 370         char *szMagicScript;
 371         char *szMagicOutput;
 372         char *szMangledMap;
 373         char *szVetoFiles;
 374         char *szHideFiles;
 375         char *szVetoOplockFiles;
 376         char *comment;
 377         char *force_user;
 378         char *force_group;
 379         char **readlist;
 380         char **writelist;
 381         char **printer_admin;
 382         char *volume;
 383         char *fstype;
 384         char **szVfsObjects;
 385         char *szMSDfsProxy;
 386         char *szDfree;
 387         int iMinPrintSpace;
 388         int iMaxPrintJobs;
 389         int iMaxReportedPrintJobs;
 390         int iWriteCacheSize;
 391         int iCreate_mask;
 392         int iCreate_force_mode;
 393         int iSecurity_mask;
 394         int iSecurity_force_mode;
 395         int iDir_mask;
 396         int iDir_force_mode;
 397         int iDir_Security_mask;
 398         int iDir_Security_force_mode;
 399         int iMaxConnections;
 400         int iDefaultCase;
 401         int iPrinting;
 402         int iOplockContentionLimit;
 403         int iCSCPolicy;
 404         int iBlock_size;
 405         int iDfreeCacheTime;
 406         BOOL bPreexecClose;
 407         BOOL bRootpreexecClose;
 408         int  iCaseSensitive;
 409         BOOL bCasePreserve;
 410         BOOL bShortCasePreserve;
 411         BOOL bHideDotFiles;
 412         BOOL bHideSpecialFiles;
 413         BOOL bHideUnReadable;
 414         BOOL bHideUnWriteableFiles;
 415         BOOL bBrowseable;
 416         BOOL bAvailable;
 417         BOOL bRead_only;
 418         BOOL bNo_set_dir;
 419         BOOL bGuest_only;
 420         BOOL bGuest_ok;
 421         BOOL bPrint_ok;
 422         BOOL bMap_system;
 423         BOOL bMap_hidden;
 424         BOOL bMap_archive;
 425         BOOL bStoreDosAttributes;
 426         BOOL bDmapiSupport;
 427         BOOL bLocking;
 428         int iStrictLocking;
 429         BOOL bPosixLocking;
 430         BOOL bShareModes;
 431         BOOL bOpLocks;
 432         BOOL bLevel2OpLocks;
 433         BOOL bOnlyUser;
 434         BOOL bMangledNames;
 435         BOOL bWidelinks;
 436         BOOL bSymlinks;
 437         BOOL bSyncAlways;
 438         BOOL bStrictAllocate;
 439         BOOL bStrictSync;
 440         char magic_char;
 441         BOOL *copymap;
 442         BOOL bDeleteReadonly;
 443         BOOL bFakeOplocks;
 444         BOOL bDeleteVetoFiles;
 445         BOOL bDosFilemode;
 446         BOOL bDosFiletimes;
 447         BOOL bDosFiletimeResolution;
 448         BOOL bFakeDirCreateTimes;
 449         BOOL bBlockingLocks;
 450         BOOL bInheritPerms;
 451         BOOL bInheritACLS;
 452         BOOL bInheritOwner;
 453         BOOL bMSDfsRoot;
 454         BOOL bUseClientDriver;
 455         BOOL bDefaultDevmode;
 456         BOOL bForcePrintername;
 457         BOOL bNTAclSupport;
 458         BOOL bForceUnknownAclUser;
 459         BOOL bUseSendfile;
 460         BOOL bProfileAcls;
 461         BOOL bMap_acl_inherit;
 462         BOOL bAfs_Share;
 463         BOOL bEASupport;
 464         BOOL bAclCheckPermissions;
 465         BOOL bAclMapFullControl;
 466         BOOL bAclGroupControl;
 467         BOOL bChangeNotify;
 468         BOOL bKernelChangeNotify;
 469         int iallocation_roundup_size;
 470         int iAioReadSize;
 471         int iAioWriteSize;
 472         int iMap_readonly;
 473         param_opt_struct *param_opt;
 474
 475         char dummy[3];          /* for alignment */
 476 } service;
 477
 478
 479 /* This is a default service used to prime a services structure */
 480 static service sDefault = {
 481         True,                   /* valid */
 482         False,                  /* not autoloaded */
 483         0,                      /* not a usershare */
 484         (time_t)0,              /* No last mod time */
 485         NULL,                   /* szService */
 486         NULL,                   /* szPath */
 487         NULL,                   /* szUsername */
 488         NULL,                   /* szInvalidUsers */
 489         NULL,                   /* szValidUsers */
 490         NULL,                   /* szAdminUsers */
 491         NULL,                   /* szCopy */
 492         NULL,                   /* szInclude */
 493         NULL,                   /* szPreExec */
 494         NULL,                   /* szPostExec */
 495         NULL,                   /* szRootPreExec */
 496         NULL,                   /* szRootPostExec */
 497         NULL,                   /* szCupsOptions */
 498         NULL,                   /* szPrintcommand */
 499         NULL,                   /* szLpqcommand */
 500         NULL,                   /* szLprmcommand */
 501         NULL,                   /* szLppausecommand */
 502         NULL,                   /* szLpresumecommand */
 503         NULL,                   /* szQueuepausecommand */
 504         NULL,                   /* szQueueresumecommand */
 505         NULL,                   /* szPrintername */
 506         NULL,                   /* szPrintjobUsername */
 507         NULL,                   /* szDontdescend */
 508         NULL,                   /* szHostsallow */
 509         NULL,                   /* szHostsdeny */
 510         NULL,                   /* szMagicScript */
 511         NULL,                   /* szMagicOutput */
 512         NULL,                   /* szMangledMap */
 513         NULL,                   /* szVetoFiles */
 514         NULL,                   /* szHideFiles */
 515         NULL,                   /* szVetoOplockFiles */
 516         NULL,                   /* comment */
 517         NULL,                   /* force user */
 518         NULL,                   /* force group */
 519         NULL,                   /* readlist */
 520         NULL,                   /* writelist */
 521         NULL,                   /* printer admin */
 522         NULL,                   /* volume */
 523         NULL,                   /* fstype */
 524         NULL,                   /* vfs objects */
 525         NULL,                   /* szMSDfsProxy */
 526         NULL,                   /* szDfree */
 527         0,                      /* iMinPrintSpace */
 528         1000,                   /* iMaxPrintJobs */
 529         0,                      /* iMaxReportedPrintJobs */
 530         0,                      /* iWriteCacheSize */
 531         0744,                   /* iCreate_mask */
 532         0000,                   /* iCreate_force_mode */
 533         0777,                   /* iSecurity_mask */
 534         0,                      /* iSecurity_force_mode */
 535         0755,                   /* iDir_mask */
 536         0000,                   /* iDir_force_mode */
 537         0777,                   /* iDir_Security_mask */
 538         0,                      /* iDir_Security_force_mode */
 539         0,                      /* iMaxConnections */
 540         CASE_LOWER,             /* iDefaultCase */
 541         DEFAULT_PRINTING,       /* iPrinting */
 542         2,                      /* iOplockContentionLimit */
 543         0,                      /* iCSCPolicy */
 544         1024,                   /* iBlock_size */
 545         0,                      /* iDfreeCacheTime */
 546         False,                  /* bPreexecClose */
 547         False,                  /* bRootpreexecClose */
 548         Auto,                   /* case sensitive */
 549         True,                   /* case preserve */
 550         True,                   /* short case preserve */
 551         True,                   /* bHideDotFiles */
 552         False,                  /* bHideSpecialFiles */
 553         False,                  /* bHideUnReadable */
 554         False,                  /* bHideUnWriteableFiles */
 555         True,                   /* bBrowseable */
 556         True,                   /* bAvailable */
 557         True,                   /* bRead_only */
 558         True,                   /* bNo_set_dir */
 559         False,                  /* bGuest_only */
 560         False,                  /* bGuest_ok */
 561         False,                  /* bPrint_ok */
 562         False,                  /* bMap_system */
 563         False,                  /* bMap_hidden */
 564         True,                   /* bMap_archive */
 565         False,                  /* bStoreDosAttributes */
 566         False,                  /* bDmapiSupport */
 567         True,                   /* bLocking */
 568         Auto,                   /* iStrictLocking */
 569         True,                   /* bPosixLocking */
 570         True,                   /* bShareModes */
 571         True,                   /* bOpLocks */
 572         True,                   /* bLevel2OpLocks */
 573         False,                  /* bOnlyUser */
 574         True,                   /* bMangledNames */
 575         True,                   /* bWidelinks */
 576         True,                   /* bSymlinks */
 577         False,                  /* bSyncAlways */
 578         False,                  /* bStrictAllocate */
 579         False,                  /* bStrictSync */
 580         '~',                    /* magic char */
 581         NULL,                   /* copymap */
 582         False,                  /* bDeleteReadonly */
 583         False,                  /* bFakeOplocks */
 584         False,                  /* bDeleteVetoFiles */
 585         False,                  /* bDosFilemode */
 586         True,                   /* bDosFiletimes */
 587         False,                  /* bDosFiletimeResolution */
 588         False,                  /* bFakeDirCreateTimes */
 589         True,                   /* bBlockingLocks */
 590         False,                  /* bInheritPerms */
 591         False,                  /* bInheritACLS */
 592         False,                  /* bInheritOwner */
 593         False,                  /* bMSDfsRoot */
 594         False,                  /* bUseClientDriver */
 595         True,                   /* bDefaultDevmode */
 596         False,                  /* bForcePrintername */
 597         True,                   /* bNTAclSupport */
 598         False,                  /* bForceUnknownAclUser */
 599         False,                  /* bUseSendfile */
 600         False,                  /* bProfileAcls */
 601         False,                  /* bMap_acl_inherit */
 602         False,                  /* bAfs_Share */
 603         False,                  /* bEASupport */
 604         True,                   /* bAclCheckPermissions */
 605         True,                   /* bAclMapFullControl */
 606         False,                  /* bAclGroupControl */
 607         True,                   /* bChangeNotify */
 608         True,                   /* bKernelChangeNotify */
 609         SMB_ROUNDUP_ALLOCATION_SIZE,            /* iallocation_roundup_size */
 610         0,                      /* iAioReadSize */
 611         0,                      /* iAioWriteSize */
 612         MAP_READONLY_YES,       /* iMap_readonly */
 613
 614         NULL,                   /* Parametric options */
 615
 616         ""                      /* dummy */
 617 };
 618
 619 /* local variables */
 620 static service **ServicePtrs = NULL;
 621 static int iNumServices = 0;
 622 static int iServiceIndex = 0;
 623 static TDB_CONTEXT *ServiceHash;
 624 static int *invalid_services = NULL;
 625 static int num_invalid_services = 0;
 626 static BOOL bInGlobalSection = True;
 627 static BOOL bGlobalOnly = False;
 628 static int server_role;
 629 static int default_server_announce;
 630
 631 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
 632
 633 /* prototypes for the special type handlers */
 634 static BOOL handle_include( int snum, const char *pszParmValue, char **ptr);
 635 static BOOL handle_copy( int snum, const char *pszParmValue, char **ptr);
 636 static BOOL handle_netbios_name( int snum, const char *pszParmValue, char **ptr);
 637 static BOOL handle_idmap_uid( int snum, const char *pszParmValue, char **ptr);
 638 static BOOL handle_idmap_gid( int snum, const char *pszParmValue, char **ptr);
 639 static BOOL handle_debug_list( int snum, const char *pszParmValue, char **ptr );
 640 static BOOL handle_workgroup( int snum, const char *pszParmValue, char **ptr );
 641 static BOOL handle_netbios_aliases( int snum, const char *pszParmValue, char **ptr );
 642 static BOOL handle_netbios_scope( int snum, const char *pszParmValue, char **ptr );
 643 static BOOL handle_charset( int snum, const char *pszParmValue, char **ptr );
 644 static BOOL handle_printing( int snum, const char *pszParmValue, char **ptr);
 645
 646 static void set_server_role(void);
 647 static void set_default_server_announce_type(void);
 648 static void set_allowed_client_auth(void);
 649
 650 static const struct enum_list enum_protocol[] = {
 651         {PROTOCOL_NT1, "NT1"},
 652         {PROTOCOL_LANMAN2, "LANMAN2"},
 653         {PROTOCOL_LANMAN1, "LANMAN1"},
 654         {PROTOCOL_CORE, "CORE"},
 655         {PROTOCOL_COREPLUS, "COREPLUS"},
 656         {PROTOCOL_COREPLUS, "CORE+"},
 657         {-1, NULL}
 658 };
 659
 660 static const struct enum_list enum_security[] = {
 661         {SEC_SHARE, "SHARE"},
 662         {SEC_USER, "USER"},
 663         {SEC_SERVER, "SERVER"},
 664         {SEC_DOMAIN, "DOMAIN"},
 665 #ifdef HAVE_ADS
 666         {SEC_ADS, "ADS"},
 667 #endif
 668         {-1, NULL}
 669 };
 670
 671 static const struct enum_list enum_printing[] = {
 672         {PRINT_SYSV, "sysv"},
 673         {PRINT_AIX, "aix"},
 674         {PRINT_HPUX, "hpux"},
 675         {PRINT_BSD, "bsd"},
 676         {PRINT_QNX, "qnx"},
 677         {PRINT_PLP, "plp"},
 678         {PRINT_LPRNG, "lprng"},
 679         {PRINT_CUPS, "cups"},
 680         {PRINT_IPRINT, "iprint"},
 681         {PRINT_LPRNT, "nt"},
 682         {PRINT_LPROS2, "os2"},
 683 #ifdef DEVELOPER
 684         {PRINT_TEST, "test"},
 685         {PRINT_VLP, "vlp"},
 686 #endif /* DEVELOPER */
 687         {-1, NULL}
 688 };
 689
 690 static const struct enum_list enum_ldap_ssl[] = {
 691         {LDAP_SSL_OFF, "no"},
 692         {LDAP_SSL_OFF, "No"},
 693         {LDAP_SSL_OFF, "off"},
 694         {LDAP_SSL_OFF, "Off"},
 695         {LDAP_SSL_START_TLS, "start tls"},
 696         {LDAP_SSL_START_TLS, "Start_tls"},
 697         {-1, NULL}
 698 };
 699
 700 static const struct enum_list enum_ldap_passwd_sync[] = {
 701         {LDAP_PASSWD_SYNC_OFF, "no"},
 702         {LDAP_PASSWD_SYNC_OFF, "No"},
 703         {LDAP_PASSWD_SYNC_OFF, "off"},
 704         {LDAP_PASSWD_SYNC_OFF, "Off"},
 705         {LDAP_PASSWD_SYNC_ON, "Yes"},
 706         {LDAP_PASSWD_SYNC_ON, "yes"},
 707         {LDAP_PASSWD_SYNC_ON, "on"},
 708         {LDAP_PASSWD_SYNC_ON, "On"},
 709         {LDAP_PASSWD_SYNC_ONLY, "Only"},
 710         {LDAP_PASSWD_SYNC_ONLY, "only"},
 711         {-1, NULL}
 712 };
 713
 714 /* Types of machine we can announce as. */
 715 #define ANNOUNCE_AS_NT_SERVER 1
 716 #define ANNOUNCE_AS_WIN95 2
 717 #define ANNOUNCE_AS_WFW 3
 718 #define ANNOUNCE_AS_NT_WORKSTATION 4
 719
 720 static const struct enum_list enum_announce_as[] = {
 721         {ANNOUNCE_AS_NT_SERVER, "NT"},
 722         {ANNOUNCE_AS_NT_SERVER, "NT Server"},
 723         {ANNOUNCE_AS_NT_WORKSTATION, "NT Workstation"},
 724         {ANNOUNCE_AS_WIN95, "win95"},
 725         {ANNOUNCE_AS_WFW, "WfW"},
 726         {-1, NULL}
 727 };
 728
 729 static const struct enum_list enum_map_readonly[] = {
 730         {MAP_READONLY_NO, "no"},
 731         {MAP_READONLY_NO, "false"},
 732         {MAP_READONLY_NO, "0"},
 733         {MAP_READONLY_YES, "yes"},
 734         {MAP_READONLY_YES, "true"},
 735         {MAP_READONLY_YES, "1"},
 736         {MAP_READONLY_PERMISSIONS, "permissions"},
 737         {MAP_READONLY_PERMISSIONS, "perms"},
 738         {-1, NULL}
 739 };
 740
 741 static const struct enum_list enum_case[] = {
 742         {CASE_LOWER, "lower"},
 743         {CASE_UPPER, "upper"},
 744         {-1, NULL}
 745 };
 746
 747 static const struct enum_list enum_bool_auto[] = {
 748         {False, "No"},
 749         {False, "False"},
 750         {False, "0"},
 751         {True, "Yes"},
 752         {True, "True"},
 753         {True, "1"},
 754         {Auto, "Auto"},
 755         {-1, NULL}
 756 };
 757
 758 /* Client-side offline caching policy types */
 759 #define CSC_POLICY_MANUAL 0
 760 #define CSC_POLICY_DOCUMENTS 1
 761 #define CSC_POLICY_PROGRAMS 2
 762 #define CSC_POLICY_DISABLE 3
 763
 764 static const struct enum_list enum_csc_policy[] = {
 765         {CSC_POLICY_MANUAL, "manual"},
 766         {CSC_POLICY_DOCUMENTS, "documents"},
 767         {CSC_POLICY_PROGRAMS, "programs"},
 768         {CSC_POLICY_DISABLE, "disable"},
 769         {-1, NULL}
 770 };
 771
 772 /* SMB signing types. */
 773 static const struct enum_list enum_smb_signing_vals[] = {
 774         {False, "No"},
 775         {False, "False"},
 776         {False, "0"},
 777         {False, "Off"},
 778         {False, "disabled"},
 779         {True, "Yes"},
 780         {True, "True"},
 781         {True, "1"},
 782         {True, "On"},
 783         {True, "enabled"},
 784         {Auto, "auto"},
 785         {Required, "required"},
 786         {Required, "mandatory"},
 787         {Required, "force"},
 788         {Required, "forced"},
 789         {Required, "enforced"},
 790         {-1, NULL}
 791 };
 792
 793 /* ACL compatibility options. */
 794 static const struct enum_list enum_acl_compat_vals[] = {
 795     { ACL_COMPAT_AUTO, "auto" },
 796     { ACL_COMPAT_WINNT, "winnt" },
 797     { ACL_COMPAT_WIN2K, "win2k" },
 798     { -1, NULL}
 799 };
 800
 801 /*
 802    Do you want session setups at user level security with a invalid
 803    password to be rejected or allowed in as guest? WinNT rejects them
 804    but it can be a pain as it means "net view" needs to use a password
 805
 806    You have 3 choices in the setting of map_to_guest:
 807
 808    "Never" means session setups with an invalid password
 809    are rejected. This is the default.
 810
 811    "Bad User" means session setups with an invalid password
 812    are rejected, unless the username does not exist, in which case it
 813    is treated as a guest login
 814
 815    "Bad Password" means session setups with an invalid password
 816    are treated as a guest login
 817
 818    Note that map_to_guest only has an effect in user or server
 819    level security.
 820 */
 821
 822 static const struct enum_list enum_map_to_guest[] = {
 823         {NEVER_MAP_TO_GUEST, "Never"},
 824         {MAP_TO_GUEST_ON_BAD_USER, "Bad User"},
 825         {MAP_TO_GUEST_ON_BAD_PASSWORD, "Bad Password"},
 826         {MAP_TO_GUEST_ON_BAD_UID, "Bad Uid"},
 827         {-1, NULL}
 828 };
 829
 830 /* Note: We do not initialise the defaults union - it is not allowed in ANSI C
 831  *
 832  * The FLAG_HIDE is explicit. Paramters set this way do NOT appear in any edit
 833  * screen in SWAT. This is used to exclude parameters as well as to squash all
 834  * parameters that have been duplicated by pseudonyms.
 835  *
 836  * NOTE: To display a parameter in BASIC view set FLAG_BASIC
 837  *       Any parameter that does NOT have FLAG_ADVANCED will not disply at all
 838  *       Set FLAG_SHARE and FLAG_PRINT to specifically display parameters in
 839  *        respective views.
 840  *
 841  * NOTE2: Handling of duplicated (synonym) paramters:
 842  *      Only the first occurance of a parameter should be enabled by FLAG_BASIC
 843  *      and/or FLAG_ADVANCED. All duplicates following the first mention should be
 844  *      set to FLAG_HIDE. ie: Make you must place the parameter that has the preferred
 845  *      name first, and all synonyms must follow it with the FLAG_HIDE attribute.
 846  */
 847
 848 static struct parm_struct parm_table[] = {
 849         {N_("Base Options"), P_SEP, P_SEPARATOR},
 850
 851         {"dos charset", P_STRING, P_GLOBAL, &Globals.dos_charset, handle_charset, NULL, FLAG_ADVANCED},
 852         {"unix charset", P_STRING, P_GLOBAL, &Globals.unix_charset, handle_charset, NULL, FLAG_ADVANCED},
 853         {"display charset", P_STRING, P_GLOBAL, &Globals.display_charset, handle_charset, NULL, FLAG_ADVANCED},
 854         {"comment", P_STRING, P_LOCAL, &sDefault.comment, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
 855         {"path", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
 856         {"directory", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_HIDE},
 857         {"workgroup", P_USTRING, P_GLOBAL, &Globals.szWorkgroup, handle_workgroup, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 858 #ifdef WITH_ADS
 859         {"realm", P_USTRING, P_GLOBAL, &Globals.szRealm, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 860 #endif
 861         {"netbios name", P_USTRING, P_GLOBAL, &Globals.szNetbiosName, handle_netbios_name, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 862         {"netbios aliases", P_LIST, P_GLOBAL, &Globals.szNetbiosAliases, handle_netbios_aliases,  NULL, FLAG_ADVANCED},
 863         {"netbios scope", P_USTRING, P_GLOBAL, &Globals.szNetbiosScope, handle_netbios_scope,  NULL, FLAG_ADVANCED},
 864         {"server string", P_STRING, P_GLOBAL, &Globals.szServerString, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED },
 865         {"interfaces", P_LIST, P_GLOBAL, &Globals.szInterfaces, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 866         {"bind interfaces only", P_BOOL, P_GLOBAL, &Globals.bBindInterfacesOnly, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
 867
 868         {N_("Security Options"), P_SEP, P_SEPARATOR},
 869
 870         {"security", P_ENUM, P_GLOBAL, &Globals.security, NULL, enum_security, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 871         {"auth methods", P_LIST, P_GLOBAL, &Globals.AuthMethods, NULL, NULL, FLAG_ADVANCED},
 872         {"encrypt passwords", P_BOOL, P_GLOBAL, &Globals.bEncryptPasswords, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 873         {"update encrypted", P_BOOL, P_GLOBAL, &Globals.bUpdateEncrypt, NULL, NULL, FLAG_ADVANCED},
 874         {"client schannel", P_ENUM, P_GLOBAL, &Globals.clientSchannel, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
 875         {"server schannel", P_ENUM, P_GLOBAL, &Globals.serverSchannel, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
 876         {"allow trusted domains", P_BOOL, P_GLOBAL, &Globals.bAllowTrustedDomains, NULL, NULL, FLAG_ADVANCED},
 877         {"map to guest", P_ENUM, P_GLOBAL, &Globals.map_to_guest, NULL, enum_map_to_guest, FLAG_ADVANCED},
 878         {"null passwords", P_BOOL, P_GLOBAL, &Globals.bNullPasswords, NULL, NULL, FLAG_ADVANCED},
 879         {"obey pam restrictions", P_BOOL, P_GLOBAL, &Globals.bObeyPamRestrictions, NULL, NULL, FLAG_ADVANCED},
 880         {"password server", P_STRING, P_GLOBAL, &Globals.szPasswordServer, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
 881         {"smb passwd file", P_STRING, P_GLOBAL, &Globals.szSMBPasswdFile, NULL, NULL, FLAG_ADVANCED},
 882         {"private dir", P_STRING, P_GLOBAL, &Globals.szPrivateDir, NULL, NULL, FLAG_ADVANCED},
 883         {"passdb backend", P_STRING, P_GLOBAL, &Globals.szPassdbBackend, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
 884         {"algorithmic rid base", P_INTEGER, P_GLOBAL, &Globals.AlgorithmicRidBase, NULL, NULL, FLAG_ADVANCED},
 885         {"root directory", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_ADVANCED},
 886         {"root dir", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_HIDE},
 887         {"root", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_HIDE},
 888         {"guest account", P_STRING, P_GLOBAL, &Globals.szGuestaccount, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED},
 889         {"enable privileges", P_BOOL, P_GLOBAL, &Globals.bEnablePrivileges, NULL, NULL, FLAG_ADVANCED},
 890
 891         {"pam password change", P_BOOL, P_GLOBAL, &Globals.bPamPasswordChange, NULL, NULL, FLAG_ADVANCED},
 892         {"passwd program", P_STRING, P_GLOBAL, &Globals.szPasswdProgram, NULL, NULL, FLAG_ADVANCED},
 893         {"passwd chat", P_STRING, P_GLOBAL, &Globals.szPasswdChat, NULL, NULL, FLAG_ADVANCED},
 894         {"passwd chat debug", P_BOOL, P_GLOBAL, &Globals.bPasswdChatDebug, NULL, NULL, FLAG_ADVANCED},
 895         {"passwd chat timeout", P_INTEGER, P_GLOBAL, &Globals.iPasswdChatTimeout, NULL, NULL, FLAG_ADVANCED},
 896         {"check password script", P_STRING, P_GLOBAL, &Globals.szCheckPasswordScript, NULL, NULL, FLAG_ADVANCED},
 897         {"username map", P_STRING, P_GLOBAL, &Globals.szUsernameMap, NULL, NULL, FLAG_ADVANCED},
 898         {"password level", P_INTEGER, P_GLOBAL, &Globals.pwordlevel, NULL, NULL, FLAG_ADVANCED},
 899         {"username level", P_INTEGER, P_GLOBAL, &Globals.unamelevel, NULL, NULL, FLAG_ADVANCED},
 900         {"unix password sync", P_BOOL, P_GLOBAL, &Globals.bUnixPasswdSync, NULL, NULL, FLAG_ADVANCED},
 901         {"restrict anonymous", P_INTEGER, P_GLOBAL, &Globals.restrict_anonymous, NULL, NULL, FLAG_ADVANCED},
 902         {"lanman auth", P_BOOL, P_GLOBAL, &Globals.bLanmanAuth, NULL, NULL, FLAG_ADVANCED},
 903         {"ntlm auth", P_BOOL, P_GLOBAL, &Globals.bNTLMAuth, NULL, NULL, FLAG_ADVANCED},
 904         {"client NTLMv2 auth", P_BOOL, P_GLOBAL, &Globals.bClientNTLMv2Auth, NULL, NULL, FLAG_ADVANCED},
 905         {"client lanman auth", P_BOOL, P_GLOBAL, &Globals.bClientLanManAuth, NULL, NULL, FLAG_ADVANCED},
 906         {"client plaintext auth", P_BOOL, P_GLOBAL, &Globals.bClientPlaintextAuth, NULL, NULL, FLAG_ADVANCED},
 907
 908         {"username", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 909         {"user", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_HIDE},
 910         {"users", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_HIDE},
 911
 912         {"invalid users", P_LIST, P_LOCAL, &sDefault.szInvalidUsers, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 913         {"valid users", P_LIST, P_LOCAL, &sDefault.szValidUsers, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 914         {"admin users", P_LIST, P_LOCAL, &sDefault.szAdminUsers, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 915         {"read list", P_LIST, P_LOCAL, &sDefault.readlist, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 916         {"write list", P_LIST, P_LOCAL, &sDefault.writelist, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 917         {"printer admin", P_LIST, P_LOCAL, &sDefault.printer_admin, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_PRINT | FLAG_DEPRECATED },
 918         {"force user", P_STRING, P_LOCAL, &sDefault.force_user, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 919         {"force group", P_STRING, P_LOCAL, &sDefault.force_group, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 920         {"group", P_STRING, P_LOCAL, &sDefault.force_group, NULL, NULL, FLAG_ADVANCED},
 921
 922         {"read only", P_BOOL, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE},
 923         {"write ok", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
 924         {"writeable", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
 925         {"writable", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
 926
 927         {"acl check permissions", P_BOOL, P_LOCAL, &sDefault.bAclCheckPermissions, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 928         {"acl group control", P_BOOL, P_LOCAL, &sDefault.bAclGroupControl, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE | FLAG_DEPRECATED },
 929         {"acl map full control", P_BOOL, P_LOCAL, &sDefault.bAclMapFullControl, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 930         {"create mask", P_OCTAL, P_LOCAL, &sDefault.iCreate_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 931         {"create mode", P_OCTAL, P_LOCAL, &sDefault.iCreate_mask, NULL, NULL, FLAG_HIDE},
 932         {"force create mode", P_OCTAL, P_LOCAL, &sDefault.iCreate_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 933         {"security mask", P_OCTAL, P_LOCAL, &sDefault.iSecurity_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 934         {"force security mode", P_OCTAL, P_LOCAL, &sDefault.iSecurity_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 935         {"directory mask", P_OCTAL, P_LOCAL, &sDefault.iDir_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 936         {"directory mode", P_OCTAL, P_LOCAL, &sDefault.iDir_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
 937         {"force directory mode", P_OCTAL, P_LOCAL, &sDefault.iDir_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 938         {"directory security mask", P_OCTAL, P_LOCAL, &sDefault.iDir_Security_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 939         {"force directory security mode", P_OCTAL, P_LOCAL, &sDefault.iDir_Security_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 940         {"force unknown acl user", P_BOOL, P_LOCAL, &sDefault.bForceUnknownAclUser, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 941         {"inherit permissions", P_BOOL, P_LOCAL, &sDefault.bInheritPerms, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 942         {"inherit acls", P_BOOL, P_LOCAL, &sDefault.bInheritACLS, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 943         {"inherit owner", P_BOOL, P_LOCAL, &sDefault.bInheritOwner, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 944         {"guest only", P_BOOL, P_LOCAL, &sDefault.bGuest_only, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 945         {"only guest", P_BOOL, P_LOCAL, &sDefault.bGuest_only, NULL, NULL, FLAG_HIDE},
 946
 947         {"guest ok", P_BOOL, P_LOCAL, &sDefault.bGuest_ok, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
 948         {"public", P_BOOL, P_LOCAL, &sDefault.bGuest_ok, NULL, NULL, FLAG_HIDE},
 949
 950         {"only user", P_BOOL, P_LOCAL, &sDefault.bOnlyUser, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_DEPRECATED},
 951         {"hosts allow", P_LIST, P_LOCAL, &sDefault.szHostsallow, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
 952         {"allow hosts", P_LIST, P_LOCAL, &sDefault.szHostsallow, NULL, NULL, FLAG_HIDE},
 953         {"hosts deny", P_LIST, P_LOCAL, &sDefault.szHostsdeny, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
 954         {"deny hosts", P_LIST, P_LOCAL, &sDefault.szHostsdeny, NULL, NULL, FLAG_HIDE},
 955         {"preload modules", P_LIST, P_GLOBAL, &Globals.szPreloadModules, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
 956         {"use kerberos keytab", P_BOOL, P_GLOBAL, &Globals.bUseKerberosKeytab, NULL, NULL, FLAG_ADVANCED},
 957
 958         {N_("Logging Options"), P_SEP, P_SEPARATOR},
 959
 960         {"log level", P_STRING, P_GLOBAL, &Globals.szLogLevel, handle_debug_list, NULL, FLAG_ADVANCED},
 961         {"debuglevel", P_STRING, P_GLOBAL, &Globals.szLogLevel, handle_debug_list, NULL, FLAG_HIDE},
 962         {"syslog", P_INTEGER, P_GLOBAL, &Globals.syslog, NULL, NULL, FLAG_ADVANCED},
 963         {"syslog only", P_BOOL, P_GLOBAL, &Globals.bSyslogOnly, NULL, NULL, FLAG_ADVANCED},
 964         {"log file", P_STRING, P_GLOBAL, &Globals.szLogFile, NULL, NULL, FLAG_ADVANCED},
 965
 966         {"max log size", P_INTEGER, P_GLOBAL, &Globals.max_log_size, NULL, NULL, FLAG_ADVANCED},
 967         {"debug timestamp", P_BOOL, P_GLOBAL, &Globals.bTimestampLogs, NULL, NULL, FLAG_ADVANCED},
 968         {"timestamp logs", P_BOOL, P_GLOBAL, &Globals.bTimestampLogs, NULL, NULL, FLAG_ADVANCED},
 969         {"debug prefix timestamp", P_BOOL, P_GLOBAL, &Globals.bDebugPrefixTimestamp, NULL, NULL, FLAG_ADVANCED},
 970         {"debug hires timestamp", P_BOOL, P_GLOBAL, &Globals.bDebugHiresTimestamp, NULL, NULL, FLAG_ADVANCED},
 971         {"debug pid", P_BOOL, P_GLOBAL, &Globals.bDebugPid, NULL, NULL, FLAG_ADVANCED},
 972         {"debug uid", P_BOOL, P_GLOBAL, &Globals.bDebugUid, NULL, NULL, FLAG_ADVANCED},
 973         {"enable core files", P_BOOL, P_GLOBAL, &Globals.bEnableCoreFiles, NULL, NULL, FLAG_ADVANCED},
 974
 975         {N_("Protocol Options"), P_SEP, P_SEPARATOR},
 976
 977         {"allocation roundup size", P_INTEGER, P_LOCAL, &sDefault.iallocation_roundup_size, NULL, NULL, FLAG_ADVANCED},
 978         {"aio read size", P_INTEGER, P_LOCAL, &sDefault.iAioReadSize, NULL, NULL, FLAG_ADVANCED},
 979         {"aio write size", P_INTEGER, P_LOCAL, &sDefault.iAioWriteSize, NULL, NULL, FLAG_ADVANCED},
 980         {"smb ports", P_STRING, P_GLOBAL, &Globals.smb_ports, NULL, NULL, FLAG_ADVANCED},
 981         {"large readwrite", P_BOOL, P_GLOBAL, &Globals.bLargeReadwrite, NULL, NULL, FLAG_ADVANCED},
 982         {"max protocol", P_ENUM, P_GLOBAL, &Globals.maxprotocol, NULL, enum_protocol, FLAG_ADVANCED},
 983         {"protocol", P_ENUM, P_GLOBAL, &Globals.maxprotocol, NULL, enum_protocol, FLAG_ADVANCED},
 984         {"min protocol", P_ENUM, P_GLOBAL, &Globals.minprotocol, NULL, enum_protocol, FLAG_ADVANCED},
 985         {"read bmpx", P_BOOL, P_GLOBAL, &Globals.bReadbmpx, NULL, NULL, FLAG_ADVANCED},
 986         {"read raw", P_BOOL, P_GLOBAL, &Globals.bReadRaw, NULL, NULL, FLAG_ADVANCED},
 987         {"write raw", P_BOOL, P_GLOBAL, &Globals.bWriteRaw, NULL, NULL, FLAG_ADVANCED},
 988         {"disable netbios", P_BOOL, P_GLOBAL, &Globals.bDisableNetbios, NULL, NULL, FLAG_ADVANCED},
 989         {"reset on zero vc", P_BOOL, P_GLOBAL, &Globals.bResetOnZeroVC, NULL, NULL, FLAG_ADVANCED},
 990
 991         {"acl compatibility", P_ENUM, P_GLOBAL, &Globals.iAclCompat, NULL,  enum_acl_compat_vals, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 992         {"defer sharing violations", P_BOOL, P_GLOBAL, &Globals.bDeferSharingViolations, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
 993         {"ea support", P_BOOL, P_LOCAL, &sDefault.bEASupport, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 994         {"nt acl support", P_BOOL, P_LOCAL, &sDefault.bNTAclSupport, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 995         {"nt pipe support", P_BOOL, P_GLOBAL, &Globals.bNTPipeSupport, NULL, NULL, FLAG_ADVANCED},
 996         {"nt status support", P_BOOL, P_GLOBAL, &Globals.bNTStatusSupport, NULL, NULL, FLAG_ADVANCED},
 997         {"profile acls", P_BOOL, P_LOCAL, &sDefault.bProfileAcls, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 998
 999         {"announce version", P_STRING, P_GLOBAL, &Globals.szAnnounceVersion, NULL, NULL, FLAG_ADVANCED},
1000         {"announce as", P_ENUM, P_GLOBAL, &Globals.announce_as, NULL, enum_announce_as,  FLAG_ADVANCED},
1001         {"map acl inherit", P_BOOL, P_LOCAL, &sDefault.bMap_acl_inherit, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1002         {"afs share", P_BOOL, P_LOCAL, &sDefault.bAfs_Share, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1003         {"max mux", P_INTEGER, P_GLOBAL, &Globals.max_mux, NULL, NULL, FLAG_ADVANCED},
1004         {"max xmit", P_INTEGER, P_GLOBAL, &Globals.max_xmit, NULL, NULL, FLAG_ADVANCED},
1005
1006         {"name resolve order", P_STRING, P_GLOBAL, &Globals.szNameResolveOrder, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
1007         {"max ttl", P_INTEGER, P_GLOBAL, &Globals.max_ttl, NULL, NULL, FLAG_ADVANCED},
1008         {"max wins ttl", P_INTEGER, P_GLOBAL, &Globals.max_wins_ttl, NULL, NULL, FLAG_ADVANCED},
1009         {"min wins ttl", P_INTEGER, P_GLOBAL, &Globals.min_wins_ttl, NULL, NULL, FLAG_ADVANCED},
1010         {"time server", P_BOOL, P_GLOBAL, &Globals.bTimeServer, NULL, NULL, FLAG_ADVANCED},
1011         {"unix extensions", P_BOOL, P_GLOBAL, &Globals.bUnixExtensions, NULL, NULL, FLAG_ADVANCED},
1012         {"use spnego", P_BOOL, P_GLOBAL, &Globals.bUseSpnego, NULL, NULL, FLAG_ADVANCED},
1013         {"client signing", P_ENUM, P_GLOBAL, &Globals.client_signing, NULL, enum_smb_signing_vals, FLAG_ADVANCED},
1014         {"server signing", P_ENUM, P_GLOBAL, &Globals.server_signing, NULL, enum_smb_signing_vals, FLAG_ADVANCED},
1015         {"client use spnego", P_BOOL, P_GLOBAL, &Globals.bClientUseSpnego, NULL, NULL, FLAG_ADVANCED},
1016
1017         {"enable asu support", P_BOOL, P_GLOBAL, &Globals.bASUSupport, NULL, NULL, FLAG_ADVANCED},
1018         {"svcctl list", P_LIST, P_GLOBAL, &Globals.szServicesList, NULL, NULL, FLAG_ADVANCED},
1019
1020         {N_("Tuning Options"), P_SEP, P_SEPARATOR},
1021
1022         {"block size", P_INTEGER, P_LOCAL, &sDefault.iBlock_size, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1023         {"deadtime", P_INTEGER, P_GLOBAL, &Globals.deadtime, NULL, NULL, FLAG_ADVANCED},
1024         {"getwd cache", P_BOOL, P_GLOBAL, &use_getwd_cache, NULL, NULL, FLAG_ADVANCED},
1025         {"keepalive", P_INTEGER, P_GLOBAL, &Globals.iKeepalive, NULL, NULL, FLAG_ADVANCED},
1026         {"change notify", P_BOOL, P_LOCAL, &sDefault.bChangeNotify, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE },
1027         {"kernel change notify", P_BOOL, P_LOCAL, &sDefault.bKernelChangeNotify, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE },
1028
1029         {"lpq cache time", P_INTEGER, P_GLOBAL, &Globals.lpqcachetime, NULL, NULL, FLAG_ADVANCED},
1030         {"max smbd processes", P_INTEGER, P_GLOBAL, &Globals.iMaxSmbdProcesses, NULL, NULL, FLAG_ADVANCED},
1031         {"max connections", P_INTEGER, P_LOCAL, &sDefault.iMaxConnections, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1032         {"paranoid server security", P_BOOL, P_GLOBAL, &Globals.paranoid_server_security, NULL, NULL, FLAG_ADVANCED},
1033         {"max disk size", P_INTEGER, P_GLOBAL, &Globals.maxdisksize, NULL, NULL, FLAG_ADVANCED},
1034         {"max open files", P_INTEGER, P_GLOBAL, &Globals.max_open_files, NULL, NULL, FLAG_ADVANCED},
1035         {"min print space", P_INTEGER, P_LOCAL, &sDefault.iMinPrintSpace, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1036         {"open files database hash size", P_INTEGER, P_GLOBAL, &Globals.open_files_db_hash_size, NULL, NULL, FLAG_ADVANCED},
1037
1038         {"socket options", P_GSTRING, P_GLOBAL, user_socket_options, NULL, NULL, FLAG_ADVANCED},
1039         {"strict allocate", P_BOOL, P_LOCAL, &sDefault.bStrictAllocate, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1040         {"strict sync", P_BOOL, P_LOCAL, &sDefault.bStrictSync, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1041         {"sync always", P_BOOL, P_LOCAL, &sDefault.bSyncAlways, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1042         {"use mmap", P_BOOL, P_GLOBAL, &Globals.bUseMmap, NULL, NULL, FLAG_ADVANCED},
1043         {"use sendfile", P_BOOL, P_LOCAL, &sDefault.bUseSendfile, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1044         {"hostname lookups", P_BOOL, P_GLOBAL, &Globals.bHostnameLookups, NULL, NULL, FLAG_ADVANCED},
1045         {"write cache size", P_INTEGER, P_LOCAL, &sDefault.iWriteCacheSize, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_DEPRECATED},
1046
1047         {"name cache timeout", P_INTEGER, P_GLOBAL, &Globals.name_cache_timeout, NULL, NULL, FLAG_ADVANCED},
1048         {"ctdbd socket", P_STRING, P_GLOBAL, &Globals.ctdbdSocket, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1049         {"clustering", P_BOOL, P_GLOBAL, &Globals.clustering, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1050
1051         {N_("Printing Options"), P_SEP, P_SEPARATOR},
1052
1053         {"max reported print jobs", P_INTEGER, P_LOCAL, &sDefault.iMaxReportedPrintJobs, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1054         {"max print jobs", P_INTEGER, P_LOCAL, &sDefault.iMaxPrintJobs, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1055         {"load printers", P_BOOL, P_GLOBAL, &Globals.bLoadPrinters, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1056         {"printcap cache time", P_INTEGER, P_GLOBAL, &Globals.PrintcapCacheTime, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1057         {"printcap name", P_STRING, P_GLOBAL, &Globals.szPrintcapname, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1058         {"printcap", P_STRING, P_GLOBAL, &Globals.szPrintcapname, NULL, NULL, FLAG_HIDE},
1059         {"printable", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1060         {"print ok", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_HIDE},
1061         {"printing", P_ENUM, P_LOCAL, &sDefault.iPrinting, handle_printing, enum_printing, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1062         {"cups options", P_STRING, P_LOCAL, &sDefault.szCupsOptions, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1063         {"cups server", P_STRING, P_GLOBAL, &Globals.szCupsServer, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1064         {"iprint server", P_STRING, P_GLOBAL, &Globals.szIPrintServer, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1065         {"print command", P_STRING, P_LOCAL, &sDefault.szPrintcommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1066         {"disable spoolss", P_BOOL, P_GLOBAL, &Globals.bDisableSpoolss, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1067         {"enable spoolss", P_BOOLREV, P_GLOBAL, &Globals.bDisableSpoolss, NULL, NULL, FLAG_HIDE},
1068         {"lpq command", P_STRING, P_LOCAL, &sDefault.szLpqcommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1069         {"lprm command", P_STRING, P_LOCAL, &sDefault.szLprmcommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1070         {"lppause command", P_STRING, P_LOCAL, &sDefault.szLppausecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1071         {"lpresume command", P_STRING, P_LOCAL, &sDefault.szLpresumecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1072         {"queuepause command", P_STRING, P_LOCAL, &sDefault.szQueuepausecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1073         {"queueresume command", P_STRING, P_LOCAL, &sDefault.szQueueresumecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1074
1075         {"addport command", P_STRING, P_GLOBAL, &Globals.szAddPortCommand, NULL, NULL, FLAG_ADVANCED},
1076         {"enumports command", P_STRING, P_GLOBAL, &Globals.szEnumPortsCommand, NULL, NULL, FLAG_ADVANCED},
1077         {"addprinter command", P_STRING, P_GLOBAL, &Globals.szAddPrinterCommand, NULL, NULL, FLAG_ADVANCED},
1078         {"deleteprinter command", P_STRING, P_GLOBAL, &Globals.szDeletePrinterCommand, NULL, NULL, FLAG_ADVANCED},
1079         {"show add printer wizard", P_BOOL, P_GLOBAL, &Globals.bMsAddPrinterWizard, NULL, NULL, FLAG_ADVANCED},
1080         {"os2 driver map", P_STRING, P_GLOBAL, &Globals.szOs2DriverMap, NULL, NULL, FLAG_ADVANCED},
1081
1082         {"printer name", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1083         {"printer", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_HIDE},
1084         {"use client driver", P_BOOL, P_LOCAL, &sDefault.bUseClientDriver, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1085         {"default devmode", P_BOOL, P_LOCAL, &sDefault.bDefaultDevmode, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1086         {"force printername", P_BOOL, P_LOCAL, &sDefault.bForcePrintername, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1087         {"printjob username", P_STRING, P_LOCAL, &sDefault.szPrintjobUsername, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1088
1089         {N_("Filename Handling"), P_SEP, P_SEPARATOR},
1090         {"mangling method", P_STRING, P_GLOBAL, &Globals.szManglingMethod, NULL, NULL, FLAG_ADVANCED},
1091         {"mangle prefix", P_INTEGER, P_GLOBAL, &Globals.mangle_prefix, NULL, NULL, FLAG_ADVANCED},
1092
1093         {"default case", P_ENUM, P_LOCAL, &sDefault.iDefaultCase, NULL, enum_case, FLAG_ADVANCED | FLAG_SHARE},
1094         {"case sensitive", P_ENUM, P_LOCAL, &sDefault.iCaseSensitive, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1095         {"casesignames", P_ENUM, P_LOCAL, &sDefault.iCaseSensitive, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL | FLAG_HIDE},
1096         {"preserve case", P_BOOL, P_LOCAL, &sDefault.bCasePreserve, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1097         {"short preserve case", P_BOOL, P_LOCAL, &sDefault.bShortCasePreserve, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1098         {"mangling char", P_CHAR, P_LOCAL, &sDefault.magic_char, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1099         {"hide dot files", P_BOOL, P_LOCAL, &sDefault.bHideDotFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1100         {"hide special files", P_BOOL, P_LOCAL, &sDefault.bHideSpecialFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1101         {"hide unreadable", P_BOOL, P_LOCAL, &sDefault.bHideUnReadable, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1102         {"hide unwriteable files", P_BOOL, P_LOCAL, &sDefault.bHideUnWriteableFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1103         {"delete veto files", P_BOOL, P_LOCAL, &sDefault.bDeleteVetoFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1104         {"veto files", P_STRING, P_LOCAL, &sDefault.szVetoFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL },
1105         {"hide files", P_STRING, P_LOCAL, &sDefault.szHideFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL },
1106         {"veto oplock files", P_STRING, P_LOCAL, &sDefault.szVetoOplockFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL },
1107         {"map archive", P_BOOL, P_LOCAL, &sDefault.bMap_archive, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1108         {"map hidden", P_BOOL, P_LOCAL, &sDefault.bMap_hidden, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1109         {"map system", P_BOOL, P_LOCAL, &sDefault.bMap_system, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1110         {"map readonly", P_ENUM, P_LOCAL, &sDefault.iMap_readonly, NULL, enum_map_readonly, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1111         {"mangled names", P_BOOL, P_LOCAL, &sDefault.bMangledNames, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1112         {"mangled map", P_STRING, P_LOCAL, &sDefault.szMangledMap, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL | FLAG_DEPRECATED },
1113         {"max stat cache size", P_INTEGER, P_GLOBAL, &Globals.iMaxStatCacheSize, NULL, NULL, FLAG_ADVANCED},
1114         {"stat cache", P_BOOL, P_GLOBAL, &Globals.bStatCache, NULL, NULL, FLAG_ADVANCED},
1115         {"store dos attributes", P_BOOL, P_LOCAL, &sDefault.bStoreDosAttributes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1116         {"dmapi support", P_BOOL, P_LOCAL, &sDefault.bDmapiSupport, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1117
1118
1119         {N_("Domain Options"), P_SEP, P_SEPARATOR},
1120
1121         {"machine password timeout", P_INTEGER, P_GLOBAL, &Globals.machine_password_timeout, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
1122
1123         {N_("Logon Options"), P_SEP, P_SEPARATOR},
1124
1125         {"add user script", P_STRING, P_GLOBAL, &Globals.szAddUserScript, NULL, NULL, FLAG_ADVANCED},
1126         {"rename user script", P_STRING, P_GLOBAL, &Globals.szRenameUserScript, NULL, NULL, FLAG_ADVANCED},
1127         {"delete user script", P_STRING, P_GLOBAL, &Globals.szDelUserScript, NULL, NULL, FLAG_ADVANCED},
1128         {"add group script", P_STRING, P_GLOBAL, &Globals.szAddGroupScript, NULL, NULL, FLAG_ADVANCED},
1129         {"delete group script", P_STRING, P_GLOBAL, &Globals.szDelGroupScript, NULL, NULL, FLAG_ADVANCED},
1130         {"add user to group script", P_STRING, P_GLOBAL, &Globals.szAddUserToGroupScript, NULL, NULL, FLAG_ADVANCED},
1131         {"delete user from group script", P_STRING, P_GLOBAL, &Globals.szDelUserFromGroupScript, NULL, NULL, FLAG_ADVANCED},
1132         {"set primary group script", P_STRING, P_GLOBAL, &Globals.szSetPrimaryGroupScript, NULL, NULL, FLAG_ADVANCED},
1133         {"add machine script", P_STRING, P_GLOBAL, &Globals.szAddMachineScript, NULL, NULL, FLAG_ADVANCED},
1134         {"shutdown script", P_STRING, P_GLOBAL, &Globals.szShutdownScript, NULL, NULL, FLAG_ADVANCED},
1135         {"abort shutdown script", P_STRING, P_GLOBAL, &Globals.szAbortShutdownScript, NULL, NULL, FLAG_ADVANCED},
1136         {"username map script", P_STRING, P_GLOBAL, &Globals.szUsernameMapScript, NULL, NULL, FLAG_ADVANCED},
1137
1138         {"logon script", P_STRING, P_GLOBAL, &Globals.szLogonScript, NULL, NULL, FLAG_ADVANCED},
1139         {"logon path", P_STRING, P_GLOBAL, &Globals.szLogonPath, NULL, NULL, FLAG_ADVANCED},
1140         {"logon drive", P_STRING, P_GLOBAL, &Globals.szLogonDrive, NULL, NULL, FLAG_ADVANCED},
1141         {"logon home", P_STRING, P_GLOBAL, &Globals.szLogonHome, NULL, NULL, FLAG_ADVANCED},
1142         {"domain logons", P_BOOL, P_GLOBAL, &Globals.bDomainLogons, NULL, NULL, FLAG_ADVANCED},
1143
1144         {N_("Browse Options"), P_SEP, P_SEPARATOR},
1145
1146         {"os level", P_INTEGER, P_GLOBAL, &Globals.os_level, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED},
1147         {"lm announce", P_ENUM, P_GLOBAL, &Globals.lm_announce, NULL, enum_bool_auto, FLAG_ADVANCED},
1148         {"lm interval", P_INTEGER, P_GLOBAL, &Globals.lm_interval, NULL, NULL, FLAG_ADVANCED},
1149         {"preferred master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
1150         {"prefered master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_HIDE},
1151         {"local master", P_BOOL, P_GLOBAL, &Globals.bLocalMaster, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED},
1152         {"domain master", P_ENUM, P_GLOBAL, &Globals.bDomainMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
1153         {"browse list", P_BOOL, P_GLOBAL, &Globals.bBrowseList, NULL, NULL, FLAG_ADVANCED},
1154         {"browseable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1155         {"browsable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_HIDE},
1156         {"enhanced browsing", P_BOOL, P_GLOBAL, &Globals.enhanced_browsing, NULL, NULL, FLAG_ADVANCED},
1157
1158         {N_("WINS Options"), P_SEP, P_SEPARATOR},
1159
1160         {"dns proxy", P_BOOL, P_GLOBAL, &Globals.bDNSproxy, NULL, NULL, FLAG_ADVANCED},
1161         {"wins proxy", P_BOOL, P_GLOBAL, &Globals.bWINSproxy, NULL, NULL, FLAG_ADVANCED},
1162
1163         {"wins server", P_LIST, P_GLOBAL, &Globals.szWINSservers, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
1164         {"wins support", P_BOOL, P_GLOBAL, &Globals.bWINSsupport, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
1165         {"wins hook", P_STRING, P_GLOBAL, &Globals.szWINSHook, NULL, NULL, FLAG_ADVANCED},
1166
1167         {N_("Locking Options"), P_SEP, P_SEPARATOR},
1168
1169         {"blocking locks", P_BOOL, P_LOCAL, &sDefault.bBlockingLocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1170         {"csc policy", P_ENUM, P_LOCAL, &sDefault.iCSCPolicy, NULL, enum_csc_policy, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1171         {"fake oplocks", P_BOOL, P_LOCAL, &sDefault.bFakeOplocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1172         {"kernel oplocks", P_BOOL, P_GLOBAL, &Globals.bKernelOplocks, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1173         {"locking", P_BOOL, P_LOCAL, &sDefault.bLocking, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1174         {"lock spin time", P_INTEGER, P_GLOBAL, &Globals.iLockSpinTime, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1175
1176         {"oplocks", P_BOOL, P_LOCAL, &sDefault.bOpLocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1177         {"level2 oplocks", P_BOOL, P_LOCAL, &sDefault.bLevel2OpLocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1178         {"oplock break wait time", P_INTEGER, P_GLOBAL, &Globals.oplock_break_wait_time, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1179         {"oplock contention limit", P_INTEGER, P_LOCAL, &sDefault.iOplockContentionLimit, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1180         {"posix locking", P_BOOL, P_LOCAL, &sDefault.bPosixLocking, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1181         {"strict locking", P_ENUM, P_LOCAL, &sDefault.iStrictLocking, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1182         {"share modes", P_BOOL, P_LOCAL,  &sDefault.bShareModes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1183
1184         {N_("Ldap Options"), P_SEP, P_SEPARATOR},
1185
1186         {"ldap admin dn", P_STRING, P_GLOBAL, &Globals.szLdapAdminDn, NULL, NULL, FLAG_ADVANCED},
1187         {"ldap delete dn", P_BOOL, P_GLOBAL, &Globals.ldap_delete_dn, NULL, NULL, FLAG_ADVANCED},
1188         {"ldap group suffix", P_STRING, P_GLOBAL, &Globals.szLdapGroupSuffix, NULL, NULL, FLAG_ADVANCED},
1189         {"ldap idmap suffix", P_STRING, P_GLOBAL, &Globals.szLdapIdmapSuffix, NULL, NULL, FLAG_ADVANCED},
1190         {"ldap machine suffix", P_STRING, P_GLOBAL, &Globals.szLdapMachineSuffix, NULL, NULL, FLAG_ADVANCED},
1191         {"ldap passwd sync", P_ENUM, P_GLOBAL, &Globals.ldap_passwd_sync, NULL, enum_ldap_passwd_sync, FLAG_ADVANCED},
1192         {"ldap password sync", P_ENUM, P_GLOBAL, &Globals.ldap_passwd_sync, NULL, enum_ldap_passwd_sync, FLAG_HIDE},
1193         {"ldap replication sleep", P_INTEGER, P_GLOBAL, &Globals.ldap_replication_sleep, NULL, NULL, FLAG_ADVANCED},
1194         {"ldap suffix", P_STRING, P_GLOBAL, &Globals.szLdapSuffix, NULL, NULL, FLAG_ADVANCED},
1195         {"ldap ssl", P_ENUM, P_GLOBAL, &Globals.ldap_ssl, NULL, enum_ldap_ssl, FLAG_ADVANCED},
1196         {"ldap timeout", P_INTEGER, P_GLOBAL, &Globals.ldap_timeout, NULL, NULL, FLAG_ADVANCED},
1197         {"ldap page size", P_INTEGER, P_GLOBAL, &Globals.ldap_page_size, NULL, NULL, FLAG_ADVANCED},
1198         {"ldap user suffix", P_STRING, P_GLOBAL, &Globals.szLdapUserSuffix, NULL, NULL, FLAG_ADVANCED},
1199
1200         {N_("Miscellaneous Options"), P_SEP, P_SEPARATOR},
1201         {"add share command", P_STRING, P_GLOBAL, &Globals.szAddShareCommand, NULL, NULL, FLAG_ADVANCED},
1202         {"change share command", P_STRING, P_GLOBAL, &Globals.szChangeShareCommand, NULL, NULL, FLAG_ADVANCED},
1203         {"delete share command", P_STRING, P_GLOBAL, &Globals.szDeleteShareCommand, NULL, NULL, FLAG_ADVANCED},
1204
1205         {N_("EventLog Options"), P_SEP, P_SEPARATOR},
1206         {"eventlog list",  P_LIST, P_GLOBAL, &Globals.szEventLogs, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
1207
1208         {"config file", P_STRING, P_GLOBAL, &Globals.szConfigFile, NULL, NULL, FLAG_HIDE},
1209         {"preload", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED},
1210         {"auto services", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED},
1211         {"lock directory", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_ADVANCED},
1212         {"lock dir", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_HIDE},
1213         {"pid directory", P_STRING, P_GLOBAL, &Globals.szPidDir, NULL, NULL, FLAG_ADVANCED},
1214 #ifdef WITH_UTMP
1215         {"utmp directory", P_STRING, P_GLOBAL, &Globals.szUtmpDir, NULL, NULL, FLAG_ADVANCED},
1216         {"wtmp directory", P_STRING, P_GLOBAL, &Globals.szWtmpDir, NULL, NULL, FLAG_ADVANCED},
1217         {"utmp", P_BOOL, P_GLOBAL, &Globals.bUtmp, NULL, NULL, FLAG_ADVANCED},
1218 #endif
1219
1220         {"default service", P_STRING, P_GLOBAL, &Globals.szDefaultService, NULL, NULL, FLAG_ADVANCED},
1221         {"default", P_STRING, P_GLOBAL, &Globals.szDefaultService, NULL, NULL, FLAG_ADVANCED},
1222         {"message command", P_STRING, P_GLOBAL, &Globals.szMsgCommand, NULL, NULL, FLAG_ADVANCED},
1223         {"dfree cache time", P_INTEGER, P_LOCAL, &sDefault.iDfreeCacheTime, NULL, NULL, FLAG_ADVANCED},
1224         {"dfree command", P_STRING, P_LOCAL, &sDefault.szDfree, NULL, NULL, FLAG_ADVANCED},
1225         {"get quota command", P_STRING, P_GLOBAL, &Globals.szGetQuota, NULL, NULL, FLAG_ADVANCED},
1226         {"set quota command", P_STRING, P_GLOBAL, &Globals.szSetQuota, NULL, NULL, FLAG_ADVANCED},
1227         {"remote announce", P_STRING, P_GLOBAL, &Globals.szRemoteAnnounce, NULL, NULL, FLAG_ADVANCED},
1228         {"remote browse sync", P_STRING, P_GLOBAL, &Globals.szRemoteBrowseSync, NULL, NULL, FLAG_ADVANCED},
1229         {"socket address", P_STRING, P_GLOBAL, &Globals.szSocketAddress, NULL, NULL, FLAG_ADVANCED},
1230         {"homedir map", P_STRING, P_GLOBAL, &Globals.szNISHomeMapName, NULL, NULL, FLAG_ADVANCED},
1231         {"afs username map", P_STRING, P_GLOBAL, &Globals.szAfsUsernameMap, NULL, NULL, FLAG_ADVANCED},
1232         {"afs token lifetime", P_INTEGER, P_GLOBAL, &Globals.iAfsTokenLifetime, NULL, NULL, FLAG_ADVANCED},
1233         {"log nt token command", P_STRING, P_GLOBAL, &Globals.szLogNtTokenCommand, NULL, NULL, FLAG_ADVANCED},
1234         {"time offset", P_INTEGER, P_GLOBAL, &extra_time_offset, NULL, NULL, FLAG_ADVANCED},
1235         {"NIS homedir", P_BOOL, P_GLOBAL, &Globals.bNISHomeMap, NULL, NULL, FLAG_ADVANCED},
1236         {"-valid", P_BOOL, P_LOCAL, &sDefault.valid, NULL, NULL, FLAG_HIDE},
1237
1238         {"copy", P_STRING, P_LOCAL, &sDefault.szCopy, handle_copy, NULL, FLAG_HIDE},
1239         {"include", P_STRING, P_LOCAL, &sDefault.szInclude, handle_include, NULL, FLAG_HIDE},
1240         {"preexec", P_STRING, P_LOCAL, &sDefault.szPreExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1241         {"exec", P_STRING, P_LOCAL, &sDefault.szPreExec, NULL, NULL, FLAG_ADVANCED},
1242
1243         {"preexec close", P_BOOL, P_LOCAL, &sDefault.bPreexecClose, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1244         {"postexec", P_STRING, P_LOCAL, &sDefault.szPostExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1245         {"root preexec", P_STRING, P_LOCAL, &sDefault.szRootPreExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1246         {"root preexec close", P_BOOL, P_LOCAL, &sDefault.bRootpreexecClose, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1247         {"root postexec", P_STRING, P_LOCAL, &sDefault.szRootPostExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1248         {"available", P_BOOL, P_LOCAL, &sDefault.bAvailable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1249         {"registry shares", P_BOOL, P_GLOBAL, &Globals.bRegistryShares, NULL, NULL, FLAG_ADVANCED},
1250         {"usershare allow guests", P_BOOL, P_GLOBAL, &Globals.bUsershareAllowGuests, NULL, NULL, FLAG_ADVANCED},
1251         {"usershare max shares", P_INTEGER, P_GLOBAL, &Globals.iUsershareMaxShares, NULL, NULL, FLAG_ADVANCED},
1252         {"usershare owner only", P_BOOL, P_GLOBAL, &Globals.bUsershareOwnerOnly, NULL, NULL, FLAG_ADVANCED},
1253         {"usershare path", P_STRING, P_GLOBAL, &Globals.szUsersharePath, NULL, NULL, FLAG_ADVANCED},
1254         {"usershare prefix allow list", P_LIST, P_GLOBAL, &Globals.szUsersharePrefixAllowList, NULL, NULL, FLAG_ADVANCED},
1255         {"usershare prefix deny list", P_LIST, P_GLOBAL, &Globals.szUsersharePrefixDenyList, NULL, NULL, FLAG_ADVANCED},
1256         {"usershare template share", P_STRING, P_GLOBAL, &Globals.szUsershareTemplateShare, NULL, NULL, FLAG_ADVANCED},
1257         {"volume", P_STRING, P_LOCAL, &sDefault.volume, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE },
1258         {"fstype", P_STRING, P_LOCAL, &sDefault.fstype, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1259         {"set directory", P_BOOLREV, P_LOCAL, &sDefault.bNo_set_dir, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1260         {"wide links", P_BOOL, P_LOCAL, &sDefault.bWidelinks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1261         {"follow symlinks", P_BOOL, P_LOCAL, &sDefault.bSymlinks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1262         {"dont descend", P_STRING, P_LOCAL, &sDefault.szDontdescend, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1263         {"magic script", P_STRING, P_LOCAL, &sDefault.szMagicScript, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1264         {"magic output", P_STRING, P_LOCAL, &sDefault.szMagicOutput, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1265         {"delete readonly", P_BOOL, P_LOCAL, &sDefault.bDeleteReadonly, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1266         {"dos filemode", P_BOOL, P_LOCAL, &sDefault.bDosFilemode, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1267         {"dos filetimes", P_BOOL, P_LOCAL, &sDefault.bDosFiletimes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1268         {"dos filetime resolution", P_BOOL, P_LOCAL, &sDefault.bDosFiletimeResolution, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1269
1270         {"fake directory create times", P_BOOL, P_LOCAL, &sDefault.bFakeDirCreateTimes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1271         {"panic action", P_STRING, P_GLOBAL, &Globals.szPanicAction, NULL, NULL, FLAG_ADVANCED},
1272
1273         {N_("VFS module options"), P_SEP, P_SEPARATOR},
1274
1275         {"vfs objects", P_LIST, P_LOCAL, &sDefault.szVfsObjects, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1276         {"vfs object", P_LIST, P_LOCAL, &sDefault.szVfsObjects, NULL, NULL, FLAG_HIDE},
1277
1278
1279         {"msdfs root", P_BOOL, P_LOCAL, &sDefault.bMSDfsRoot, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1280         {"msdfs proxy", P_STRING, P_LOCAL, &sDefault.szMSDfsProxy, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1281         {"host msdfs", P_BOOL, P_GLOBAL, &Globals.bHostMSDfs, NULL, NULL, FLAG_ADVANCED},
1282
1283         {N_("Winbind options"), P_SEP, P_SEPARATOR},
1284
1285         {"passdb expand explicit", P_BOOL, P_GLOBAL, &Globals.bPassdbExpandExplicit, NULL, NULL, FLAG_ADVANCED},
1286         {"idmap domains", P_LIST, P_GLOBAL, &Globals.szIdmapDomains, NULL, NULL, FLAG_ADVANCED},
1287         {"idmap backend", P_LIST, P_GLOBAL, &Globals.szIdmapBackend, NULL, NULL, FLAG_ADVANCED },
1288         {"idmap alloc backend", P_STRING, P_GLOBAL, &Globals.szIdmapAllocBackend, NULL, NULL, FLAG_ADVANCED},
1289         {"idmap cache time", P_INTEGER, P_GLOBAL, &Globals.iIdmapCacheTime, NULL, NULL, FLAG_ADVANCED},
1290         {"idmap negative cache time", P_INTEGER, P_GLOBAL, &Globals.iIdmapNegativeCacheTime, NULL, NULL, FLAG_ADVANCED},
1291         {"idmap uid", P_STRING, P_GLOBAL, &Globals.szIdmapUID, handle_idmap_uid, NULL, FLAG_ADVANCED },
1292         {"winbind uid", P_STRING, P_GLOBAL, &Globals.szIdmapUID, handle_idmap_uid, NULL, FLAG_HIDE },
1293         {"idmap gid", P_STRING, P_GLOBAL, &Globals.szIdmapGID, handle_idmap_gid, NULL, FLAG_ADVANCED },
1294         {"winbind gid", P_STRING, P_GLOBAL, &Globals.szIdmapGID, handle_idmap_gid, NULL, FLAG_HIDE },
1295         {"template homedir", P_STRING, P_GLOBAL, &Globals.szTemplateHomedir, NULL, NULL, FLAG_ADVANCED},
1296         {"template shell", P_STRING, P_GLOBAL, &Globals.szTemplateShell, NULL, NULL, FLAG_ADVANCED},
1297         {"winbind separator", P_STRING, P_GLOBAL, &Globals.szWinbindSeparator, NULL, NULL, FLAG_ADVANCED},
1298         {"winbind cache time", P_INTEGER, P_GLOBAL, &Globals.winbind_cache_time, NULL, NULL, FLAG_ADVANCED},
1299         {"winbind enum users", P_BOOL, P_GLOBAL, &Globals.bWinbindEnumUsers, NULL, NULL, FLAG_ADVANCED},
1300         {"winbind enum groups", P_BOOL, P_GLOBAL, &Globals.bWinbindEnumGroups, NULL, NULL, FLAG_ADVANCED},
1301         {"winbind use default domain", P_BOOL, P_GLOBAL, &Globals.bWinbindUseDefaultDomain, NULL, NULL, FLAG_ADVANCED},
1302         {"winbind trusted domains only", P_BOOL, P_GLOBAL, &Globals.bWinbindTrustedDomainsOnly, NULL, NULL, FLAG_ADVANCED},
1303         {"winbind nested groups", P_BOOL, P_GLOBAL, &Globals.bWinbindNestedGroups, NULL, NULL, FLAG_ADVANCED},
1304         {"winbind expand groups", P_INTEGER, P_GLOBAL, &Globals.winbind_expand_groups, NULL, NULL, FLAG_ADVANCED},
1305         {"winbind nss info", P_LIST, P_GLOBAL, &Globals.szWinbindNssInfo, NULL, NULL, FLAG_ADVANCED},
1306         {"winbind refresh tickets", P_BOOL, P_GLOBAL, &Globals.bWinbindRefreshTickets, NULL, NULL, FLAG_ADVANCED},
1307         {"winbind offline logon", P_BOOL, P_GLOBAL, &Globals.bWinbindOfflineLogon, NULL, NULL, FLAG_ADVANCED},
1308         {"winbind normalize names", P_BOOL, P_GLOBAL, &Globals.bWinbindNormalizeNames, NULL, NULL, FLAG_ADVANCED},
1309         {"winbind rpc only", P_BOOL, P_GLOBAL, &Globals.bWinbindRpcOnly, NULL, NULL, FLAG_ADVANCED},
1310
1311         {NULL,  P_BOOL,  P_NONE,  NULL,  NULL,  NULL,  0}
1312 };
1313
1314 /***************************************************************************
1315  Initialise the sDefault parameter structure for the printer values.
1316 ***************************************************************************/
1317
1318 static void init_printer_values(service *pService)
1319 {
1320         /* choose defaults depending on the type of printing */
1321         switch (pService->iPrinting) {
1322                 case PRINT_BSD:
1323                 case PRINT_AIX:
1324                 case PRINT_LPRNT:
1325                 case PRINT_LPROS2:
1326                         string_set(&pService->szLpqcommand, "lpq -P'%p'");
1327                         string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
1328                         string_set(&pService->szPrintcommand, "lpr -r -P'%p' %s");
1329                         break;
1330
1331                 case PRINT_LPRNG:
1332                 case PRINT_PLP:
1333                         string_set(&pService->szLpqcommand, "lpq -P'%p'");
1334                         string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
1335                         string_set(&pService->szPrintcommand, "lpr -r -P'%p' %s");
1336                         string_set(&pService->szQueuepausecommand, "lpc stop '%p'");
1337                         string_set(&pService->szQueueresumecommand, "lpc start '%p'");
1338                         string_set(&pService->szLppausecommand, "lpc hold '%p' %j");
1339                         string_set(&pService->szLpresumecommand, "lpc release '%p' %j");
1340                         break;
1341
1342                 case PRINT_CUPS:
1343                 case PRINT_IPRINT:
1344 #ifdef HAVE_CUPS
1345                         /* set the lpq command to contain the destination printer
1346                            name only.  This is used by cups_queue_get() */
1347                         string_set(&pService->szLpqcommand, "%p");
1348                         string_set(&pService->szLprmcommand, "");
1349                         string_set(&pService->szPrintcommand, "");
1350                         string_set(&pService->szLppausecommand, "");
1351                         string_set(&pService->szLpresumecommand, "");
1352                         string_set(&pService->szQueuepausecommand, "");
1353                         string_set(&pService->szQueueresumecommand, "");
1354 #else
1355                         string_set(&pService->szLpqcommand, "lpq -P'%p'");
1356                         string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
1357                         string_set(&pService->szPrintcommand, "lpr -P'%p' %s; rm %s");
1358                         string_set(&pService->szLppausecommand, "lp -i '%p-%j' -H hold");
1359                         string_set(&pService->szLpresumecommand, "lp -i '%p-%j' -H resume");
1360                         string_set(&pService->szQueuepausecommand, "disable '%p'");
1361                         string_set(&pService->szQueueresumecommand, "enable '%p'");
1362 #endif /* HAVE_CUPS */
1363                         break;
1364
1365                 case PRINT_SYSV:
1366                 case PRINT_HPUX:
1367                         string_set(&pService->szLpqcommand, "lpstat -o%p");
1368                         string_set(&pService->szLprmcommand, "cancel %p-%j");
1369                         string_set(&pService->szPrintcommand, "lp -c -d%p %s; rm %s");
1370                         string_set(&pService->szQueuepausecommand, "disable %p");
1371                         string_set(&pService->szQueueresumecommand, "enable %p");
1372 #ifndef HPUX
1373                         string_set(&pService->szLppausecommand, "lp -i %p-%j -H hold");
1374                         string_set(&pService->szLpresumecommand, "lp -i %p-%j -H resume");
1375 #endif /* HPUX */
1376                         break;
1377
1378                 case PRINT_QNX:
1379                         string_set(&pService->szLpqcommand, "lpq -P%p");
1380                         string_set(&pService->szLprmcommand, "lprm -P%p %j");
1381                         string_set(&pService->szPrintcommand, "lp -r -P%p %s");
1382                         break;
1383
1384 #ifdef DEVELOPER
1385         case PRINT_TEST:
1386         case PRINT_VLP:
1387                 string_set(&pService->szPrintcommand, "vlp print %p %s");
1388                 string_set(&pService->szLpqcommand, "vlp lpq %p");
1389                 string_set(&pService->szLprmcommand, "vlp lprm %p %j");
1390                 string_set(&pService->szLppausecommand, "vlp lppause %p %j");
1391                 string_set(&pService->szLpresumecommand, "vlp lpresum %p %j");
1392                 string_set(&pService->szQueuepausecommand, "vlp queuepause %p");
1393                 string_set(&pService->szQueueresumecommand, "vlp queueresume %p");
1394                 break;
1395 #endif /* DEVELOPER */
1396
1397         }
1398 }
1399
1400 /***************************************************************************
1401  Initialise the global parameter structure.
1402 ***************************************************************************/
1403
1404 static void init_globals(BOOL first_time_only)
1405 {
1406         static BOOL done_init = False;
1407         pstring s;
1408
1409         /* If requested to initialize only once and we've already done it... */
1410         if (first_time_only && done_init) {
1411                 /* ... then we have nothing more to do */
1412                 return;
1413         }
1414
1415         if (!done_init) {
1416                 int i;
1417
1418                 /* The logfile can be set before this is invoked. Free it if so. */
1419                 if (Globals.szLogFile != NULL) {
1420                         string_free(&Globals.szLogFile);
1421                         Globals.szLogFile = NULL;
1422                 }
1423
1424                 memset((void *)&Globals, '\0', sizeof(Globals));
1425
1426                 for (i = 0; parm_table[i].label; i++)
1427                         if ((parm_table[i].type == P_STRING ||
1428                              parm_table[i].type == P_USTRING) &&
1429                             parm_table[i].ptr)
1430                                 string_set((char **)parm_table[i].ptr, "");
1431
1432                 string_set(&sDefault.fstype, FSTYPE_STRING);
1433                 string_set(&sDefault.szPrintjobUsername, "%U");
1434
1435                 init_printer_values(&sDefault);
1436
1437                 done_init = True;
1438         }
1439
1440
1441         DEBUG(3, ("Initialising global parameters\n"));
1442
1443         string_set(&Globals.szSMBPasswdFile, dyn_SMB_PASSWD_FILE);
1444         string_set(&Globals.szPrivateDir, dyn_PRIVATE_DIR);
1445
1446         /* use the new 'hash2' method by default, with a prefix of 1 */
1447         string_set(&Globals.szManglingMethod, "hash2");
1448         Globals.mangle_prefix = 1;
1449
1450         string_set(&Globals.szGuestaccount, GUEST_ACCOUNT);
1451
1452         /* using UTF8 by default allows us to support all chars */
1453         string_set(&Globals.unix_charset, DEFAULT_UNIX_CHARSET);
1454
1455 #if defined(HAVE_NL_LANGINFO) && defined(CODESET)
1456         /* If the system supports nl_langinfo(), try to grab the value
1457            from the user's locale */
1458         string_set(&Globals.display_charset, "LOCALE");
1459 #else
1460         string_set(&Globals.display_charset, DEFAULT_DISPLAY_CHARSET);
1461 #endif
1462
1463         /* Use codepage 850 as a default for the dos character set */
1464         string_set(&Globals.dos_charset, DEFAULT_DOS_CHARSET);
1465
1466         /*
1467          * Allow the default PASSWD_CHAT to be overridden in local.h.
1468          */
1469         string_set(&Globals.szPasswdChat, DEFAULT_PASSWD_CHAT);
1470
1471         set_global_myname(myhostname());
1472         string_set(&Globals.szNetbiosName,global_myname());
1473
1474         set_global_myworkgroup(WORKGROUP);
1475         string_set(&Globals.szWorkgroup, lp_workgroup());
1476
1477         string_set(&Globals.szPasswdProgram, "");
1478         string_set(&Globals.szPidDir, dyn_PIDDIR);
1479         string_set(&Globals.szLockDir, dyn_LOCKDIR);
1480         string_set(&Globals.szSocketAddress, "0.0.0.0");
1481         pstrcpy(s, "Samba ");
1482         pstrcat(s, SAMBA_VERSION_STRING);
1483         string_set(&Globals.szServerString, s);
1484         slprintf(s, sizeof(s) - 1, "%d.%d", DEFAULT_MAJOR_VERSION,
1485                  DEFAULT_MINOR_VERSION);
1486         string_set(&Globals.szAnnounceVersion, s);
1487 #ifdef DEVELOPER
1488         string_set(&Globals.szPanicAction, "/bin/sleep 999999999");
1489 #endif
1490
1491         pstrcpy(user_socket_options, DEFAULT_SOCKET_OPTIONS);
1492
1493         string_set(&Globals.szLogonDrive, "");
1494         /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
1495         string_set(&Globals.szLogonHome, "\\\\%N\\%U");
1496         string_set(&Globals.szLogonPath, "\\\\%N\\%U\\profile");
1497
1498         string_set(&Globals.szNameResolveOrder, "lmhosts wins host bcast");
1499         string_set(&Globals.szPasswordServer, "*");
1500
1501         Globals.AlgorithmicRidBase = BASE_RID;
1502
1503         Globals.bLoadPrinters = True;
1504         Globals.PrintcapCacheTime = 750;        /* 12.5 minutes */
1505
1506         /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
1507         /* Discovered by 2 days of pain by Don McCall @ HP :-). */
1508         Globals.max_xmit = 0x4104;
1509         Globals.max_mux = 50;   /* This is *needed* for profile support. */
1510         Globals.lpqcachetime = 30;      /* changed to handle large print servers better -- jerry */
1511         Globals.bDisableSpoolss = False;
1512         Globals.iMaxSmbdProcesses = 0;/* no limit specified */
1513         Globals.pwordlevel = 0;
1514         Globals.unamelevel = 0;
1515         Globals.deadtime = 0;
1516         Globals.bLargeReadwrite = True;
1517         Globals.max_log_size = 5000;
1518         Globals.max_open_files = MAX_OPEN_FILES;
1519         Globals.open_files_db_hash_size = SMB_OPEN_DATABASE_TDB_HASH_SIZE;
1520         Globals.maxprotocol = PROTOCOL_NT1;
1521         Globals.minprotocol = PROTOCOL_CORE;
1522         Globals.security = SEC_USER;
1523         Globals.paranoid_server_security = True;
1524         Globals.bEncryptPasswords = True;
1525         Globals.bUpdateEncrypt = False;
1526         Globals.clientSchannel = Auto;
1527         Globals.serverSchannel = Auto;
1528         Globals.bReadRaw = True;
1529         Globals.bWriteRaw = True;
1530         Globals.bReadbmpx = False;
1531         Globals.bNullPasswords = False;
1532         Globals.bObeyPamRestrictions = False;
1533         Globals.syslog = 1;
1534         Globals.bSyslogOnly = False;
1535         Globals.bTimestampLogs = True;
1536         string_set(&Globals.szLogLevel, "0");
1537         Globals.bDebugPrefixTimestamp = False;
1538         Globals.bDebugHiresTimestamp = False;
1539         Globals.bDebugPid = False;
1540         Globals.bDebugUid = False;
1541         Globals.bEnableCoreFiles = True;
1542         Globals.max_ttl = 60 * 60 * 24 * 3;     /* 3 days default. */
1543         Globals.max_wins_ttl = 60 * 60 * 24 * 6;        /* 6 days default. */
1544         Globals.min_wins_ttl = 60 * 60 * 6;     /* 6 hours default. */
1545         Globals.machine_password_timeout = 60 * 60 * 24 * 7;    /* 7 days default. */
1546         Globals.lm_announce = 2;        /* = Auto: send only if LM clients found */
1547         Globals.lm_interval = 60;
1548         Globals.announce_as = ANNOUNCE_AS_NT_SERVER;
1549 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1550         Globals.bNISHomeMap = False;
1551 #ifdef WITH_NISPLUS_HOME
1552         string_set(&Globals.szNISHomeMapName, "auto_home.org_dir");
1553 #else
1554         string_set(&Globals.szNISHomeMapName, "auto.home");
1555 #endif
1556 #endif
1557         Globals.bTimeServer = False;
1558         Globals.bBindInterfacesOnly = False;
1559         Globals.bUnixPasswdSync = False;
1560         Globals.bPamPasswordChange = False;
1561         Globals.bPasswdChatDebug = False;
1562         Globals.iPasswdChatTimeout = 2; /* 2 second default. */
1563         Globals.bNTPipeSupport = True;  /* Do NT pipes by default. */
1564         Globals.bNTStatusSupport = True; /* Use NT status by default. */
1565         Globals.bStatCache = True;      /* use stat cache by default */
1566         Globals.iMaxStatCacheSize = 1024; /* one Meg by default. */
1567         Globals.restrict_anonymous = 0;
1568         Globals.bClientLanManAuth = True;       /* Do use the LanMan hash if it is available */
1569         Globals.bClientPlaintextAuth = True;    /* Do use a plaintext password if is requested by the server */
1570         Globals.bLanmanAuth = True;     /* Do use the LanMan hash if it is available */
1571         Globals.bNTLMAuth = True;       /* Do use NTLMv1 if it is available (otherwise NTLMv2) */
1572         Globals.bClientNTLMv2Auth = False; /* Client should not use NTLMv2, as we can't tell that the server supports it. */
1573         /* Note, that we will use NTLM2 session security (which is different), if it is available */
1574
1575         Globals.map_to_guest = 0;       /* By Default, "Never" */
1576         Globals.oplock_break_wait_time = 0;     /* By Default, 0 msecs. */
1577         Globals.enhanced_browsing = True;
1578         Globals.iLockSpinTime = WINDOWS_MINIMUM_LOCK_TIMEOUT_MS; /* msec. */
1579 #ifdef MMAP_BLACKLIST
1580         Globals.bUseMmap = False;
1581 #else
1582         Globals.bUseMmap = True;
1583 #endif
1584         Globals.bUnixExtensions = True;
1585         Globals.bResetOnZeroVC = False;
1586
1587         /* hostname lookups can be very expensive and are broken on
1588            a large number of sites (tridge) */
1589         Globals.bHostnameLookups = False;
1590
1591         string_set(&Globals.szPassdbBackend, "smbpasswd");
1592         string_set(&Globals.szLdapSuffix, "");
1593         string_set(&Globals.szLdapMachineSuffix, "");
1594         string_set(&Globals.szLdapUserSuffix, "");
1595         string_set(&Globals.szLdapGroupSuffix, "");
1596         string_set(&Globals.szLdapIdmapSuffix, "");
1597
1598         string_set(&Globals.szLdapAdminDn, "");
1599         Globals.ldap_ssl = LDAP_SSL_ON;
1600         Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
1601         Globals.ldap_delete_dn = False;
1602         Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
1603         Globals.ldap_timeout = LDAP_CONNECT_DEFAULT_TIMEOUT;
1604         Globals.ldap_page_size = LDAP_PAGE_SIZE;
1605
1606         /* This is what we tell the afs client. in reality we set the token
1607          * to never expire, though, when this runs out the afs client will
1608          * forget the token. Set to 0 to get NEVERDATE.*/
1609         Globals.iAfsTokenLifetime = 604800;
1610
1611 /* these parameters are set to defaults that are more appropriate
1612    for the increasing samba install base:
1613
1614    as a member of the workgroup, that will possibly become a
1615    _local_ master browser (lm = True).  this is opposed to a forced
1616    local master browser startup (pm = True).
1617
1618    doesn't provide WINS server service by default (wsupp = False),
1619    and doesn't provide domain master browser services by default, either.
1620
1621 */
1622
1623         Globals.bMsAddPrinterWizard = True;
1624         Globals.bPreferredMaster = Auto;        /* depending on bDomainMaster */
1625         Globals.os_level = 20;
1626         Globals.bLocalMaster = True;
1627         Globals.bDomainMaster = Auto;   /* depending on bDomainLogons */
1628         Globals.bDomainLogons = False;
1629         Globals.bBrowseList = True;
1630         Globals.bWINSsupport = False;
1631         Globals.bWINSproxy = False;
1632
1633         Globals.bDNSproxy = True;
1634
1635         /* this just means to use them if they exist */
1636         Globals.bKernelOplocks = True;
1637
1638         Globals.bAllowTrustedDomains = True;
1639
1640         string_set(&Globals.szTemplateShell, "/bin/false");
1641         string_set(&Globals.szTemplateHomedir, "/home/%D/%U");
1642         string_set(&Globals.szWinbindSeparator, "\\");
1643
1644         string_set(&Globals.szCupsServer, "");
1645         string_set(&Globals.szIPrintServer, "");
1646
1647         string_set(&Globals.ctdbdSocket, "");
1648         Globals.clustering = False;
1649
1650         Globals.winbind_cache_time = 300;       /* 5 minutes */
1651         Globals.bWinbindEnumUsers = False;
1652         Globals.bWinbindEnumGroups = False;
1653         Globals.bWinbindUseDefaultDomain = False;
1654         Globals.bWinbindTrustedDomainsOnly = False;
1655         Globals.bWinbindNestedGroups = True;
1656         Globals.winbind_expand_groups = 1;
1657         Globals.szWinbindNssInfo = str_list_make("template", NULL);
1658         Globals.bWinbindRefreshTickets = False;
1659         Globals.bWinbindOfflineLogon = False;
1660
1661         Globals.iIdmapCacheTime = 900; /* 15 minutes by default */
1662         Globals.iIdmapNegativeCacheTime = 120; /* 2 minutes by default */
1663
1664         Globals.bPassdbExpandExplicit = False;
1665
1666         Globals.name_cache_timeout = 660; /* In seconds */
1667
1668         Globals.bUseSpnego = True;
1669         Globals.bClientUseSpnego = True;
1670
1671         Globals.client_signing = Auto;
1672         Globals.server_signing = False;
1673
1674         Globals.bDeferSharingViolations = True;
1675         string_set(&Globals.smb_ports, SMB_PORTS);
1676
1677         Globals.bEnablePrivileges = True;
1678         Globals.bHostMSDfs        = True;
1679         Globals.bASUSupport       = False;
1680
1681         /* User defined shares. */
1682         pstrcpy(s, dyn_LOCKDIR);
1683         pstrcat(s, "/usershares");
1684         string_set(&Globals.szUsersharePath, s);
1685         string_set(&Globals.szUsershareTemplateShare, "");
1686         Globals.iUsershareMaxShares = 0;
1687         /* By default disallow sharing of directories not owned by the sharer. */
1688         Globals.bUsershareOwnerOnly = True;
1689         /* By default disallow guest access to usershares. */
1690         Globals.bUsershareAllowGuests = False;
1691
1692         Globals.iKeepalive = DEFAULT_KEEPALIVE;
1693
1694         /* By default no shares out of the registry */
1695         Globals.bRegistryShares = False;
1696 }
1697
1698 static TALLOC_CTX *lp_talloc;
1699
1700 /******************************************************************* a
1701  Free up temporary memory - called from the main loop.
1702 ********************************************************************/
1703
1704 void lp_TALLOC_FREE(void)
1705 {
1706         if (!lp_talloc)
1707                 return;
1708         TALLOC_FREE(lp_talloc);
1709         lp_talloc = NULL;
1710 }
1711
1712 TALLOC_CTX *tmp_talloc_ctx(void)
1713 {
1714         if (lp_talloc == NULL) {
1715                 lp_talloc = talloc_init("tmp_talloc_ctx");
1716         }
1717
1718         if (lp_talloc == NULL) {
1719                 smb_panic("Could not create temporary talloc context");
1720         }
1721
1722         return lp_talloc;
1723 }
1724
1725 /*******************************************************************
1726  Convenience routine to grab string parameters into temporary memory
1727  and run standard_sub_basic on them. The buffers can be written to by
1728  callers without affecting the source string.
1729 ********************************************************************/
1730
1731 static char *lp_string(const char *s)
1732 {
1733         char *ret, *tmpstr;
1734
1735         /* The follow debug is useful for tracking down memory problems
1736            especially if you have an inner loop that is calling a lp_*()
1737            function that returns a string.  Perhaps this debug should be
1738            present all the time? */
1739
1740 #if 0
1741         DEBUG(10, ("lp_string(%s)\n", s));
1742 #endif
1743
1744         if (!lp_talloc)
1745                 lp_talloc = talloc_init("lp_talloc");
1746
1747         tmpstr = alloc_sub_basic(get_current_username(),
1748                                  current_user_info.domain, s);
1749         if (trim_char(tmpstr, '\"', '\"')) {
1750                 if (strchr(tmpstr,'\"') != NULL) {
1751                         SAFE_FREE(tmpstr);
1752                         tmpstr = alloc_sub_basic(get_current_username(),
1753                                                  current_user_info.domain, s);
1754                 }
1755         }
1756         ret = talloc_strdup(lp_talloc, tmpstr);
1757         SAFE_FREE(tmpstr);
1758
1759         return (ret);
1760 }
1761
1762 /*
1763    In this section all the functions that are used to access the
1764    parameters from the rest of the program are defined
1765 */
1766
1767 #define FN_GLOBAL_STRING(fn_name,ptr) \
1768  char *fn_name(void) {return(lp_string(*(char **)(ptr) ? *(char **)(ptr) : ""));}
1769 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1770  const char *fn_name(void) {return(*(const char **)(ptr) ? *(const char **)(ptr) : "");}
1771 #define FN_GLOBAL_LIST(fn_name,ptr) \
1772  const char **fn_name(void) {return(*(const char ***)(ptr));}
1773 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1774  BOOL fn_name(void) {return(*(BOOL *)(ptr));}
1775 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1776  char fn_name(void) {return(*(char *)(ptr));}
1777 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1778  int fn_name(void) {return(*(int *)(ptr));}
1779
1780 #define FN_LOCAL_STRING(fn_name,val) \
1781  char *fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
1782 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1783  const char *fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1784 #define FN_LOCAL_LIST(fn_name,val) \
1785  const char **fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1786 #define FN_LOCAL_BOOL(fn_name,val) \
1787  BOOL fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1788 #define FN_LOCAL_INTEGER(fn_name,val) \
1789  int fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1790
1791 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1792  BOOL fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1793 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1794  int fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1795 #define FN_LOCAL_PARM_STRING(fn_name,val) \
1796  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));}
1797 #define FN_LOCAL_CHAR(fn_name,val) \
1798  char fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1799
1800 FN_GLOBAL_STRING(lp_smb_ports, &Globals.smb_ports)
1801 FN_GLOBAL_STRING(lp_dos_charset, &Globals.dos_charset)
1802 FN_GLOBAL_STRING(lp_unix_charset, &Globals.unix_charset)
1803 FN_GLOBAL_STRING(lp_display_charset, &Globals.display_charset)
1804 FN_GLOBAL_STRING(lp_logfile, &Globals.szLogFile)
1805 FN_GLOBAL_STRING(lp_configfile, &Globals.szConfigFile)
1806 FN_GLOBAL_STRING(lp_smb_passwd_file, &Globals.szSMBPasswdFile)
1807 FN_GLOBAL_STRING(lp_private_dir, &Globals.szPrivateDir)
1808 FN_GLOBAL_STRING(lp_serverstring, &Globals.szServerString)
1809 FN_GLOBAL_INTEGER(lp_printcap_cache_time, &Globals.PrintcapCacheTime)
1810 FN_GLOBAL_STRING(lp_addport_cmd, &Globals.szAddPortCommand)
1811 FN_GLOBAL_STRING(lp_enumports_cmd, &Globals.szEnumPortsCommand)
1812 FN_GLOBAL_STRING(lp_addprinter_cmd, &Globals.szAddPrinterCommand)
1813 FN_GLOBAL_STRING(lp_deleteprinter_cmd, &Globals.szDeletePrinterCommand)
1814 FN_GLOBAL_STRING(lp_os2_driver_map, &Globals.szOs2DriverMap)
1815 FN_GLOBAL_STRING(lp_lockdir, &Globals.szLockDir)
1816 FN_GLOBAL_STRING(lp_piddir, &Globals.szPidDir)
1817 FN_GLOBAL_STRING(lp_mangling_method, &Globals.szManglingMethod)
1818 FN_GLOBAL_INTEGER(lp_mangle_prefix, &Globals.mangle_prefix)
1819 FN_GLOBAL_STRING(lp_utmpdir, &Globals.szUtmpDir)
1820 FN_GLOBAL_STRING(lp_wtmpdir, &Globals.szWtmpDir)
1821 FN_GLOBAL_BOOL(lp_utmp, &Globals.bUtmp)
1822 FN_GLOBAL_STRING(lp_rootdir, &Globals.szRootdir)
1823 FN_GLOBAL_STRING(lp_defaultservice, &Globals.szDefaultService)
1824 FN_GLOBAL_STRING(lp_msg_command, &Globals.szMsgCommand)
1825 FN_GLOBAL_STRING(lp_get_quota_command, &Globals.szGetQuota)
1826 FN_GLOBAL_STRING(lp_set_quota_command, &Globals.szSetQuota)
1827 FN_GLOBAL_STRING(lp_auto_services, &Globals.szAutoServices)
1828 FN_GLOBAL_STRING(lp_passwd_program, &Globals.szPasswdProgram)
1829 FN_GLOBAL_STRING(lp_passwd_chat, &Globals.szPasswdChat)
1830 FN_GLOBAL_STRING(lp_passwordserver, &Globals.szPasswordServer)
1831 FN_GLOBAL_STRING(lp_name_resolve_order, &Globals.szNameResolveOrder)
1832 FN_GLOBAL_STRING(lp_realm, &Globals.szRealm)
1833 FN_GLOBAL_CONST_STRING(lp_afs_username_map, &Globals.szAfsUsernameMap)
1834 FN_GLOBAL_INTEGER(lp_afs_token_lifetime, &Globals.iAfsTokenLifetime)
1835 FN_GLOBAL_STRING(lp_log_nt_token_command, &Globals.szLogNtTokenCommand)
1836 FN_GLOBAL_STRING(lp_username_map, &Globals.szUsernameMap)
1837 FN_GLOBAL_CONST_STRING(lp_logon_script, &Globals.szLogonScript)
1838 FN_GLOBAL_CONST_STRING(lp_logon_path, &Globals.szLogonPath)
1839 FN_GLOBAL_CONST_STRING(lp_logon_drive, &Globals.szLogonDrive)
1840 FN_GLOBAL_CONST_STRING(lp_logon_home, &Globals.szLogonHome)
1841 FN_GLOBAL_STRING(lp_remote_announce, &Globals.szRemoteAnnounce)
1842 FN_GLOBAL_STRING(lp_remote_browse_sync, &Globals.szRemoteBrowseSync)
1843 FN_GLOBAL_LIST(lp_wins_server_list, &Globals.szWINSservers)
1844 FN_GLOBAL_LIST(lp_interfaces, &Globals.szInterfaces)
1845 FN_GLOBAL_STRING(lp_socket_address, &Globals.szSocketAddress)
1846 FN_GLOBAL_STRING(lp_nis_home_map_name, &Globals.szNISHomeMapName)
1847 static FN_GLOBAL_STRING(lp_announce_version, &Globals.szAnnounceVersion)
1848 FN_GLOBAL_LIST(lp_netbios_aliases, &Globals.szNetbiosAliases)
1849 /* FN_GLOBAL_STRING(lp_passdb_backend, &Globals.szPassdbBackend)
1850  * lp_passdb_backend() should be replace by the this macro again after
1851  * some releases.
1852  * */
1853 const char *lp_passdb_backend(void)
1854 {
1855         char *delim, *quote;
1856
1857         delim = strchr( Globals.szPassdbBackend, ' ');
1858         /* no space at all */
1859         if (delim == NULL) {
1860                 goto out;
1861         }
1862
1863         quote = strchr(Globals.szPassdbBackend, '"');
1864         /* no quote char or non in the first part */
1865         if (quote == NULL || quote > delim) {
1866                 *delim = '\0';
1867                 goto warn;
1868         }
1869
1870         quote = strchr(quote+1, '"');
1871         if (quote == NULL) {
1872                 DEBUG(0, ("WARNING: Your 'passdb backend' configuration is invalid due to a missing second \" char.\n"));
1873                 goto out;
1874         } else if (*(quote+1) == '\0') {
1875                 /* space, fitting quote char, and one backend only */
1876                 goto out;
1877         } else {
1878                 /* terminate string after the fitting quote char */
1879                 *(quote+1) = '\0';
1880         }
1881
1882 warn:
1883         DEBUG(0, ("WARNING: Your 'passdb backend' configuration includes multiple backends.  This\n"
1884                 "is deprecated since Samba 3.0.23.  Please check WHATSNEW.txt or the section 'Passdb\n"
1885                 "Changes' from the ChangeNotes as part of the Samba HOWTO collection.  Only the first\n"
1886                 "backend (%s) is used.  The rest is ignored.\n", Globals.szPassdbBackend));
1887
1888 out:
1889         return Globals.szPassdbBackend;
1890 }
1891 FN_GLOBAL_LIST(lp_preload_modules, &Globals.szPreloadModules)
1892 FN_GLOBAL_STRING(lp_panic_action, &Globals.szPanicAction)
1893 FN_GLOBAL_STRING(lp_adduser_script, &Globals.szAddUserScript)
1894 FN_GLOBAL_STRING(lp_renameuser_script, &Globals.szRenameUserScript)
1895 FN_GLOBAL_STRING(lp_deluser_script, &Globals.szDelUserScript)
1896
1897 FN_GLOBAL_CONST_STRING(lp_guestaccount, &Globals.szGuestaccount)
1898 FN_GLOBAL_STRING(lp_addgroup_script, &Globals.szAddGroupScript)
1899 FN_GLOBAL_STRING(lp_delgroup_script, &Globals.szDelGroupScript)
1900 FN_GLOBAL_STRING(lp_addusertogroup_script, &Globals.szAddUserToGroupScript)
1901 FN_GLOBAL_STRING(lp_deluserfromgroup_script, &Globals.szDelUserFromGroupScript)
1902 FN_GLOBAL_STRING(lp_setprimarygroup_script, &Globals.szSetPrimaryGroupScript)
1903
1904 FN_GLOBAL_STRING(lp_addmachine_script, &Globals.szAddMachineScript)
1905
1906 FN_GLOBAL_STRING(lp_shutdown_script, &Globals.szShutdownScript)
1907 FN_GLOBAL_STRING(lp_abort_shutdown_script, &Globals.szAbortShutdownScript)
1908 FN_GLOBAL_STRING(lp_username_map_script, &Globals.szUsernameMapScript)
1909
1910 FN_GLOBAL_STRING(lp_check_password_script, &Globals.szCheckPasswordScript)
1911
1912 FN_GLOBAL_STRING(lp_wins_hook, &Globals.szWINSHook)
1913 FN_GLOBAL_CONST_STRING(lp_template_homedir, &Globals.szTemplateHomedir)
1914 FN_GLOBAL_CONST_STRING(lp_template_shell, &Globals.szTemplateShell)
1915 FN_GLOBAL_CONST_STRING(lp_winbind_separator, &Globals.szWinbindSeparator)
1916 FN_GLOBAL_INTEGER(lp_acl_compatibility, &Globals.iAclCompat)
1917 FN_GLOBAL_BOOL(lp_winbind_enum_users, &Globals.bWinbindEnumUsers)
1918 FN_GLOBAL_BOOL(lp_winbind_enum_groups, &Globals.bWinbindEnumGroups)
1919 FN_GLOBAL_BOOL(lp_winbind_use_default_domain, &Globals.bWinbindUseDefaultDomain)
1920 FN_GLOBAL_BOOL(lp_winbind_trusted_domains_only, &Globals.bWinbindTrustedDomainsOnly)
1921 FN_GLOBAL_BOOL(lp_winbind_nested_groups, &Globals.bWinbindNestedGroups)
1922 FN_GLOBAL_INTEGER(lp_winbind_expand_groups, &Globals.winbind_expand_groups)
1923 FN_GLOBAL_BOOL(lp_winbind_refresh_tickets, &Globals.bWinbindRefreshTickets)
1924 FN_GLOBAL_BOOL(lp_winbind_offline_logon, &Globals.bWinbindOfflineLogon)
1925 FN_GLOBAL_BOOL(lp_winbind_normalize_names, &Globals.bWinbindNormalizeNames)
1926 FN_GLOBAL_BOOL(lp_winbind_rpc_only, &Globals.bWinbindRpcOnly)
1927
1928 FN_GLOBAL_LIST(lp_idmap_domains, &Globals.szIdmapDomains)
1929 FN_GLOBAL_LIST(lp_idmap_backend, &Globals.szIdmapBackend) /* deprecated */
1930 FN_GLOBAL_STRING(lp_idmap_alloc_backend, &Globals.szIdmapAllocBackend)
1931 FN_GLOBAL_INTEGER(lp_idmap_cache_time, &Globals.iIdmapCacheTime)
1932 FN_GLOBAL_INTEGER(lp_idmap_negative_cache_time, &Globals.iIdmapNegativeCacheTime)
1933 FN_GLOBAL_INTEGER(lp_keepalive, &Globals.iKeepalive)
1934 FN_GLOBAL_BOOL(lp_passdb_expand_explicit, &Globals.bPassdbExpandExplicit)
1935
1936 FN_GLOBAL_STRING(lp_ldap_suffix, &Globals.szLdapSuffix)
1937 FN_GLOBAL_STRING(lp_ldap_admin_dn, &Globals.szLdapAdminDn)
1938 FN_GLOBAL_INTEGER(lp_ldap_ssl, &Globals.ldap_ssl)
1939 FN_GLOBAL_INTEGER(lp_ldap_passwd_sync, &Globals.ldap_passwd_sync)
1940 FN_GLOBAL_BOOL(lp_ldap_delete_dn, &Globals.ldap_delete_dn)
1941 FN_GLOBAL_INTEGER(lp_ldap_replication_sleep, &Globals.ldap_replication_sleep)
1942 FN_GLOBAL_INTEGER(lp_ldap_timeout, &Globals.ldap_timeout)
1943 FN_GLOBAL_INTEGER(lp_ldap_page_size, &Globals.ldap_page_size)
1944 FN_GLOBAL_STRING(lp_add_share_cmd, &Globals.szAddShareCommand)
1945 FN_GLOBAL_STRING(lp_change_share_cmd, &Globals.szChangeShareCommand)
1946 FN_GLOBAL_STRING(lp_delete_share_cmd, &Globals.szDeleteShareCommand)
1947 FN_GLOBAL_STRING(lp_usershare_path, &Globals.szUsersharePath)
1948 FN_GLOBAL_LIST(lp_usershare_prefix_allow_list, &Globals.szUsersharePrefixAllowList)
1949 FN_GLOBAL_LIST(lp_usershare_prefix_deny_list, &Globals.szUsersharePrefixDenyList)
1950
1951 FN_GLOBAL_LIST(lp_eventlog_list, &Globals.szEventLogs)
1952
1953 FN_GLOBAL_BOOL(lp_registry_shares, &Globals.bRegistryShares)
1954 FN_GLOBAL_BOOL(lp_usershare_allow_guests, &Globals.bUsershareAllowGuests)
1955 FN_GLOBAL_BOOL(lp_usershare_owner_only, &Globals.bUsershareOwnerOnly)
1956 FN_GLOBAL_BOOL(lp_disable_netbios, &Globals.bDisableNetbios)
1957 FN_GLOBAL_BOOL(lp_reset_on_zero_vc, &Globals.bResetOnZeroVC)
1958 FN_GLOBAL_BOOL(lp_ms_add_printer_wizard, &Globals.bMsAddPrinterWizard)
1959 FN_GLOBAL_BOOL(lp_dns_proxy, &Globals.bDNSproxy)
1960 FN_GLOBAL_BOOL(lp_wins_support, &Globals.bWINSsupport)
1961 FN_GLOBAL_BOOL(lp_we_are_a_wins_server, &Globals.bWINSsupport)
1962 FN_GLOBAL_BOOL(lp_wins_proxy, &Globals.bWINSproxy)
1963 FN_GLOBAL_BOOL(lp_local_master, &Globals.bLocalMaster)
1964 FN_GLOBAL_BOOL(lp_domain_logons, &Globals.bDomainLogons)
1965 FN_GLOBAL_BOOL(lp_load_printers, &Globals.bLoadPrinters)
1966 FN_GLOBAL_BOOL(lp_readbmpx, &Globals.bReadbmpx)
1967 FN_GLOBAL_BOOL(lp_readraw, &Globals.bReadRaw)
1968 FN_GLOBAL_BOOL(lp_large_readwrite, &Globals.bLargeReadwrite)
1969 FN_GLOBAL_BOOL(lp_writeraw, &Globals.bWriteRaw)
1970 FN_GLOBAL_BOOL(lp_null_passwords, &Globals.bNullPasswords)
1971 FN_GLOBAL_BOOL(lp_obey_pam_restrictions, &Globals.bObeyPamRestrictions)
1972 FN_GLOBAL_BOOL(lp_encrypted_passwords, &Globals.bEncryptPasswords)
1973 FN_GLOBAL_BOOL(lp_update_encrypted, &Globals.bUpdateEncrypt)
1974 FN_GLOBAL_INTEGER(lp_client_schannel, &Globals.clientSchannel)
1975 FN_GLOBAL_INTEGER(lp_server_schannel, &Globals.serverSchannel)
1976 FN_GLOBAL_BOOL(lp_syslog_only, &Globals.bSyslogOnly)
1977 FN_GLOBAL_BOOL(lp_timestamp_logs, &Globals.bTimestampLogs)
1978 FN_GLOBAL_BOOL(lp_debug_prefix_timestamp, &Globals.bDebugPrefixTimestamp)
1979 FN_GLOBAL_BOOL(lp_debug_hires_timestamp, &Globals.bDebugHiresTimestamp)
1980 FN_GLOBAL_BOOL(lp_debug_pid, &Globals.bDebugPid)
1981 FN_GLOBAL_BOOL(lp_debug_uid, &Globals.bDebugUid)
1982 FN_GLOBAL_BOOL(lp_enable_core_files, &Globals.bEnableCoreFiles)
1983 FN_GLOBAL_BOOL(lp_browse_list, &Globals.bBrowseList)
1984 FN_GLOBAL_BOOL(lp_nis_home_map, &Globals.bNISHomeMap)
1985 static FN_GLOBAL_BOOL(lp_time_server, &Globals.bTimeServer)
1986 FN_GLOBAL_BOOL(lp_bind_interfaces_only, &Globals.bBindInterfacesOnly)
1987 FN_GLOBAL_BOOL(lp_pam_password_change, &Globals.bPamPasswordChange)
1988 FN_GLOBAL_BOOL(lp_unix_password_sync, &Globals.bUnixPasswdSync)
1989 FN_GLOBAL_BOOL(lp_passwd_chat_debug, &Globals.bPasswdChatDebug)
1990 FN_GLOBAL_INTEGER(lp_passwd_chat_timeout, &Globals.iPasswdChatTimeout)
1991 FN_GLOBAL_BOOL(lp_nt_pipe_support, &Globals.bNTPipeSupport)
1992 FN_GLOBAL_BOOL(lp_nt_status_support, &Globals.bNTStatusSupport)
1993 FN_GLOBAL_BOOL(lp_stat_cache, &Globals.bStatCache)
1994 FN_GLOBAL_INTEGER(lp_max_stat_cache_size, &Globals.iMaxStatCacheSize)
1995 FN_GLOBAL_BOOL(lp_allow_trusted_domains, &Globals.bAllowTrustedDomains)
1996 FN_GLOBAL_INTEGER(lp_restrict_anonymous, &Globals.restrict_anonymous)
1997 FN_GLOBAL_BOOL(lp_lanman_auth, &Globals.bLanmanAuth)
1998 FN_GLOBAL_BOOL(lp_ntlm_auth, &Globals.bNTLMAuth)
1999 FN_GLOBAL_BOOL(lp_client_plaintext_auth, &Globals.bClientPlaintextAuth)
2000 FN_GLOBAL_BOOL(lp_client_lanman_auth, &Globals.bClientLanManAuth)
2001 FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, &Globals.bClientNTLMv2Auth)
2002 FN_GLOBAL_BOOL(lp_host_msdfs, &Globals.bHostMSDfs)
2003 FN_GLOBAL_BOOL(lp_kernel_oplocks, &Globals.bKernelOplocks)
2004 FN_GLOBAL_BOOL(lp_enhanced_browsing, &Globals.enhanced_browsing)
2005 FN_GLOBAL_BOOL(lp_use_mmap, &Globals.bUseMmap)
2006 FN_GLOBAL_BOOL(lp_unix_extensions, &Globals.bUnixExtensions)
2007 FN_GLOBAL_BOOL(lp_use_spnego, &Globals.bUseSpnego)
2008 FN_GLOBAL_BOOL(lp_client_use_spnego, &Globals.bClientUseSpnego)
2009 FN_GLOBAL_BOOL(lp_hostname_lookups, &Globals.bHostnameLookups)
2010 FN_LOCAL_PARM_BOOL(lp_change_notify, bChangeNotify)
2011 FN_LOCAL_PARM_BOOL(lp_kernel_change_notify, bKernelChangeNotify)
2012 FN_GLOBAL_BOOL(lp_use_kerberos_keytab, &Globals.bUseKerberosKeytab)
2013 FN_GLOBAL_BOOL(lp_defer_sharing_violations, &Globals.bDeferSharingViolations)
2014 FN_GLOBAL_BOOL(lp_enable_privileges, &Globals.bEnablePrivileges)
2015 FN_GLOBAL_BOOL(lp_enable_asu_support, &Globals.bASUSupport)
2016 FN_GLOBAL_INTEGER(lp_os_level, &Globals.os_level)
2017 FN_GLOBAL_INTEGER(lp_max_ttl, &Globals.max_ttl)
2018 FN_GLOBAL_INTEGER(lp_max_wins_ttl, &Globals.max_wins_ttl)
2019 FN_GLOBAL_INTEGER(lp_min_wins_ttl, &Globals.min_wins_ttl)
2020 FN_GLOBAL_INTEGER(lp_max_log_size, &Globals.max_log_size)
2021 FN_GLOBAL_INTEGER(lp_max_open_files, &Globals.max_open_files)
2022 FN_GLOBAL_INTEGER(lp_open_files_db_hash_size, &Globals.open_files_db_hash_size)
2023 FN_GLOBAL_INTEGER(lp_maxxmit, &Globals.max_xmit)
2024 FN_GLOBAL_INTEGER(lp_maxmux, &Globals.max_mux)
2025 FN_GLOBAL_INTEGER(lp_passwordlevel, &Globals.pwordlevel)
2026 FN_GLOBAL_INTEGER(lp_usernamelevel, &Globals.unamelevel)
2027 FN_GLOBAL_INTEGER(lp_deadtime, &Globals.deadtime)
2028 FN_GLOBAL_INTEGER(lp_maxprotocol, &Globals.maxprotocol)
2029 FN_GLOBAL_INTEGER(lp_minprotocol, &Globals.minprotocol)
2030 FN_GLOBAL_INTEGER(lp_security, &Globals.security)
2031 FN_GLOBAL_LIST(lp_auth_methods, &Globals.AuthMethods)
2032 FN_GLOBAL_BOOL(lp_paranoid_server_security, &Globals.paranoid_server_security)
2033 FN_GLOBAL_INTEGER(lp_maxdisksize, &Globals.maxdisksize)
2034 FN_GLOBAL_INTEGER(lp_lpqcachetime, &Globals.lpqcachetime)
2035 FN_GLOBAL_INTEGER(lp_max_smbd_processes, &Globals.iMaxSmbdProcesses)
2036 FN_GLOBAL_INTEGER(_lp_disable_spoolss, &Globals.bDisableSpoolss)
2037 FN_GLOBAL_INTEGER(lp_syslog, &Globals.syslog)
2038 static FN_GLOBAL_INTEGER(lp_announce_as, &Globals.announce_as)
2039 FN_GLOBAL_INTEGER(lp_lm_announce, &Globals.lm_announce)
2040 FN_GLOBAL_INTEGER(lp_lm_interval, &Globals.lm_interval)
2041 FN_GLOBAL_INTEGER(lp_machine_password_timeout, &Globals.machine_password_timeout)
2042 FN_GLOBAL_INTEGER(lp_map_to_guest, &Globals.map_to_guest)
2043 FN_GLOBAL_INTEGER(lp_oplock_break_wait_time, &Globals.oplock_break_wait_time)
2044 FN_GLOBAL_INTEGER(lp_lock_spin_time, &Globals.iLockSpinTime)
2045 FN_GLOBAL_INTEGER(lp_usershare_max_shares, &Globals.iUsershareMaxShares)
2046
2047 FN_LOCAL_STRING(lp_preexec, szPreExec)
2048 FN_LOCAL_STRING(lp_postexec, szPostExec)
2049 FN_LOCAL_STRING(lp_rootpreexec, szRootPreExec)
2050 FN_LOCAL_STRING(lp_rootpostexec, szRootPostExec)
2051 FN_LOCAL_STRING(lp_servicename, szService)
2052 FN_LOCAL_CONST_STRING(lp_const_servicename, szService)
2053 FN_LOCAL_STRING(lp_pathname, szPath)
2054 FN_LOCAL_STRING(lp_dontdescend, szDontdescend)
2055 FN_LOCAL_STRING(lp_username, szUsername)
2056 FN_LOCAL_LIST(lp_invalid_users, szInvalidUsers)
2057 FN_LOCAL_LIST(lp_valid_users, szValidUsers)
2058 FN_LOCAL_LIST(lp_admin_users, szAdminUsers)
2059 FN_GLOBAL_LIST(lp_svcctl_list, &Globals.szServicesList)
2060 FN_LOCAL_STRING(lp_cups_options, szCupsOptions)
2061 FN_GLOBAL_STRING(lp_cups_server, &Globals.szCupsServer)
2062 FN_GLOBAL_STRING(lp_iprint_server, &Globals.szIPrintServer)
2063 FN_GLOBAL_CONST_STRING(lp_ctdbd_socket, &Globals.ctdbdSocket)
2064 FN_GLOBAL_BOOL(lp_clustering, &Globals.clustering);
2065 FN_LOCAL_STRING(lp_printcommand, szPrintcommand)
2066 FN_LOCAL_STRING(lp_lpqcommand, szLpqcommand)
2067 FN_LOCAL_STRING(lp_lprmcommand, szLprmcommand)
2068 FN_LOCAL_STRING(lp_lppausecommand, szLppausecommand)
2069 FN_LOCAL_STRING(lp_lpresumecommand, szLpresumecommand)
2070 FN_LOCAL_STRING(lp_queuepausecommand, szQueuepausecommand)
2071 FN_LOCAL_STRING(lp_queueresumecommand, szQueueresumecommand)
2072 static FN_LOCAL_STRING(_lp_printername, szPrintername)
2073 FN_LOCAL_CONST_STRING(lp_printjob_username, szPrintjobUsername)
2074 FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
2075 FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
2076 FN_LOCAL_STRING(lp_magicscript, szMagicScript)
2077 FN_LOCAL_STRING(lp_magicoutput, szMagicOutput)
2078 FN_LOCAL_STRING(lp_comment, comment)
2079 FN_LOCAL_STRING(lp_force_user, force_user)
2080 FN_LOCAL_STRING(lp_force_group, force_group)
2081 FN_LOCAL_LIST(lp_readlist, readlist)
2082 FN_LOCAL_LIST(lp_writelist, writelist)
2083 FN_LOCAL_LIST(lp_printer_admin, printer_admin)
2084 FN_LOCAL_STRING(lp_fstype, fstype)
2085 FN_LOCAL_LIST(lp_vfs_objects, szVfsObjects)
2086 FN_LOCAL_STRING(lp_msdfs_proxy, szMSDfsProxy)
2087 static FN_LOCAL_STRING(lp_volume, volume)
2088 FN_LOCAL_PARM_STRING(lp_mangled_map, szMangledMap)
2089 FN_LOCAL_STRING(lp_veto_files, szVetoFiles)
2090 FN_LOCAL_STRING(lp_hide_files, szHideFiles)
2091 FN_LOCAL_STRING(lp_veto_oplocks, szVetoOplockFiles)
2092 FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
2093 FN_LOCAL_STRING(lp_dfree_command, szDfree)
2094 FN_LOCAL_BOOL(lp_autoloaded, autoloaded)
2095 FN_LOCAL_BOOL(lp_preexec_close, bPreexecClose)
2096 FN_LOCAL_BOOL(lp_rootpreexec_close, bRootpreexecClose)
2097 FN_LOCAL_INTEGER(lp_casesensitive, iCaseSensitive)
2098 FN_LOCAL_BOOL(lp_preservecase, bCasePreserve)
2099 FN_LOCAL_BOOL(lp_shortpreservecase, bShortCasePreserve)
2100 FN_LOCAL_BOOL(lp_hide_dot_files, bHideDotFiles)
2101 FN_LOCAL_BOOL(lp_hide_special_files, bHideSpecialFiles)
2102 FN_LOCAL_BOOL(lp_hideunreadable, bHideUnReadable)
2103 FN_LOCAL_BOOL(lp_hideunwriteable_files, bHideUnWriteableFiles)
2104 FN_LOCAL_BOOL(lp_browseable, bBrowseable)
2105 FN_LOCAL_BOOL(lp_readonly, bRead_only)
2106 FN_LOCAL_BOOL(lp_no_set_dir, bNo_set_dir)
2107 FN_LOCAL_BOOL(lp_guest_ok, bGuest_ok)
2108 FN_LOCAL_BOOL(lp_guest_only, bGuest_only)
2109 FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
2110 FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
2111 FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
2112 FN_LOCAL_BOOL(lp_store_dos_attributes, bStoreDosAttributes)
2113 FN_LOCAL_BOOL(lp_dmapi_support, bDmapiSupport)
2114 FN_LOCAL_PARM_BOOL(lp_locking, bLocking)
2115 FN_LOCAL_PARM_INTEGER(lp_strict_locking, iStrictLocking)
2116 FN_LOCAL_PARM_BOOL(lp_posix_locking, bPosixLocking)
2117 FN_LOCAL_BOOL(lp_share_modes, bShareModes)
2118 FN_LOCAL_BOOL(lp_oplocks, bOpLocks)
2119 FN_LOCAL_BOOL(lp_level2_oplocks, bLevel2OpLocks)
2120 FN_LOCAL_BOOL(lp_onlyuser, bOnlyUser)
2121 FN_LOCAL_PARM_BOOL(lp_manglednames, bMangledNames)
2122 FN_LOCAL_BOOL(lp_widelinks, bWidelinks)
2123 FN_LOCAL_BOOL(lp_symlinks, bSymlinks)
2124 FN_LOCAL_BOOL(lp_syncalways, bSyncAlways)
2125 FN_LOCAL_BOOL(lp_strict_allocate, bStrictAllocate)
2126 FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
2127 FN_LOCAL_BOOL(lp_map_system, bMap_system)
2128 FN_LOCAL_BOOL(lp_delete_readonly, bDeleteReadonly)
2129 FN_LOCAL_BOOL(lp_fake_oplocks, bFakeOplocks)
2130 FN_LOCAL_BOOL(lp_recursive_veto_delete, bDeleteVetoFiles)
2131 FN_LOCAL_BOOL(lp_dos_filemode, bDosFilemode)
2132 FN_LOCAL_BOOL(lp_dos_filetimes, bDosFiletimes)
2133 FN_LOCAL_BOOL(lp_dos_filetime_resolution, bDosFiletimeResolution)
2134 FN_LOCAL_BOOL(lp_fake_dir_create_times, bFakeDirCreateTimes)
2135 FN_LOCAL_BOOL(lp_blocking_locks, bBlockingLocks)
2136 FN_LOCAL_BOOL(lp_inherit_perms, bInheritPerms)
2137 FN_LOCAL_BOOL(lp_inherit_acls, bInheritACLS)
2138 FN_LOCAL_BOOL(lp_inherit_owner, bInheritOwner)
2139 FN_LOCAL_BOOL(lp_use_client_driver, bUseClientDriver)
2140 FN_LOCAL_BOOL(lp_default_devmode, bDefaultDevmode)
2141 FN_LOCAL_BOOL(lp_force_printername, bForcePrintername)
2142 FN_LOCAL_BOOL(lp_nt_acl_support, bNTAclSupport)
2143 FN_LOCAL_BOOL(lp_force_unknown_acl_user, bForceUnknownAclUser)
2144 FN_LOCAL_BOOL(lp_ea_support, bEASupport)
2145 FN_LOCAL_BOOL(_lp_use_sendfile, bUseSendfile)
2146 FN_LOCAL_BOOL(lp_profile_acls, bProfileAcls)
2147 FN_LOCAL_BOOL(lp_map_acl_inherit, bMap_acl_inherit)
2148 FN_LOCAL_BOOL(lp_afs_share, bAfs_Share)
2149 FN_LOCAL_BOOL(lp_acl_check_permissions, bAclCheckPermissions)
2150 FN_LOCAL_BOOL(lp_acl_group_control, bAclGroupControl)
2151 FN_LOCAL_BOOL(lp_acl_map_full_control, bAclMapFullControl)
2152 FN_LOCAL_INTEGER(lp_create_mask, iCreate_mask)
2153 FN_LOCAL_INTEGER(lp_force_create_mode, iCreate_force_mode)
2154 FN_LOCAL_INTEGER(lp_security_mask, iSecurity_mask)
2155 FN_LOCAL_INTEGER(lp_force_security_mode, iSecurity_force_mode)
2156 FN_LOCAL_INTEGER(lp_dir_mask, iDir_mask)
2157 FN_LOCAL_INTEGER(lp_force_dir_mode, iDir_force_mode)
2158 FN_LOCAL_INTEGER(lp_dir_security_mask, iDir_Security_mask)
2159 FN_LOCAL_INTEGER(lp_force_dir_security_mode, iDir_Security_force_mode)
2160 FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
2161 FN_LOCAL_INTEGER(lp_defaultcase, iDefaultCase)
2162 FN_LOCAL_INTEGER(lp_minprintspace, iMinPrintSpace)
2163 FN_LOCAL_INTEGER(lp_printing, iPrinting)
2164 FN_LOCAL_INTEGER(lp_max_reported_jobs, iMaxReportedPrintJobs)
2165 FN_LOCAL_INTEGER(lp_oplock_contention_limit, iOplockContentionLimit)
2166 FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
2167 FN_LOCAL_INTEGER(lp_write_cache_size, iWriteCacheSize)
2168 FN_LOCAL_INTEGER(lp_block_size, iBlock_size)
2169 FN_LOCAL_INTEGER(lp_dfree_cache_time, iDfreeCacheTime)
2170 FN_LOCAL_INTEGER(lp_allocation_roundup_size, iallocation_roundup_size)
2171 FN_LOCAL_INTEGER(lp_aio_read_size, iAioReadSize)
2172 FN_LOCAL_INTEGER(lp_aio_write_size, iAioWriteSize)
2173 FN_LOCAL_INTEGER(lp_map_readonly, iMap_readonly)
2174 FN_LOCAL_CHAR(lp_magicchar, magic_char)
2175 FN_GLOBAL_INTEGER(lp_winbind_cache_time, &Globals.winbind_cache_time)
2176 FN_GLOBAL_LIST(lp_winbind_nss_info, &Globals.szWinbindNssInfo)
2177 FN_GLOBAL_INTEGER(lp_algorithmic_rid_base, &Globals.AlgorithmicRidBase)
2178 FN_GLOBAL_INTEGER(lp_name_cache_timeout, &Globals.name_cache_timeout)
2179 FN_GLOBAL_INTEGER(lp_client_signing, &Globals.client_signing)
2180 FN_GLOBAL_INTEGER(lp_server_signing, &Globals.server_signing)
2181
2182 /* local prototypes */
2183
2184 static int map_parameter(const char *pszParmName);
2185 static BOOL set_boolean(BOOL *pb, const char *pszParmValue);
2186 static int getservicebyname(const char *pszServiceName,
2187                             service * pserviceDest);
2188 static void copy_service(service * pserviceDest,
2189                          service * pserviceSource, BOOL *pcopymapDest);
2190 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue);
2191 static BOOL do_section(const char *pszSectionName);
2192 static void init_copymap(service * pservice);
2193 static BOOL hash_a_service(const char *name, int number);
2194 static void free_service_byindex(int iService);
2195 static char * canonicalize_servicename(const char *name);
2196
2197 /* This is a helper function for parametrical options support. */
2198 /* It returns a pointer to parametrical option value if it exists or NULL otherwise */
2199 /* Actual parametrical functions are quite simple */
2200 static param_opt_struct *get_parametrics(int snum, const char *type, const char *option)
2201 {
2202         BOOL global_section = False;
2203         char* param_key;
2204         param_opt_struct *data;
2205
2206         if (snum >= iNumServices) return NULL;
2207
2208         if (snum < 0) {
2209                 data = Globals.param_opt;
2210                 global_section = True;
2211         } else {
2212                 data = ServicePtrs[snum]->param_opt;
2213         }
2214
2215         asprintf(&param_key, "%s:%s", type, option);
2216         if (!param_key) {
2217                 DEBUG(0,("asprintf failed!\n"));
2218                 return NULL;
2219         }
2220
2221         while (data) {
2222                 if (strcmp(data->key, param_key) == 0) {
2223                         string_free(&param_key);
2224                         return data;
2225                 }
2226                 data = data->next;
2227         }
2228
2229         if (!global_section) {
2230                 /* Try to fetch the same option but from globals */
2231                 /* but only if we are not already working with Globals */
2232                 data = Globals.param_opt;
2233                 while (data) {
2234                         if (strcmp(data->key, param_key) == 0) {
2235                                 string_free(&param_key);
2236                                 return data;
2237                         }
2238                         data = data->next;
2239                 }
2240         }
2241
2242         string_free(&param_key);
2243
2244         return NULL;
2245 }
2246
2247
2248 #define MISSING_PARAMETER(name) \
2249     DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
2250
2251 /*******************************************************************
2252 convenience routine to return int parameters.
2253 ********************************************************************/
2254 static int lp_int(const char *s)
2255 {
2256
2257         if (!s || !*s) {
2258                 MISSING_PARAMETER(lp_int);
2259                 return (-1);
2260         }
2261
2262         return (int)strtol(s, NULL, 0);
2263 }
2264
2265 /*******************************************************************
2266 convenience routine to return unsigned long parameters.
2267 ********************************************************************/
2268 static unsigned long lp_ulong(const char *s)
2269 {
2270
2271         if (!s || !*s) {
2272                 MISSING_PARAMETER(lp_ulong);
2273                 return (0);
2274         }
2275
2276         return strtoul(s, NULL, 0);
2277 }
2278
2279 /*******************************************************************
2280 convenience routine to return boolean parameters.
2281 ********************************************************************/
2282 static BOOL lp_bool(const char *s)
2283 {
2284         BOOL ret = False;
2285
2286         if (!s || !*s) {
2287                 MISSING_PARAMETER(lp_bool);
2288                 return False;
2289         }
2290
2291         if (!set_boolean(&ret,s)) {
2292                 DEBUG(0,("lp_bool(%s): value is not boolean!\n",s));
2293                 return False;
2294         }
2295
2296         return ret;
2297 }
2298
2299 /*******************************************************************
2300 convenience routine to return enum parameters.
2301 ********************************************************************/
2302 static int lp_enum(const char *s,const struct enum_list *_enum)
2303 {
2304         int i;
2305
2306         if (!s || !*s || !_enum) {
2307                 MISSING_PARAMETER(lp_enum);
2308                 return (-1);
2309         }
2310
2311         for (i=0; _enum[i].name; i++) {
2312                 if (strequal(_enum[i].name,s))
2313                         return _enum[i].value;
2314         }
2315
2316         DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
2317         return (-1);
2318 }
2319
2320 #undef MISSING_PARAMETER
2321
2322 /* DO NOT USE lp_parm_string ANYMORE!!!!
2323  * use lp_parm_const_string or lp_parm_talloc_string
2324  *
2325  * lp_parm_string is only used to let old modules find this symbol
2326  */
2327 #undef lp_parm_string
2328  char *lp_parm_string(const char *servicename, const char *type, const char *option);
2329  char *lp_parm_string(const char *servicename, const char *type, const char *option)
2330 {
2331         return lp_parm_talloc_string(lp_servicenumber(servicename), type, option, NULL);
2332 }
2333
2334 /* Return parametric option from a given service. Type is a part of option before ':' */
2335 /* Parametric option has following syntax: 'Type: option = value' */
2336 /* the returned value is talloced in lp_talloc */
2337 char *lp_parm_talloc_string(int snum, const char *type, const char *option, const char *def)
2338 {
2339         param_opt_struct *data = get_parametrics(snum, type, option);
2340
2341         if (data == NULL||data->value==NULL) {
2342                 if (def) {
2343                         return lp_string(def);
2344                 } else {
2345                         return NULL;
2346                 }
2347         }
2348
2349         return lp_string(data->value);
2350 }
2351
2352 /* Return parametric option from a given service. Type is a part of option before ':' */
2353 /* Parametric option has following syntax: 'Type: option = value' */
2354 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
2355 {
2356         param_opt_struct *data = get_parametrics(snum, type, option);
2357
2358         if (data == NULL||data->value==NULL)
2359                 return def;
2360
2361         return data->value;
2362 }
2363
2364 /* Return parametric option from a given service. Type is a part of option before ':' */
2365 /* Parametric option has following syntax: 'Type: option = value' */
2366
2367 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
2368 {
2369         param_opt_struct *data = get_parametrics(snum, type, option);
2370
2371         if (data == NULL||data->value==NULL)
2372                 return (const char **)def;
2373
2374         if (data->list==NULL) {
2375                 data->list = str_list_make(data->value, NULL);
2376         }
2377
2378         return (const char **)data->list;
2379 }
2380
2381 /* Return parametric option from a given service. Type is a part of option before ':' */
2382 /* Parametric option has following syntax: 'Type: option = value' */
2383
2384 int lp_parm_int(int snum, const char *type, const char *option, int def)
2385 {
2386         param_opt_struct *data = get_parametrics(snum, type, option);
2387
2388         if (data && data->value && *data->value)
2389                 return lp_int(data->value);
2390
2391         return def;
2392 }
2393
2394 /* Return parametric option from a given service. Type is a part of option before ':' */
2395 /* Parametric option has following syntax: 'Type: option = value' */
2396
2397 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
2398 {
2399         param_opt_struct *data = get_parametrics(snum, type, option);
2400
2401         if (data && data->value && *data->value)
2402                 return lp_ulong(data->value);
2403
2404         return def;
2405 }
2406
2407 /* Return parametric option from a given service. Type is a part of option before ':' */
2408 /* Parametric option has following syntax: 'Type: option = value' */
2409
2410 BOOL lp_parm_bool(int snum, const char *type, const char *option, BOOL def)
2411 {
2412         param_opt_struct *data = get_parametrics(snum, type, option);
2413
2414         if (data && data->value && *data->value)
2415                 return lp_bool(data->value);
2416
2417         return def;
2418 }
2419
2420 /* Return parametric option from a given service. Type is a part of option before ':' */
2421 /* Parametric option has following syntax: 'Type: option = value' */
2422
2423 int lp_parm_enum(int snum, const char *type, const char *option,
2424                  const struct enum_list *_enum, int def)
2425 {
2426         param_opt_struct *data = get_parametrics(snum, type, option);
2427
2428         if (data && data->value && *data->value && _enum)
2429                 return lp_enum(data->value, _enum);
2430
2431         return def;
2432 }
2433
2434
2435 /***************************************************************************
2436  Initialise a service to the defaults.
2437 ***************************************************************************/
2438
2439 static void init_service(service * pservice)
2440 {
2441         memset((char *)pservice, '\0', sizeof(service));
2442         copy_service(pservice, &sDefault, NULL);
2443 }
2444
2445 /***************************************************************************
2446  Free the dynamically allocated parts of a service struct.
2447 ***************************************************************************/
2448
2449 static void free_service(service *pservice)
2450 {
2451         int i;
2452         param_opt_struct *data, *pdata;
2453         if (!pservice)
2454                 return;
2455
2456         if (pservice->szService)
2457                 DEBUG(5, ("free_service: Freeing service %s\n",
2458                        pservice->szService));
2459
2460         string_free(&pservice->szService);
2461         SAFE_FREE(pservice->copymap);
2462
2463         for (i = 0; parm_table[i].label; i++) {
2464                 if ((parm_table[i].type == P_STRING ||
2465                      parm_table[i].type == P_USTRING) &&
2466                     parm_table[i].p_class == P_LOCAL)
2467                         string_free((char **)
2468                                     (((char *)pservice) +
2469                                      PTR_DIFF(parm_table[i].ptr, &sDefault)));
2470                 else if (parm_table[i].type == P_LIST &&
2471                          parm_table[i].p_class == P_LOCAL)
2472                              str_list_free((char ***)
2473                                             (((char *)pservice) +
2474                                              PTR_DIFF(parm_table[i].ptr, &sDefault)));
2475         }
2476
2477         data = pservice->param_opt;
2478         if (data)
2479                 DEBUG(5,("Freeing parametrics:\n"));
2480         while (data) {
2481                 DEBUG(5,("[%s = %s]\n", data->key, data->value));
2482                 string_free(&data->key);
2483                 string_free(&data->value);
2484                 str_list_free(&data->list);
2485                 pdata = data->next;
2486                 SAFE_FREE(data);
2487                 data = pdata;
2488         }
2489
2490         ZERO_STRUCTP(pservice);
2491 }
2492
2493
2494 /***************************************************************************
2495  remove a service indexed in the ServicePtrs array from the ServiceHash
2496  and free the dynamically allocated parts
2497 ***************************************************************************/
2498
2499 static void free_service_byindex(int idx)
2500 {
2501         if ( !LP_SNUM_OK(idx) )
2502                 return;
2503
2504         ServicePtrs[idx]->valid = False;
2505         invalid_services[num_invalid_services++] = idx;
2506
2507         /* we have to cleanup the hash record */
2508
2509         if (ServicePtrs[idx]->szService) {
2510                 char *canon_name = canonicalize_servicename( ServicePtrs[idx]->szService );
2511
2512                 tdb_delete_bystring(ServiceHash, canon_name );
2513         }
2514
2515         free_service(ServicePtrs[idx]);
2516 }
2517
2518 /***************************************************************************
2519  Add a new service to the services array initialising it with the given
2520  service.
2521 ***************************************************************************/
2522
2523 static int add_a_service(const service *pservice, const char *name)
2524 {
2525         int i;
2526         service tservice;
2527         int num_to_alloc = iNumServices + 1;
2528         param_opt_struct *data, *pdata;
2529
2530         tservice = *pservice;
2531
2532         /* it might already exist */
2533         if (name) {
2534                 i = getservicebyname(name, NULL);
2535                 if (i >= 0) {
2536                         /* Clean all parametric options for service */
2537                         /* They will be added during parsing again */
2538                         data = ServicePtrs[i]->param_opt;
2539                         while (data) {
2540                                 string_free(&data->key);
2541                                 string_free(&data->value);
2542                                 str_list_free(&data->list);
2543                                 pdata = data->next;
2544                                 SAFE_FREE(data);
2545                                 data = pdata;
2546                         }
2547                         ServicePtrs[i]->param_opt = NULL;
2548                         return (i);
2549                 }
2550         }
2551
2552         /* find an invalid one */
2553         i = iNumServices;
2554         if (num_invalid_services > 0) {
2555                 i = invalid_services[--num_invalid_services];
2556         }
2557
2558         /* if not, then create one */
2559         if (i == iNumServices) {
2560                 service **tsp;
2561                 int *tinvalid;
2562
2563                 tsp = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(ServicePtrs, service *, num_to_alloc);
2564                 if (tsp == NULL) {
2565                         DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
2566                         return (-1);
2567                 }
2568                 ServicePtrs = tsp;
2569                 ServicePtrs[iNumServices] = SMB_MALLOC_P(service);
2570                 if (!ServicePtrs[iNumServices]) {
2571                         DEBUG(0,("add_a_service: out of memory!\n"));
2572                         return (-1);
2573                 }
2574                 iNumServices++;
2575
2576                 /* enlarge invalid_services here for now... */
2577                 tinvalid = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(invalid_services, int,
2578                                              num_to_alloc);
2579                 if (tinvalid == NULL) {
2580                         DEBUG(0,("add_a_service: failed to enlarge "
2581                                  "invalid_services!\n"));
2582                         return (-1);
2583                 }
2584                 invalid_services = tinvalid;
2585         } else {
2586                 free_service_byindex(i);
2587         }
2588
2589         ServicePtrs[i]->valid = True;
2590
2591         init_service(ServicePtrs[i]);
2592         copy_service(ServicePtrs[i], &tservice, NULL);
2593         if (name)
2594                 string_set(&ServicePtrs[i]->szService, name);
2595
2596         DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
2597                 i, ServicePtrs[i]->szService));
2598
2599         if (!hash_a_service(ServicePtrs[i]->szService, i)) {
2600                 return (-1);
2601         }
2602
2603         return (i);
2604 }
2605
2606 /***************************************************************************
2607   Canonicalize by converting to lowercase.
2608 ***************************************************************************/
2609
2610 static char *canonicalize_servicename(const char *src)
2611 {
2612         static fstring canon; /* is fstring large enough? */
2613
2614         if ( !src ) {
2615                 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
2616                 return NULL;
2617         }
2618
2619         fstrcpy( canon, src );
2620         strlower_m( canon );
2621
2622         return canon;
2623 }
2624
2625 /***************************************************************************
2626   Add a name/index pair for the services array to the hash table.
2627 ***************************************************************************/
2628
2629 static BOOL hash_a_service(const char *name, int idx)
2630 {
2631         char *canon_name;
2632
2633         if ( !ServiceHash ) {
2634                 DEBUG(10,("hash_a_service: creating tdb servicehash\n"));
2635                 ServiceHash = tdb_open("servicehash", 1031, TDB_INTERNAL,
2636                                         (O_RDWR|O_CREAT), 0600);
2637                 if ( !ServiceHash ) {
2638                         DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
2639                         return False;
2640                 }
2641         }
2642
2643         DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
2644                 idx, name));
2645
2646         if ( !(canon_name = canonicalize_servicename( name )) )
2647                 return False;
2648
2649         tdb_store_int32(ServiceHash, canon_name, idx);
2650
2651         return True;
2652 }
2653
2654 /***************************************************************************
2655  Add a new home service, with the specified home directory, defaults coming
2656  from service ifrom.
2657 ***************************************************************************/
2658
2659 BOOL lp_add_home(const char *pszHomename, int iDefaultService,
2660                  const char *user, const char *pszHomedir)
2661 {
2662         int i;
2663         pstring newHomedir;
2664
2665         i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
2666
2667         if (i < 0)
2668                 return (False);
2669
2670         if (!(*(ServicePtrs[iDefaultService]->szPath))
2671             || strequal(ServicePtrs[iDefaultService]->szPath, lp_pathname(GLOBAL_SECTION_SNUM))) {
2672                 pstrcpy(newHomedir, pszHomedir);
2673                 string_set(&ServicePtrs[i]->szPath, newHomedir);
2674         }
2675
2676         if (!(*(ServicePtrs[i]->comment))) {
2677                 pstring comment;
2678                 slprintf(comment, sizeof(comment) - 1,
2679                          "Home directory of %s", user);
2680                 string_set(&ServicePtrs[i]->comment, comment);
2681         }
2682
2683         /* set the browseable flag from the global default */
2684
2685         ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2686
2687         ServicePtrs[i]->autoloaded = True;
2688
2689         DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
2690                user, ServicePtrs[i]->szPath ));
2691
2692         return (True);
2693 }
2694
2695 /***************************************************************************
2696  Add a new service, based on an old one.
2697 ***************************************************************************/
2698
2699 int lp_add_service(const char *pszService, int iDefaultService)
2700 {
2701         if (iDefaultService < 0) {
2702                 return add_a_service(&sDefault, pszService);
2703         }
2704
2705         return (add_a_service(ServicePtrs[iDefaultService], pszService));
2706 }
2707
2708 /***************************************************************************
2709  Add the IPC service.
2710 ***************************************************************************/
2711
2712 static BOOL lp_add_ipc(const char *ipc_name, BOOL guest_ok)
2713 {
2714         pstring comment;
2715         int i = add_a_service(&sDefault, ipc_name);
2716
2717         if (i < 0)
2718                 return (False);
2719
2720         slprintf(comment, sizeof(comment) - 1,
2721                  "IPC Service (%s)", Globals.szServerString);
2722
2723         string_set(&ServicePtrs[i]->szPath, tmpdir());
2724         string_set(&ServicePtrs[i]->szUsername, "");
2725         string_set(&ServicePtrs[i]->comment, comment);
2726         string_set(&ServicePtrs[i]->fstype, "IPC");
2727         ServicePtrs[i]->iMaxConnections = 0;
2728         ServicePtrs[i]->bAvailable = True;
2729         ServicePtrs[i]->bRead_only = True;
2730         ServicePtrs[i]->bGuest_only = False;
2731         ServicePtrs[i]->bGuest_ok = guest_ok;
2732         ServicePtrs[i]->bPrint_ok = False;
2733         ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2734
2735         DEBUG(3, ("adding IPC service\n"));
2736
2737         return (True);
2738 }
2739
2740 /***************************************************************************
2741  Add a new printer service, with defaults coming from service iFrom.
2742 ***************************************************************************/
2743
2744 BOOL lp_add_printer(const char *pszPrintername, int iDefaultService)
2745 {
2746         const char *comment = "From Printcap";
2747         int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
2748
2749         if (i < 0)
2750                 return (False);
2751
2752         /* note that we do NOT default the availability flag to True - */
2753         /* we take it from the default service passed. This allows all */
2754         /* dynamic printers to be disabled by disabling the [printers] */
2755         /* entry (if/when the 'available' keyword is implemented!).    */
2756
2757         /* the printer name is set to the service name. */
2758         string_set(&ServicePtrs[i]->szPrintername, pszPrintername);
2759         string_set(&ServicePtrs[i]->comment, comment);
2760
2761         /* set the browseable flag from the gloabl default */
2762         ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2763
2764         /* Printers cannot be read_only. */
2765         ServicePtrs[i]->bRead_only = False;
2766         /* No share modes on printer services. */
2767         ServicePtrs[i]->bShareModes = False;
2768         /* No oplocks on printer services. */
2769         ServicePtrs[i]->bOpLocks = False;
2770         /* Printer services must be printable. */
2771         ServicePtrs[i]->bPrint_ok = True;
2772
2773         DEBUG(3, ("adding printer service %s\n", pszPrintername));
2774
2775         return (True);
2776 }
2777
2778
2779 /***************************************************************************
2780  Check whether the given parameter name is valid.
2781  Parametric options (names containing a colon) are considered valid.
2782 ***************************************************************************/
2783
2784 BOOL lp_parameter_is_valid(const char *pszParmName)
2785 {
2786         return ((map_parameter(pszParmName) != -1) ||
2787                 (strchr(pszParmName, ':') != NULL));
2788 }
2789
2790 /***************************************************************************
2791  Check whether the given name is the name of a global parameter.
2792  Returns True for strings belonging to parameters of class
2793  P_GLOBAL, False for all other strings, also for parametric options
2794  and strings not belonging to any option.
2795 ***************************************************************************/
2796
2797 BOOL lp_parameter_is_global(const char *pszParmName)
2798 {
2799         int num = map_parameter(pszParmName);
2800
2801         if (num >= 0) {
2802                 return (parm_table[num].p_class == P_GLOBAL);
2803         }
2804
2805         return False;
2806 }
2807
2808 /***************************************************************************
2809  Map a parameter's string representation to something we can use.
2810  Returns False if the parameter string is not recognised, else TRUE.
2811 ***************************************************************************/
2812
2813 static int map_parameter(const char *pszParmName)
2814 {
2815         int iIndex;
2816
2817         if (*pszParmName == '-')
2818                 return (-1);
2819
2820         for (iIndex = 0; parm_table[iIndex].label; iIndex++)
2821                 if (strwicmp(parm_table[iIndex].label, pszParmName) == 0)
2822                         return (iIndex);
2823
2824         /* Warn only if it isn't parametric option */
2825         if (strchr(pszParmName, ':') == NULL)
2826                 DEBUG(0, ("Unknown parameter encountered: \"%s\"\n", pszParmName));
2827         /* We do return 'fail' for parametric options as well because they are
2828            stored in different storage
2829          */
2830         return (-1);
2831 }
2832
2833 /***************************************************************************
2834  Show all parameter's name, type, [values,] and flags.
2835 ***************************************************************************/
2836
2837 void show_parameter_list(void)
2838 {
2839         int classIndex, parmIndex, enumIndex, flagIndex;
2840         BOOL hadFlag;
2841         const char *section_names[] = { "local", "global", NULL};
2842         const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
2843                 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING", "P_GSTRING",
2844                 "P_UGSTRING", "P_ENUM", "P_SEP"};
2845         unsigned flags[] = { FLAG_BASIC, FLAG_SHARE, FLAG_PRINT, FLAG_GLOBAL,
2846                 FLAG_WIZARD, FLAG_ADVANCED, FLAG_DEVELOPER, FLAG_DEPRECATED,
2847                 FLAG_HIDE, FLAG_DOS_STRING};
2848         const char *flag_names[] = { "FLAG_BASIC", "FLAG_SHARE", "FLAG_PRINT",
2849                 "FLAG_GLOBAL", "FLAG_WIZARD", "FLAG_ADVANCED", "FLAG_DEVELOPER",
2850                 "FLAG_DEPRECATED", "FLAG_HIDE", "FLAG_DOS_STRING", NULL};
2851
2852         for ( classIndex=0; section_names[classIndex]; classIndex++) {
2853                 printf("[%s]\n", section_names[classIndex]);
2854                 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
2855                         if (parm_table[parmIndex].p_class == classIndex) {
2856                                 printf("%s=%s",
2857                                         parm_table[parmIndex].label,
2858                                         type[parm_table[parmIndex].type]);
2859                                 switch (parm_table[parmIndex].type) {
2860                                 case P_ENUM:
2861                                         printf(",");
2862                                         for (enumIndex=0; parm_table[parmIndex].enum_list[enumIndex].name; enumIndex++)
2863                                                 printf("%s%s",
2864                                                         enumIndex ? "|" : "",
2865                                                         parm_table[parmIndex].enum_list[enumIndex].name);
2866                                         break;
2867                                 default:
2868                                         break;
2869                                 }
2870                                 printf(",");
2871                                 hadFlag = False;
2872                                 for ( flagIndex=0; flag_names[flagIndex]; flagIndex++ ) {
2873                                         if (parm_table[parmIndex].flags & flags[flagIndex]) {
2874                                                 printf("%s%s",
2875                                                         hadFlag ? "|" : "",
2876                                                         flag_names[flagIndex]);
2877                                                 hadFlag = True;
2878                                         }
2879                                 }
2880                                 printf("\n");
2881                         }
2882                 }
2883         }
2884 }
2885
2886 /***************************************************************************
2887  Set a boolean variable from the text value stored in the passed string.
2888  Returns True in success, False if the passed string does not correctly
2889  represent a boolean.
2890 ***************************************************************************/
2891
2892 static BOOL set_boolean(BOOL *pb, const char *pszParmValue)
2893 {
2894         BOOL bRetval;
2895
2896         bRetval = True;
2897         if (strwicmp(pszParmValue, "yes") == 0 ||
2898             strwicmp(pszParmValue, "true") == 0 ||
2899             strwicmp(pszParmValue, "1") == 0)
2900                 *pb = True;
2901         else if (strwicmp(pszParmValue, "no") == 0 ||
2902                     strwicmp(pszParmValue, "False") == 0 ||
2903                     strwicmp(pszParmValue, "0") == 0)
2904                 *pb = False;
2905         else {
2906                 DEBUG(0,
2907                       ("ERROR: Badly formed boolean in configuration file: \"%s\".\n",
2908                        pszParmValue));
2909                 bRetval = False;
2910         }
2911         return (bRetval);
2912 }
2913
2914 /***************************************************************************
2915 Find a service by name. Otherwise works like get_service.
2916 ***************************************************************************/
2917
2918 static int getservicebyname(const char *pszServiceName, service * pserviceDest)
2919 {
2920         int iService = -1;
2921         char *canon_name;
2922
2923         if (ServiceHash != NULL) {
2924                 if ( !(canon_name = canonicalize_servicename( pszServiceName )) )
2925                         return -1;
2926
2927                 iService = tdb_fetch_int32(ServiceHash, canon_name );
2928
2929                 if (LP_SNUM_OK(iService)) {
2930                         if (pserviceDest != NULL) {
2931                                 copy_service(pserviceDest, ServicePtrs[iService], NULL);
2932                         }
2933                 } else {
2934                         iService = -1;
2935                 }
2936         }
2937
2938         return (iService);
2939 }
2940
2941 /***************************************************************************
2942  Copy a service structure to another.
2943  If pcopymapDest is NULL then copy all fields
2944 ***************************************************************************/
2945
2946 static void copy_service(service * pserviceDest, service * pserviceSource, BOOL *pcopymapDest)
2947 {
2948         int i;
2949         BOOL bcopyall = (pcopymapDest == NULL);
2950         param_opt_struct *data, *pdata, *paramo;
2951         BOOL not_added;
2952
2953         for (i = 0; parm_table[i].label; i++)
2954                 if (parm_table[i].ptr && parm_table[i].p_class == P_LOCAL &&
2955                     (bcopyall || pcopymapDest[i])) {
2956                         void *def_ptr = parm_table[i].ptr;
2957                         void *src_ptr =
2958                                 ((char *)pserviceSource) + PTR_DIFF(def_ptr,
2959                                                                     &sDefault);
2960                         void *dest_ptr =
2961                                 ((char *)pserviceDest) + PTR_DIFF(def_ptr,
2962                                                                   &sDefault);
2963
2964                         switch (parm_table[i].type) {
2965                                 case P_BOOL:
2966                                 case P_BOOLREV:
2967                                         *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
2968                                         break;
2969
2970                                 case P_INTEGER:
2971                                 case P_ENUM:
2972                                 case P_OCTAL:
2973                                         *(int *)dest_ptr = *(int *)src_ptr;
2974                                         break;
2975
2976                                 case P_CHAR:
2977                                         *(char *)dest_ptr = *(char *)src_ptr;
2978                                         break;
2979
2980                                 case P_STRING:
2981                                         string_set((char **)dest_ptr,
2982                                                    *(char **)src_ptr);
2983                                         break;
2984
2985                                 case P_USTRING:
2986                                         string_set((char **)dest_ptr,
2987                                                    *(char **)src_ptr);
2988                                         strupper_m(*(char **)dest_ptr);
2989                                         break;
2990                                 case P_LIST:
2991                                         str_list_free((char ***)dest_ptr);
2992                                         str_list_copy((char ***)dest_ptr, *(const char ***)src_ptr);
2993                                         break;
2994                                 default:
2995                                         break;
2996                         }
2997                 }
2998
2999         if (bcopyall) {
3000                 init_copymap(pserviceDest);
3001                 if (pserviceSource->copymap)
3002                         memcpy((void *)pserviceDest->copymap,
3003                                (void *)pserviceSource->copymap,
3004                                sizeof(BOOL) * NUMPARAMETERS);
3005         }
3006
3007         data = pserviceSource->param_opt;
3008         while (data) {
3009                 not_added = True;
3010                 pdata = pserviceDest->param_opt;
3011                 /* Traverse destination */
3012                 while (pdata) {
3013                         /* If we already have same option, override it */
3014                         if (strcmp(pdata->key, data->key) == 0) {
3015                                 string_free(&pdata->value);
3016                                 str_list_free(&data->list);
3017                                 pdata->value = SMB_STRDUP(data->value);
3018                                 not_added = False;
3019                                 break;
3020                         }
3021                         pdata = pdata->next;
3022                 }
3023                 if (not_added) {
3024                     paramo = SMB_XMALLOC_P(param_opt_struct);
3025                     paramo->key = SMB_STRDUP(data->key);
3026                     paramo->value = SMB_STRDUP(data->value);
3027                     paramo->list = NULL;
3028                     DLIST_ADD(pserviceDest->param_opt, paramo);
3029                 }
3030                 data = data->next;
3031         }
3032 }
3033
3034 /***************************************************************************
3035 Check a service for consistency. Return False if the service is in any way
3036 incomplete or faulty, else True.
3037 ***************************************************************************/
3038
3039 BOOL service_ok(int iService)
3040 {
3041         BOOL bRetval;
3042
3043         bRetval = True;
3044         if (ServicePtrs[iService]->szService[0] == '\0') {
3045                 DEBUG(0, ("The following message indicates an internal error:\n"));
3046                 DEBUG(0, ("No service name in service entry.\n"));
3047                 bRetval = False;
3048         }
3049
3050         /* The [printers] entry MUST be printable. I'm all for flexibility, but */
3051         /* I can't see why you'd want a non-printable printer service...        */
3052         if (strwicmp(ServicePtrs[iService]->szService, PRINTERS_NAME) == 0) {
3053                 if (!ServicePtrs[iService]->bPrint_ok) {
3054                         DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
3055                                ServicePtrs[iService]->szService));
3056                         ServicePtrs[iService]->bPrint_ok = True;
3057                 }
3058                 /* [printers] service must also be non-browsable. */
3059                 if (ServicePtrs[iService]->bBrowseable)
3060                         ServicePtrs[iService]->bBrowseable = False;
3061         }
3062
3063         if (ServicePtrs[iService]->szPath[0] == '\0' &&
3064             strwicmp(ServicePtrs[iService]->szService, HOMES_NAME) != 0 &&
3065             ServicePtrs[iService]->szMSDfsProxy[0] == '\0'
3066             ) {
3067                 DEBUG(0, ("WARNING: No path in service %s - making it unavailable!\n",
3068                         ServicePtrs[iService]->szService));
3069                 ServicePtrs[iService]->bAvailable = False;
3070         }
3071
3072         /* If a service is flagged unavailable, log the fact at level 1. */
3073         if (!ServicePtrs[iService]->bAvailable)
3074                 DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
3075                           ServicePtrs[iService]->szService));
3076
3077         return (bRetval);
3078 }
3079
3080 /*
3081  * lp_regdb_open - regdb helper function
3082  *
3083  * this should be considered an interim solution that becomes
3084  * superfluous once the registry code has been rewritten
3085  * do allow use of the tdb portion of the registry alone.
3086  *
3087  * in the meanwhile this provides a lean access
3088  * to the registry globals.
3089  */
3090
3091 static struct tdb_wrap *lp_regdb_open(void)
3092 {
3093         struct tdb_wrap *reg_tdb = NULL;
3094         const char *vstring = "INFO/version";
3095         uint32 vers_id;
3096
3097         become_root();
3098         reg_tdb = tdb_wrap_open(NULL, lock_path("registry.tdb"), 0,
3099                                 REG_TDB_FLAGS, O_RDWR, 0600);
3100         if (!reg_tdb) {
3101                 DEBUG(1, ("lp_regdb_open: failed to open %s: %s\n",
3102                          lock_path("registry.tdb"), strerror(errno)));
3103                 goto done;
3104         }
3105         else {
3106                 DEBUG(10, ("lp_regdb_open: reg tdb opened.\n"));
3107         }
3108         unbecome_root();
3109
3110         vers_id = tdb_fetch_int32(reg_tdb->tdb, vstring);
3111         if (vers_id != REGVER_V1) {
3112                 DEBUG(10, ("lp_regdb_open: INFO: registry tdb %s has wrong "
3113                           "INFO/version (got %d, expected %d)\n",
3114                           lock_path("registry.tdb"), vers_id, REGVER_V1));
3115                 /* this is apparently not implemented in the tdb */
3116         }
3117
3118 done:
3119         return reg_tdb;
3120 }
3121
3122 /*
3123  * process_registry_globals
3124  *
3125  * this is the interim version of process_registry globals
3126  *
3127  * until we can do it as we would like using the api and only
3128  * using the tdb portion of the registry (see below),
3129  * this just provides the needed functionality of regdb_fetch_values
3130  * and regdb_unpack_values, circumventing any fancy stuff, to
3131  * give us access to the registry globals.
3132  */
3133 static BOOL process_registry_globals(BOOL (*pfunc)(const char *, const char *))
3134 {
3135         BOOL ret = False;
3136         struct tdb_wrap *reg_tdb = NULL;
3137         WERROR err;
3138         char *keystr;
3139         TDB_DATA data;
3140         /* vars for the tdb unpack loop */
3141         int len = 0;
3142         int i;
3143         int buflen;
3144         uint8 *buf;
3145         uint32 type;
3146         uint32 size;
3147         uint32 num_values = 0;
3148         uint8 *data_p;
3149         pstring valname;
3150         char * valstr;
3151         struct registry_value *value = NULL;
3152
3153         include_registry_globals = True;
3154
3155         ZERO_STRUCT(data);
3156
3157         reg_tdb = lp_regdb_open();
3158         if (!reg_tdb) {
3159                 DEBUG(1, ("Error opening the registry!\n"));
3160                 goto done;
3161         }
3162
3163         /* reg_tdb is from now on used as talloc ctx.
3164          * freeing it closes the tdb (if refcount is 0) */
3165
3166         keystr = talloc_asprintf(reg_tdb,"%s/%s/%s", REG_VALUE_PREFIX,
3167                                  KEY_SMBCONF, GLOBAL_NAME);
3168         normalize_dbkey(keystr);
3169
3170         DEBUG(10, ("process_registry_globals: fetching key '%s'\n",
3171                    keystr));
3172
3173         data = tdb_fetch_bystring(reg_tdb->tdb, keystr);
3174         if (!data.dptr) {
3175                 ret = True;
3176                 goto done;
3177         }
3178
3179         buf = data.dptr;
3180         buflen = data.dsize;
3181
3182         /* unpack number of values */
3183         len = tdb_unpack(buf, buflen, "d", &num_values);
3184         DEBUG(10, ("process_registry_globals: got %d values from tdb\n",
3185                    num_values));
3186
3187         /* unpack the values */
3188         for (i=0; i < num_values; i++) {
3189                 type = REG_NONE;
3190                 size = 0;
3191                 data_p = NULL;
3192                 len += tdb_unpack(buf+len, buflen-len, "fdB",
3193                                   valname,
3194                                   &type,
3195                                   &size,
3196                                   &data_p);
3197                 if (registry_smbconf_valname_forbidden(valname)) {
3198                         DEBUG(10, ("process_registry_globals: Ignoring "
3199                                    "parameter '%s' in registry.\n", valname));
3200                         continue;
3201                 }
3202                 DEBUG(10, ("process_registry_globals: got value '%s'\n",
3203                            valname));
3204                 if (size && data_p) {
3205                         err = registry_pull_value(reg_tdb,
3206                                                   &value,
3207                                                   type,
3208                                                   data_p,
3209                                                   size,
3210                                                   size);
3211                         SAFE_FREE(data_p);
3212                         if (!W_ERROR_IS_OK(err)) {
3213                                 goto done;
3214                         }
3215                         switch(type) {
3216                         case REG_DWORD:
3217                                 valstr = talloc_asprintf(reg_tdb, "%d",
3218                                                          value->v.dword);
3219                                 pfunc(valname, valstr);
3220                                 break;
3221                         case REG_SZ:
3222                                 pfunc(valname, value->v.sz.str);
3223                                 break;
3224                         default:
3225                                 /* ignore other types */
3226                                 break;
3227                         }
3228                 }
3229         }
3230
3231         ret = pfunc("registry shares", "yes");
3232         regdb_last_seqnum = tdb_get_seqnum(reg_tdb->tdb);
3233
3234 done:
3235         TALLOC_FREE(reg_tdb);
3236         SAFE_FREE(data.dptr);
3237         return ret;
3238 }
3239
3240 #if 0
3241 /*
3242  * this is process_registry_globals as it _should_ be (roughly)
3243  * using the reg_api functions...
3244  *
3245  */
3246 static BOOL process_registry_globals(BOOL (*pfunc)(const char *, const char *))
3247 {
3248         BOOL ret = False;
3249         TALLOC_CTX *ctx = NULL;
3250         char *regpath = NULL;
3251         WERROR werr = WERR_OK;
3252         struct registry_key *key = NULL;
3253         struct registry_value *value = NULL;
3254         char *valname = NULL;
3255         char *valstr = NULL;
3256         uint32 idx = 0;
3257         NT_USER_TOKEN *token;
3258
3259         ctx = talloc_init("process_registry_globals");
3260         if (!ctx) {
3261                 smb_panic("Failed to create talloc context!");
3262         }
3263
3264         include_registry_globals = True;
3265
3266         if (!registry_init_regdb()) {
3267                 DEBUG(1, ("Error initializing the registry.\n"));
3268                 goto done;
3269         }
3270
3271         if (!(token = registry_create_admin_token(ctx))) {
3272                 DEBUG(1, ("Error creating admin token\n"));
3273                 goto done;
3274         }
3275
3276         regpath = talloc_asprintf(ctx,"%s\\%s", KEY_SMBCONF, GLOBAL_NAME);
3277         werr = reg_open_path(ctx, regpath, REG_KEY_READ, token, &key);
3278         if (!W_ERROR_IS_OK(werr)) {
3279                 DEBUG(1, ("Registry smbconf global section does not exist.\n"));
3280                 DEBUGADD(1, ("Error opening registry path '%s\\%s: %s\n",
3281                              KEY_SMBCONF, GLOBAL_NAME, dos_errstr(werr)));
3282                 goto done;
3283         }
3284
3285         for (idx = 0;
3286              W_ERROR_IS_OK(werr = reg_enumvalue(ctx, key, idx, &valname,
3287                                                 &value));
3288              idx++)
3289         {
3290                 DEBUG(5, ("got global registry parameter '%s'\n", valname));
3291                 switch(value->type) {
3292                 case REG_DWORD:
3293                         valstr = talloc_asprintf(ctx, "%d", value->v.dword);
3294                         pfunc(valname, valstr);
3295                         TALLOC_FREE(valstr);
3296                         break;
3297                 case REG_SZ:
3298                         pfunc(valname, value->v.sz.str);
3299                         break;
3300                 default:
3301                         /* ignore other types */
3302                         break;
3303                 }
3304                 TALLOC_FREE(value);
3305                 TALLOC_FREE(valstr);
3306         }
3307
3308         ret = pfunc("registry shares", "yes");
3309
3310         regdb_last_seqnum = regdb_get_seqnum();
3311
3312 done:
3313         talloc_destroy(ctx);
3314         return ret;
3315 }
3316 #endif /* if 0 */
3317
3318 static struct file_lists {
3319         struct file_lists *next;
3320         char *name;
3321         char *subfname;
3322         time_t modtime;
3323 } *file_lists = NULL;
3324
3325 /*******************************************************************
3326  Keep a linked list of all config files so we know when one has changed
3327  it's date and needs to be reloaded.
3328 ********************************************************************/
3329
3330 static void add_to_file_list(const char *fname, const char *subfname)
3331 {
3332         struct file_lists *f = file_lists;
3333
3334         while (f) {
3335                 if (f->name && !strcmp(f->name, fname))
3336                         break;
3337                 f = f->next;
3338         }
3339
3340         if (!f) {
3341                 f = SMB_MALLOC_P(struct file_lists);
3342                 if (!f)
3343                         return;
3344                 f->next = file_lists;
3345                 f->name = SMB_STRDUP(fname);
3346                 if (!f->name) {
3347                         SAFE_FREE(f);
3348                         return;
3349                 }
3350                 f->subfname = SMB_STRDUP(subfname);
3351                 if (!f->subfname) {
3352                         SAFE_FREE(f);
3353                         return;
3354                 }
3355                 file_lists = f;
3356                 f->modtime = file_modtime(subfname);
3357         } else {
3358                 time_t t = file_modtime(subfname);
3359                 if (t)
3360                         f->modtime = t;
3361         }
3362 }
3363
3364 /*******************************************************************
3365  Check if a config file has changed date.
3366 ********************************************************************/
3367
3368 BOOL lp_file_list_changed(void)
3369 {
3370         struct file_lists *f = file_lists;
3371         struct tdb_wrap *reg_tdb = NULL;
3372
3373         DEBUG(6, ("lp_file_list_changed()\n"));
3374
3375         if (include_registry_globals) {
3376                 reg_tdb = lp_regdb_open();
3377                 if (reg_tdb && (regdb_last_seqnum != tdb_get_seqnum(reg_tdb->tdb)))
3378                 {
3379                         DEBUGADD(6, ("regdb seqnum changed: old = %d, new = %d\n",
3380                                     regdb_last_seqnum, tdb_get_seqnum(reg_tdb->tdb)));
3381                         TALLOC_FREE(reg_tdb);
3382                         return True;
3383                 }
3384         }
3385
3386         while (f) {
3387                 pstring n2;
3388                 time_t mod_time;
3389
3390                 pstrcpy(n2, f->name);
3391                 standard_sub_basic( get_current_username(),
3392                                     current_user_info.domain,
3393                                     n2, sizeof(n2) );
3394
3395                 DEBUGADD(6, ("file %s -> %s  last mod_time: %s\n",
3396                              f->name, n2, ctime(&f->modtime)));
3397
3398                 mod_time = file_modtime(n2);
3399
3400                 if (mod_time && ((f->modtime != mod_time) || (f->subfname == NULL) || (strcmp(n2, f->subfname) != 0))) {
3401                         DEBUGADD(6,
3402                                  ("file %s modified: %s\n", n2,
3403                                   ctime(&mod_time)));
3404                         f->modtime = mod_time;
3405                         SAFE_FREE(f->subfname);
3406                         f->subfname = SMB_STRDUP(n2);
3407                         return (True);
3408                 }
3409                 f = f->next;
3410         }
3411         return (False);
3412 }
3413
3414 /***************************************************************************
3415  Run standard_sub_basic on netbios name... needed because global_myname
3416  is not accessed through any lp_ macro.
3417  Note: We must *NOT* use string_set() here as ptr points to global_myname.
3418 ***************************************************************************/
3419
3420 static BOOL handle_netbios_name(int snum, const char *pszParmValue, char **ptr)
3421 {
3422         BOOL ret;
3423         pstring netbios_name;
3424
3425         pstrcpy(netbios_name, pszParmValue);
3426
3427         standard_sub_basic(get_current_username(), current_user_info.domain,
3428                            netbios_name, sizeof(netbios_name));
3429
3430         ret = set_global_myname(netbios_name);
3431         string_set(&Globals.szNetbiosName,global_myname());
3432
3433         DEBUG(4, ("handle_netbios_name: set global_myname to: %s\n",
3434                global_myname()));
3435
3436         return ret;
3437 }
3438
3439 static BOOL handle_charset(int snum, const char *pszParmValue, char **ptr)
3440 {
3441         if (strcmp(*ptr, pszParmValue) != 0) {
3442                 string_set(ptr, pszParmValue);
3443                 init_iconv();
3444         }
3445         return True;
3446 }
3447
3448
3449
3450 static BOOL handle_workgroup(int snum, const char *pszParmValue, char **ptr)
3451 {
3452         BOOL ret;
3453
3454         ret = set_global_myworkgroup(pszParmValue);
3455         string_set(&Globals.szWorkgroup,lp_workgroup());
3456
3457         return ret;
3458 }
3459
3460 static BOOL handle_netbios_scope(int snum, const char *pszParmValue, char **ptr)
3461 {
3462         BOOL ret;
3463
3464         ret = set_global_scope(pszParmValue);
3465         string_set(&Globals.szNetbiosScope,global_scope());
3466
3467         return ret;
3468 }
3469
3470 static BOOL handle_netbios_aliases(int snum, const char *pszParmValue, char **ptr)
3471 {
3472         str_list_free(&Globals.szNetbiosAliases);
3473         Globals.szNetbiosAliases = str_list_make(pszParmValue, NULL);
3474         return set_netbios_aliases((const char **)Globals.szNetbiosAliases);
3475 }
3476
3477 /***************************************************************************
3478  Handle the include operation.
3479 ***************************************************************************/
3480
3481 static BOOL handle_include(int snum, const char *pszParmValue, char **ptr)
3482 {
3483         pstring fname;
3484         pstrcpy(fname, pszParmValue);
3485
3486         if (strequal(fname, INCLUDE_REGISTRY_NAME)) {
3487                 if (bInGlobalSection) {
3488                         return process_registry_globals(do_parameter);
3489                 }
3490                 else {
3491                         DEBUG(1, ("\"include = registry\" only effective "
3492                                   "in %s section\n", GLOBAL_NAME));
3493                         return False;
3494                 }
3495         }
3496
3497         standard_sub_basic(get_current_username(), current_user_info.domain,
3498                            fname,sizeof(fname));
3499
3500         add_to_file_list(pszParmValue, fname);
3501
3502         string_set(ptr, fname);
3503
3504         if (file_exist(fname, NULL))
3505                 return (pm_process(fname, do_section, do_parameter));
3506
3507         DEBUG(2, ("Can't find include file %s\n", fname));
3508
3509         return (False);
3510 }
3511
3512 /***************************************************************************
3513  Handle the interpretation of the copy parameter.
3514 ***************************************************************************/
3515
3516 static BOOL handle_copy(int snum, const char *pszParmValue, char **ptr)
3517 {
3518         BOOL bRetval;
3519         int iTemp;
3520         service serviceTemp;
3521
3522         string_set(ptr, pszParmValue);
3523
3524         init_service(&serviceTemp);
3525
3526         bRetval = False;
3527
3528         DEBUG(3, ("Copying service from service %s\n", pszParmValue));
3529
3530         if ((iTemp = getservicebyname(pszParmValue, &serviceTemp)) >= 0) {
3531                 if (iTemp == iServiceIndex) {
3532                         DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
3533                 } else {
3534                         copy_service(ServicePtrs[iServiceIndex],
3535                                      &serviceTemp,
3536                                      ServicePtrs[iServiceIndex]->copymap);
3537                         bRetval = True;
3538                 }
3539         } else {
3540                 DEBUG(0, ("Unable to copy service - source not found: %s\n", pszParmValue));
3541                 bRetval = False;
3542         }
3543
3544         free_service(&serviceTemp);
3545         return (bRetval);
3546 }
3547
3548 /***************************************************************************
3549  Handle idmap/non unix account uid and gid allocation parameters.  The format of these
3550  parameters is:
3551
3552  [global]
3553
3554         idmap uid = 1000-1999
3555         idmap gid = 700-899
3556
3557  We only do simple parsing checks here.  The strings are parsed into useful
3558  structures in the idmap daemon code.
3559
3560 ***************************************************************************/
3561
3562 /* Some lp_ routines to return idmap [ug]id information */
3563
3564 static uid_t idmap_uid_low, idmap_uid_high;
3565 static gid_t idmap_gid_low, idmap_gid_high;
3566
3567 BOOL lp_idmap_uid(uid_t *low, uid_t *high)
3568 {
3569         if (idmap_uid_low == 0 || idmap_uid_high == 0)
3570                 return False;
3571
3572         if (low)
3573                 *low = idmap_uid_low;
3574
3575         if (high)
3576                 *high = idmap_uid_high;
3577
3578         return True;
3579 }
3580
3581 BOOL lp_idmap_gid(gid_t *low, gid_t *high)
3582 {
3583         if (idmap_gid_low == 0 || idmap_gid_high == 0)
3584                 return False;
3585
3586         if (low)
3587                 *low = idmap_gid_low;
3588
3589         if (high)
3590                 *high = idmap_gid_high;
3591
3592         return True;
3593 }
3594
3595 /* Do some simple checks on "idmap [ug]id" parameter values */
3596
3597 static BOOL handle_idmap_uid(int snum, const char *pszParmValue, char **ptr)
3598 {
3599         uint32 low, high;
3600
3601         if (sscanf(pszParmValue, "%u - %u", &low, &high) != 2 || high < low)
3602                 return False;
3603
3604         /* Parse OK */
3605
3606         string_set(ptr, pszParmValue);
3607
3608         idmap_uid_low = low;
3609         idmap_uid_high = high;
3610
3611         return True;
3612 }
3613
3614 static BOOL handle_idmap_gid(int snum, const char *pszParmValue, char **ptr)
3615 {
3616         uint32 low, high;
3617
3618         if (sscanf(pszParmValue, "%u - %u", &low, &high) != 2 || high < low)
3619                 return False;
3620
3621         /* Parse OK */
3622
3623         string_set(ptr, pszParmValue);
3624
3625         idmap_gid_low = low;
3626         idmap_gid_high = high;
3627
3628         return True;
3629 }
3630
3631 /***************************************************************************
3632  Handle the DEBUG level list.
3633 ***************************************************************************/
3634
3635 static BOOL handle_debug_list( int snum, const char *pszParmValueIn, char **ptr )
3636 {
3637         pstring pszParmValue;
3638
3639         pstrcpy(pszParmValue, pszParmValueIn);
3640         string_set(ptr, pszParmValueIn);
3641         return debug_parse_levels( pszParmValue );
3642 }
3643
3644 /***************************************************************************
3645  Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
3646 ***************************************************************************/
3647
3648 static const char *append_ldap_suffix( const char *str )
3649 {
3650         const char *suffix_string;
3651
3652
3653         if (!lp_talloc)
3654                 lp_talloc = talloc_init("lp_talloc");
3655
3656         suffix_string = talloc_asprintf( lp_talloc, "%s,%s", str, Globals.szLdapSuffix );
3657         if ( !suffix_string ) {
3658                 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
3659                 return "";
3660         }
3661
3662         return suffix_string;
3663 }
3664
3665 const char *lp_ldap_machine_suffix(void)
3666 {
3667         if (Globals.szLdapMachineSuffix[0])
3668                 return append_ldap_suffix(Globals.szLdapMachineSuffix);
3669
3670         return lp_string(Globals.szLdapSuffix);
3671 }
3672
3673 const char *lp_ldap_user_suffix(void)
3674 {
3675         if (Globals.szLdapUserSuffix[0])
3676                 return append_ldap_suffix(Globals.szLdapUserSuffix);
3677
3678         return lp_string(Globals.szLdapSuffix);
3679 }
3680
3681 const char *lp_ldap_group_suffix(void)
3682 {
3683         if (Globals.szLdapGroupSuffix[0])
3684                 return append_ldap_suffix(Globals.szLdapGroupSuffix);
3685
3686         return lp_string(Globals.szLdapSuffix);
3687 }
3688
3689 const char *lp_ldap_idmap_suffix(void)
3690 {
3691         if (Globals.szLdapIdmapSuffix[0])
3692                 return append_ldap_suffix(Globals.szLdapIdmapSuffix);
3693
3694         return lp_string(Globals.szLdapSuffix);
3695 }
3696
3697 /****************************************************************************
3698  set the value for a P_ENUM
3699  ***************************************************************************/
3700
3701 static void lp_set_enum_parm( struct parm_struct *parm, const char *pszParmValue,
3702                               int *ptr )
3703 {
3704         int i;
3705
3706         for (i = 0; parm->enum_list[i].name; i++) {
3707                 if ( strequal(pszParmValue, parm->enum_list[i].name)) {
3708                         *ptr = parm->enum_list[i].value;
3709                         break;
3710                 }
3711         }
3712 }
3713
3714 /***************************************************************************
3715 ***************************************************************************/
3716
3717 static BOOL handle_printing(int snum, const char *pszParmValue, char **ptr)
3718 {
3719         static int parm_num = -1;
3720         service *s;
3721
3722         if ( parm_num == -1 )
3723                 parm_num = map_parameter( "printing" );
3724
3725         lp_set_enum_parm( &parm_table[parm_num], pszParmValue, (int*)ptr );
3726
3727         if ( snum < 0 )
3728                 s = &sDefault;
3729         else
3730                 s = ServicePtrs[snum];
3731
3732         init_printer_values( s );
3733
3734         return True;
3735 }
3736
3737
3738 /***************************************************************************
3739  Initialise a copymap.
3740 ***************************************************************************/
3741
3742 static void init_copymap(service * pservice)
3743 {
3744         int i;
3745         SAFE_FREE(pservice->copymap);
3746         pservice->copymap = SMB_MALLOC_ARRAY(BOOL,NUMPARAMETERS);
3747         if (!pservice->copymap)
3748                 DEBUG(0,
3749                       ("Couldn't allocate copymap!! (size %d)\n",
3750                        (int)NUMPARAMETERS));
3751         else
3752                 for (i = 0; i < NUMPARAMETERS; i++)
3753                         pservice->copymap[i] = True;
3754 }
3755
3756 /***************************************************************************
3757  Return the local pointer to a parameter given the service number and the
3758  pointer into the default structure.
3759 ***************************************************************************/
3760
3761 void *lp_local_ptr(int snum, void *ptr)
3762 {
3763         return (void *)(((char *)ServicePtrs[snum]) + PTR_DIFF(ptr, &sDefault));
3764 }
3765
3766 /***************************************************************************
3767  Process a parameter for a particular service number. If snum < 0
3768  then assume we are in the globals.
3769 ***************************************************************************/
3770
3771 BOOL lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
3772 {
3773         int parmnum, i, slen;
3774         void *parm_ptr = NULL;  /* where we are going to store the result */
3775         void *def_ptr = NULL;
3776         pstring param_key;
3777         char *sep;
3778         param_opt_struct *paramo, *data;
3779         BOOL not_added;
3780
3781         parmnum = map_parameter(pszParmName);
3782
3783         if (parmnum < 0) {
3784                 if ((sep=strchr(pszParmName, ':')) != NULL) {
3785                         *sep = '\0';
3786                         ZERO_STRUCT(param_key);
3787                         pstr_sprintf(param_key, "%s:", pszParmName);
3788                         slen = strlen(param_key);
3789                         pstrcat(param_key, sep+1);
3790                         trim_char(param_key+slen, ' ', ' ');
3791                         not_added = True;
3792                         data = (snum < 0) ? Globals.param_opt :
3793                                 ServicePtrs[snum]->param_opt;
3794                         /* Traverse destination */
3795                         while (data) {
3796                                 /* If we already have same option, override it */
3797                                 if (strcmp(data->key, param_key) == 0) {
3798                                         string_free(&data->value);
3799                                         str_list_free(&data->list);
3800                                         data->value = SMB_STRDUP(pszParmValue);
3801                                         not_added = False;
3802                                         break;
3803                                 }
3804                                 data = data->next;
3805                         }
3806                         if (not_added) {
3807                                 paramo = SMB_XMALLOC_P(param_opt_struct);
3808                                 paramo->key = SMB_STRDUP(param_key);
3809                                 paramo->value = SMB_STRDUP(pszParmValue);
3810                                 paramo->list = NULL;
3811                                 if (snum < 0) {
3812                                         DLIST_ADD(Globals.param_opt, paramo);
3813                                 } else {
3814                                         DLIST_ADD(ServicePtrs[snum]->param_opt, paramo);
3815                                 }
3816                         }
3817
3818                         *sep = ':';
3819                         return (True);
3820                 }
3821                 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
3822                 return (True);
3823         }
3824
3825         if (parm_table[parmnum].flags & FLAG_DEPRECATED) {
3826                 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
3827                           pszParmName));
3828         }
3829
3830         def_ptr = parm_table[parmnum].ptr;
3831
3832         /* we might point at a service, the default service or a global */
3833         if (snum < 0) {
3834                 parm_ptr = def_ptr;
3835         } else {
3836                 if (parm_table[parmnum].p_class == P_GLOBAL) {
3837                         DEBUG(0,
3838                               ("Global parameter %s found in service section!\n",
3839                                pszParmName));
3840                         return (True);
3841                 }
3842                 parm_ptr =
3843                         ((char *)ServicePtrs[snum]) + PTR_DIFF(def_ptr,
3844                                                             &sDefault);
3845
3846                 if (!ServicePtrs[snum]->copymap)
3847                         init_copymap(ServicePtrs[snum]);
3848
3849                 /* this handles the aliases - set the copymap for other entries with
3850                    the same data pointer */
3851                 for (i = 0; parm_table[i].label; i++)
3852                         if (parm_table[i].ptr == parm_table[parmnum].ptr)
3853                                 ServicePtrs[snum]->copymap[i] = False;
3854         }
3855
3856         /* if it is a special case then go ahead */
3857         if (parm_table[parmnum].special) {
3858                 parm_table[parmnum].special(snum, pszParmValue, (char **)parm_ptr);
3859                 return (True);
3860         }
3861
3862         /* now switch on the type of variable it is */
3863         switch (parm_table[parmnum].type)
3864         {
3865                 case P_BOOL:
3866                         *(BOOL *)parm_ptr = lp_bool(pszParmValue);
3867                         break;
3868
3869                 case P_BOOLREV:
3870                         *(BOOL *)parm_ptr = !lp_bool(pszParmValue);
3871                         break;
3872
3873                 case P_INTEGER:
3874                         *(int *)parm_ptr = lp_int(pszParmValue);
3875                         break;
3876
3877                 case P_CHAR:
3878                         *(char *)parm_ptr = *pszParmValue;
3879                         break;
3880
3881                 case P_OCTAL:
3882                         i = sscanf(pszParmValue, "%o", (int *)parm_ptr);
3883                         if ( i != 1 ) {
3884                             DEBUG ( 0, ("Invalid octal number %s\n", pszParmName ));
3885                         }
3886                         break;
3887
3888                 case P_LIST:
3889                         str_list_free((char ***)parm_ptr);
3890                         *(char ***)parm_ptr = str_list_make(pszParmValue, NULL);
3891                         break;
3892
3893                 case P_STRING:
3894                         string_set((char **)parm_ptr, pszParmValue);
3895                         break;
3896
3897                 case P_USTRING:
3898                         string_set((char **)parm_ptr, pszParmValue);
3899                         strupper_m(*(char **)parm_ptr);
3900                         break;
3901
3902                 case P_GSTRING:
3903                         pstrcpy((char *)parm_ptr, pszParmValue);
3904                         break;
3905
3906                 case P_UGSTRING:
3907                         pstrcpy((char *)parm_ptr, pszParmValue);
3908                         strupper_m((char *)parm_ptr);
3909                         break;
3910
3911                 case P_ENUM:
3912                         lp_set_enum_parm( &parm_table[parmnum], pszParmValue, (int*)parm_ptr );
3913                         break;
3914                 case P_SEP:
3915                         break;
3916         }
3917
3918         return (True);
3919 }
3920
3921 /***************************************************************************
3922  Process a parameter.
3923 ***************************************************************************/
3924
3925 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue)
3926 {
3927         if (!bInGlobalSection && bGlobalOnly)
3928                 return (True);
3929
3930         DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
3931
3932         return (lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
3933                                 pszParmName, pszParmValue));
3934 }
3935
3936 /***************************************************************************
3937  Print a parameter of the specified type.
3938 ***************************************************************************/
3939
3940 static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
3941 {
3942         int i;
3943         switch (p->type)
3944         {
3945                 case P_ENUM:
3946                         for (i = 0; p->enum_list[i].name; i++) {
3947                                 if (*(int *)ptr == p->enum_list[i].value) {
3948                                         fprintf(f, "%s",
3949                                                 p->enum_list[i].name);
3950                                         break;
3951                                 }
3952                         }
3953                         break;
3954
3955                 case P_BOOL:
3956                         fprintf(f, "%s", BOOLSTR(*(BOOL *)ptr));
3957                         break;
3958
3959                 case P_BOOLREV:
3960                         fprintf(f, "%s", BOOLSTR(!*(BOOL *)ptr));
3961                         break;
3962
3963                 case P_INTEGER:
3964                         fprintf(f, "%d", *(int *)ptr);
3965                         break;
3966
3967                 case P_CHAR:
3968                         fprintf(f, "%c", *(char *)ptr);
3969                         break;
3970
3971                 case P_OCTAL:
3972                         fprintf(f, "%s", octal_string(*(int *)ptr));
3973                         break;
3974
3975                 case P_LIST:
3976                         if ((char ***)ptr && *(char ***)ptr) {
3977                                 char **list = *(char ***)ptr;
3978
3979                                 for (; *list; list++) {
3980                                         /* surround strings with whitespace in double quotes */
3981                                         if ( strchr_m( *list, ' ' ) )
3982                                                 fprintf(f, "\"%s\"%s", *list, ((*(list+1))?", ":""));
3983                                         else
3984                                                 fprintf(f, "%s%s", *list, ((*(list+1))?", ":""));
3985                                 }
3986                         }
3987                         break;
3988
3989                 case P_GSTRING:
3990                 case P_UGSTRING:
3991                         if ((char *)ptr) {
3992                                 fprintf(f, "%s", (char *)ptr);
3993                         }
3994                         break;
3995
3996                 case P_STRING:
3997                 case P_USTRING:
3998                         if (*(char **)ptr) {
3999                                 fprintf(f, "%s", *(char **)ptr);
4000                         }
4001                         break;
4002                 case P_SEP:
4003                         break;
4004         }
4005 }
4006
4007 /***************************************************************************
4008  Check if two parameters are equal.
4009 ***************************************************************************/
4010
4011 static BOOL equal_parameter(parm_type type, void *ptr1, void *ptr2)
4012 {
4013         switch (type) {
4014                 case P_BOOL:
4015                 case P_BOOLREV:
4016                         return (*((BOOL *)ptr1) == *((BOOL *)ptr2));
4017
4018                 case P_INTEGER:
4019                 case P_ENUM:
4020                 case P_OCTAL:
4021                         return (*((int *)ptr1) == *((int *)ptr2));
4022
4023                 case P_CHAR:
4024                         return (*((char *)ptr1) == *((char *)ptr2));
4025
4026                 case P_LIST:
4027                         return str_list_compare(*(char ***)ptr1, *(char ***)ptr2);
4028
4029                 case P_GSTRING:
4030                 case P_UGSTRING:
4031                 {
4032                         char *p1 = (char *)ptr1, *p2 = (char *)ptr2;
4033                         if (p1 && !*p1)
4034                                 p1 = NULL;
4035                         if (p2 && !*p2)
4036                                 p2 = NULL;
4037                         return (p1 == p2 || strequal(p1, p2));
4038                 }
4039                 case P_STRING:
4040                 case P_USTRING:
4041                 {
4042                         char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
4043                         if (p1 && !*p1)
4044                                 p1 = NULL;
4045                         if (p2 && !*p2)
4046                                 p2 = NULL;
4047                         return (p1 == p2 || strequal(p1, p2));
4048                 }
4049                 case P_SEP:
4050                         break;
4051         }
4052         return (False);
4053 }
4054
4055 /***************************************************************************
4056  Initialize any local varients in the sDefault table.
4057 ***************************************************************************/
4058
4059 void init_locals(void)
4060 {
4061         /* None as yet. */
4062 }
4063
4064 /***************************************************************************
4065  Process a new section (service). At this stage all sections are services.
4066  Later we'll have special sections that permit server parameters to be set.
4067  Returns True on success, False on failure.
4068 ***************************************************************************/
4069
4070 static BOOL do_section(const char *pszSectionName)
4071 {
4072         BOOL bRetval;
4073         BOOL isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
4074                          (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
4075         bRetval = False;
4076
4077         /* if we were in a global section then do the local inits */
4078         if (bInGlobalSection && !isglobal)
4079                 init_locals();
4080
4081         /* if we've just struck a global section, note the fact. */
4082         bInGlobalSection = isglobal;
4083
4084         /* check for multiple global sections */
4085         if (bInGlobalSection) {
4086                 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
4087                 return (True);
4088         }
4089
4090         if (!bInGlobalSection && bGlobalOnly)
4091                 return (True);
4092
4093         /* if we have a current service, tidy it up before moving on */
4094         bRetval = True;
4095
4096         if (iServiceIndex >= 0)
4097                 bRetval = service_ok(iServiceIndex);
4098
4099         /* if all is still well, move to the next record in the services array */
4100         if (bRetval) {
4101                 /* We put this here to avoid an odd message order if messages are */
4102                 /* issued by the post-processing of a previous section. */
4103                 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
4104
4105                 if ((iServiceIndex = add_a_service(&sDefault, pszSectionName))
4106                     < 0) {
4107                         DEBUG(0, ("Failed to add a new service\n"));
4108                         return (False);
4109                 }
4110         }
4111
4112         return (bRetval);
4113 }
4114
4115
4116 /***************************************************************************
4117  Determine if a partcular base parameter is currentl set to the default value.
4118 ***************************************************************************/
4119
4120 static BOOL is_default(int i)
4121 {
4122         if (!defaults_saved)
4123                 return False;
4124         switch (parm_table[i].type) {
4125                 case P_LIST:
4126                         return str_list_compare (parm_table[i].def.lvalue,
4127                                                 *(char ***)parm_table[i].ptr);
4128                 case P_STRING:
4129                 case P_USTRING:
4130                         return strequal(parm_table[i].def.svalue,
4131                                         *(char **)parm_table[i].ptr);
4132                 case P_GSTRING:
4133                 case P_UGSTRING:
4134                         return strequal(parm_table[i].def.svalue,
4135                                         (char *)parm_table[i].ptr);
4136                 case P_BOOL:
4137                 case P_BOOLREV:
4138                         return parm_table[i].def.bvalue ==
4139                                 *(BOOL *)parm_table[i].ptr;
4140                 case P_CHAR:
4141                         return parm_table[i].def.cvalue ==
4142                                 *(char *)parm_table[i].ptr;
4143                 case P_INTEGER:
4144                 case P_OCTAL:
4145                 case P_ENUM:
4146                         return parm_table[i].def.ivalue ==
4147                                 *(int *)parm_table[i].ptr;
4148                 case P_SEP:
4149                         break;
4150         }
4151         return False;
4152 }
4153
4154 /***************************************************************************
4155 Display the contents of the global structure.
4156 ***************************************************************************/
4157
4158 static void dump_globals(FILE *f)
4159 {
4160         int i;
4161         param_opt_struct *data;
4162
4163         fprintf(f, "[global]\n");
4164
4165         for (i = 0; parm_table[i].label; i++)
4166                 if (parm_table[i].p_class == P_GLOBAL &&
4167                     parm_table[i].ptr &&
4168                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
4169                         if (defaults_saved && is_default(i))
4170                                 continue;
4171                         fprintf(f, "\t%s = ", parm_table[i].label);
4172                         print_parameter(&parm_table[i], parm_table[i].ptr, f);
4173                         fprintf(f, "\n");
4174         }
4175         if (Globals.param_opt != NULL) {
4176                 data = Globals.param_opt;
4177                 while(data) {
4178                         fprintf(f, "\t%s = %s\n", data->key, data->value);
4179                         data = data->next;
4180                 }
4181         }
4182
4183 }
4184
4185 /***************************************************************************
4186  Return True if a local parameter is currently set to the global default.
4187 ***************************************************************************/
4188
4189 BOOL lp_is_default(int snum, struct parm_struct *parm)
4190 {
4191         int pdiff = PTR_DIFF(parm->ptr, &sDefault);
4192
4193         return equal_parameter(parm->type,
4194                                ((char *)ServicePtrs[snum]) + pdiff,
4195                                ((char *)&sDefault) + pdiff);
4196 }
4197
4198 /***************************************************************************
4199  Display the contents of a single services record.
4200 ***************************************************************************/
4201
4202 static void dump_a_service(service * pService, FILE * f)
4203 {
4204         int i;
4205         param_opt_struct *data;
4206
4207         if (pService != &sDefault)
4208                 fprintf(f, "[%s]\n", pService->szService);
4209
4210         for (i = 0; parm_table[i].label; i++) {
4211
4212                 if (parm_table[i].p_class == P_LOCAL &&
4213                     parm_table[i].ptr &&
4214                     (*parm_table[i].label != '-') &&
4215                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
4216                 {
4217
4218                         int pdiff = PTR_DIFF(parm_table[i].ptr, &sDefault);
4219
4220                         if (pService == &sDefault) {
4221                                 if (defaults_saved && is_default(i))
4222                                         continue;
4223                         } else {
4224                                 if (equal_parameter(parm_table[i].type,
4225                                                     ((char *)pService) +
4226                                                     pdiff,
4227                                                     ((char *)&sDefault) +
4228                                                     pdiff))
4229                                         continue;
4230                         }
4231
4232                         fprintf(f, "\t%s = ", parm_table[i].label);
4233                         print_parameter(&parm_table[i],
4234                                         ((char *)pService) + pdiff, f);
4235                         fprintf(f, "\n");
4236                 }
4237         }
4238
4239                 if (pService->param_opt != NULL) {
4240                         data = pService->param_opt;
4241                         while(data) {
4242                                 fprintf(f, "\t%s = %s\n", data->key, data->value);
4243                                 data = data->next;
4244                         }
4245                 }
4246 }
4247
4248 /***************************************************************************
4249  Display the contents of a parameter of a single services record.
4250 ***************************************************************************/
4251
4252 BOOL dump_a_parameter(int snum, char *parm_name, FILE * f, BOOL isGlobal)
4253 {
4254         int i;
4255         BOOL result = False;
4256         parm_class p_class;
4257         unsigned flag = 0;
4258         fstring local_parm_name;
4259         char *parm_opt;
4260         const char *parm_opt_value;
4261
4262         /* check for parametrical option */
4263         fstrcpy( local_parm_name, parm_name);
4264         parm_opt = strchr( local_parm_name, ':');
4265
4266         if (parm_opt) {
4267                 *parm_opt = '\0';
4268                 parm_opt++;
4269                 if (strlen(parm_opt)) {
4270                         parm_opt_value = lp_parm_const_string( snum,
4271                                 local_parm_name, parm_opt, NULL);
4272                         if (parm_opt_value) {
4273                                 printf( "%s\n", parm_opt_value);
4274                                 result = True;
4275                         }
4276                 }
4277                 return result;
4278         }
4279
4280         /* check for a key and print the value */
4281         if (isGlobal) {
4282                 p_class = P_GLOBAL;
4283                 flag = FLAG_GLOBAL;
4284         } else
4285                 p_class = P_LOCAL;
4286
4287         for (i = 0; parm_table[i].label; i++) {
4288                 if (strwicmp(parm_table[i].label, parm_name) == 0 &&
4289                     (parm_table[i].p_class == p_class || parm_table[i].flags & flag) &&
4290                     parm_table[i].ptr &&
4291                     (*parm_table[i].label != '-') &&
4292                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
4293                 {
4294                         void *ptr;
4295
4296                         if (isGlobal) {
4297                                 ptr = parm_table[i].ptr;
4298                         } else {
4299                                 service * pService = ServicePtrs[snum];
4300                                 ptr = ((char *)pService) +
4301                                         PTR_DIFF(parm_table[i].ptr, &sDefault);
4302                         }
4303
4304                         print_parameter(&parm_table[i],
4305                                         ptr, f);
4306                         fprintf(f, "\n");
4307                         result = True;
4308                         break;
4309                 }
4310         }
4311
4312         return result;
4313 }
4314
4315 /***************************************************************************
4316  Return info about the next parameter in a service.
4317  snum==GLOBAL_SECTION_SNUM gives the globals.
4318  Return NULL when out of parameters.
4319 ***************************************************************************/
4320
4321 struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters)
4322 {
4323         if (snum < 0) {
4324                 /* do the globals */
4325                 for (; parm_table[*i].label; (*i)++) {
4326                         if (parm_table[*i].p_class == P_SEPARATOR)
4327                                 return &parm_table[(*i)++];
4328
4329                         if (!parm_table[*i].ptr
4330                             || (*parm_table[*i].label == '-'))
4331                                 continue;
4332
4333                         if ((*i) > 0
4334                             && (parm_table[*i].ptr ==
4335                                 parm_table[(*i) - 1].ptr))
4336                                 continue;
4337
4338                         if (is_default(*i) && !allparameters)
4339                                 continue;
4340
4341                         return &parm_table[(*i)++];
4342                 }
4343         } else {
4344                 service *pService = ServicePtrs[snum];
4345
4346                 for (; parm_table[*i].label; (*i)++) {
4347                         if (parm_table[*i].p_class == P_SEPARATOR)
4348                                 return &parm_table[(*i)++];
4349
4350                         if (parm_table[*i].p_class == P_LOCAL &&
4351                             parm_table[*i].ptr &&
4352                             (*parm_table[*i].label != '-') &&
4353                             ((*i) == 0 ||
4354                              (parm_table[*i].ptr !=
4355                               parm_table[(*i) - 1].ptr)))
4356                         {
4357                                 int pdiff =
4358                                         PTR_DIFF(parm_table[*i].ptr,
4359                                                  &sDefault);
4360
4361                                 if (allparameters ||
4362                                     !equal_parameter(parm_table[*i].type,
4363                                                      ((char *)pService) +
4364                                                      pdiff,
4365                                                      ((char *)&sDefault) +
4366                                                      pdiff))
4367                                 {
4368                                         return &parm_table[(*i)++];
4369                                 }
4370                         }
4371                 }
4372         }
4373
4374         return NULL;
4375 }
4376
4377
4378 #if 0
4379 /***************************************************************************
4380  Display the contents of a single copy structure.
4381 ***************************************************************************/
4382 static void dump_copy_map(BOOL *pcopymap)
4383 {
4384         int i;
4385         if (!pcopymap)
4386                 return;
4387
4388         printf("\n\tNon-Copied parameters:\n");
4389
4390         for (i = 0; parm_table[i].label; i++)
4391                 if (parm_table[i].p_class == P_LOCAL &&
4392                     parm_table[i].ptr && !pcopymap[i] &&
4393                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
4394                 {
4395                         printf("\t\t%s\n", parm_table[i].label);
4396                 }
4397 }
4398 #endif
4399
4400 /***************************************************************************
4401  Return TRUE if the passed service number is within range.
4402 ***************************************************************************/
4403
4404 BOOL lp_snum_ok(int iService)
4405 {
4406         return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
4407 }
4408
4409 /***************************************************************************
4410  Auto-load some home services.
4411 ***************************************************************************/
4412
4413 static void lp_add_auto_services(char *str)
4414 {
4415         char *s;
4416         char *p;
4417         int homes;
4418
4419         if (!str)
4420                 return;
4421
4422         s = SMB_STRDUP(str);
4423         if (!s)
4424                 return;
4425
4426         homes = lp_servicenumber(HOMES_NAME);
4427
4428         for (p = strtok(s, LIST_SEP); p; p = strtok(NULL, LIST_SEP)) {
4429                 char *home = get_user_home_dir(p);
4430
4431                 if (lp_servicenumber(p) >= 0)
4432                         continue;
4433
4434                 if (home && homes >= 0)
4435                         lp_add_home(p, homes, p, home);
4436         }
4437         SAFE_FREE(s);
4438 }
4439
4440 /***************************************************************************
4441  Auto-load one printer.
4442 ***************************************************************************/
4443
4444 void lp_add_one_printer(char *name, char *comment)
4445 {
4446         int printers = lp_servicenumber(PRINTERS_NAME);
4447         int i;
4448
4449         if (lp_servicenumber(name) < 0) {
4450                 lp_add_printer(name, printers);
4451                 if ((i = lp_servicenumber(name)) >= 0) {
4452                         string_set(&ServicePtrs[i]->comment, comment);
4453                         ServicePtrs[i]->autoloaded = True;
4454                 }
4455         }
4456 }
4457
4458 /***************************************************************************
4459  Have we loaded a services file yet?
4460 ***************************************************************************/
4461
4462 BOOL lp_loaded(void)
4463 {
4464         return (bLoaded);
4465 }
4466
4467 /***************************************************************************
4468  Unload unused services.
4469 ***************************************************************************/
4470
4471 void lp_killunused(BOOL (*snumused) (int))
4472 {
4473         int i;
4474         for (i = 0; i < iNumServices; i++) {
4475                 if (!VALID(i))
4476                         continue;
4477
4478                 /* don't kill autoloaded or usershare services */
4479                 if ( ServicePtrs[i]->autoloaded ||
4480                                 ServicePtrs[i]->usershare == USERSHARE_VALID) {
4481                         continue;
4482                 }
4483
4484                 if (!snumused || !snumused(i)) {
4485                         free_service_byindex(i);
4486                 }
4487         }
4488 }
4489
4490 /***************************************************************************
4491  Unload a service.
4492 ***************************************************************************/
4493
4494 void lp_killservice(int iServiceIn)
4495 {
4496         if (VALID(iServiceIn)) {
4497                 free_service_byindex(iServiceIn);
4498         }
4499 }
4500
4501 /***************************************************************************
4502  Save the curent values of all global and sDefault parameters into the
4503  defaults union. This allows swat and testparm to show only the
4504  changed (ie. non-default) parameters.
4505 ***************************************************************************/
4506
4507 static void lp_save_defaults(void)
4508 {
4509         int i;
4510         for (i = 0; parm_table[i].label; i++) {
4511                 if (i > 0 && parm_table[i].ptr == parm_table[i - 1].ptr)
4512                         continue;
4513                 switch (parm_table[i].type) {
4514                         case P_LIST:
4515                                 str_list_copy(&(parm_table[i].def.lvalue),
4516                                             *(const char ***)parm_table[i].ptr);
4517                                 break;
4518                         case P_STRING:
4519                         case P_USTRING:
4520                                 if (parm_table[i].ptr) {
4521                                         parm_table[i].def.svalue = SMB_STRDUP(*(char **)parm_table[i].ptr);
4522                                 } else {
4523                                         parm_table[i].def.svalue = NULL;
4524                                 }
4525                                 break;
4526                         case P_GSTRING:
4527                         case P_UGSTRING:
4528                                 if (parm_table[i].ptr) {
4529                                         parm_table[i].def.svalue = SMB_STRDUP((char *)parm_table[i].ptr);
4530                                 } else {
4531                                         parm_table[i].def.svalue = NULL;
4532                                 }
4533                                 break;
4534                         case P_BOOL:
4535                         case P_BOOLREV:
4536                                 parm_table[i].def.bvalue =
4537                                         *(BOOL *)parm_table[i].ptr;
4538                                 break;
4539                         case P_CHAR:
4540                                 parm_table[i].def.cvalue =
4541                                         *(char *)parm_table[i].ptr;
4542                                 break;
4543                         case P_INTEGER:
4544                         case P_OCTAL:
4545                         case P_ENUM:
4546                                 parm_table[i].def.ivalue =
4547                                         *(int *)parm_table[i].ptr;
4548                                 break;
4549                         case P_SEP:
4550                                 break;
4551                 }
4552         }
4553         defaults_saved = True;
4554 }
4555
4556 /*******************************************************************
4557  Set the server type we will announce as via nmbd.
4558 ********************************************************************/
4559
4560 static const struct srv_role_tab {
4561         uint32 role;
4562         const char *role_str;
4563 } srv_role_tab [] = {
4564         { ROLE_STANDALONE, "ROLE_STANDALONE" },
4565         { ROLE_DOMAIN_MEMBER, "ROLE_DOMAIN_MEMBER" },
4566         { ROLE_DOMAIN_BDC, "ROLE_DOMAIN_BDC" },
4567         { ROLE_DOMAIN_PDC, "ROLE_DOMAIN_PDC" },
4568         { 0, NULL }
4569 };
4570
4571 const char* server_role_str(uint32 role)
4572 {
4573         int i = 0;
4574         for (i=0; srv_role_tab[i].role_str; i++) {
4575                 if (role == srv_role_tab[i].role) {
4576                         return srv_role_tab[i].role_str;
4577                 }
4578         }
4579         return NULL;
4580 }
4581
4582 static void set_server_role(void)
4583 {
4584         server_role = ROLE_STANDALONE;
4585
4586         switch (lp_security()) {
4587                 case SEC_SHARE:
4588                         if (lp_domain_logons())
4589                                 DEBUG(0, ("Server's Role (logon server) conflicts with share-level security\n"));
4590                         break;
4591                 case SEC_SERVER:
4592                         if (lp_domain_logons())
4593                                 DEBUG(0, ("Server's Role (logon server) conflicts with server-level security\n"));
4594                         /* this used to be considered ROLE_DOMAIN_MEMBER but that's just wrong */
4595                         server_role = ROLE_STANDALONE;
4596                         break;
4597                 case SEC_DOMAIN:
4598                         if (lp_domain_logons()) {
4599                                 DEBUG(1, ("Server's Role (logon server) NOT ADVISED with domain-level security\n"));
4600                                 server_role = ROLE_DOMAIN_BDC;
4601                                 break;
4602                         }
4603                         server_role = ROLE_DOMAIN_MEMBER;
4604                         break;
4605                 case SEC_ADS:
4606                         if (lp_domain_logons()) {
4607                                 server_role = ROLE_DOMAIN_PDC;
4608                                 break;
4609                         }
4610                         server_role = ROLE_DOMAIN_MEMBER;
4611                         break;
4612                 case SEC_USER:
4613                         if (lp_domain_logons()) {
4614
4615                                 if (Globals.bDomainMaster) /* auto or yes */
4616                                         server_role = ROLE_DOMAIN_PDC;
4617                                 else
4618                                         server_role = ROLE_DOMAIN_BDC;
4619                         }
4620                         break;
4621                 default:
4622                         DEBUG(0, ("Server's Role undefined due to unknown security mode\n"));
4623                         break;
4624         }
4625
4626         DEBUG(10, ("set_server_role: role = %s\n", server_role_str(server_role)));
4627 }
4628
4629 /***********************************************************
4630  If we should send plaintext/LANMAN passwords in the clinet
4631 ************************************************************/
4632
4633 static void set_allowed_client_auth(void)
4634 {
4635         if (Globals.bClientNTLMv2Auth) {
4636                 Globals.bClientLanManAuth = False;
4637         }
4638         if (!Globals.bClientLanManAuth) {
4639                 Globals.bClientPlaintextAuth = False;
4640         }
4641 }
4642
4643 /***************************************************************************
4644  JRA.
4645  The following code allows smbd to read a user defined share file.
4646  Yes, this is my intent. Yes, I'm comfortable with that...
4647
4648  THE FOLLOWING IS SECURITY CRITICAL CODE.
4649
4650  It washes your clothes, it cleans your house, it guards you while you sleep...
4651  Do not f%^k with it....
4652 ***************************************************************************/
4653
4654 #define MAX_USERSHARE_FILE_SIZE (10*1024)
4655
4656 /***************************************************************************
4657  Check allowed stat state of a usershare file.
4658  Ensure we print out who is dicking with us so the admin can
4659  get their sorry ass fired.
4660 ***************************************************************************/
4661
4662 static BOOL check_usershare_stat(const char *fname, SMB_STRUCT_STAT *psbuf)
4663 {
4664         if (!S_ISREG(psbuf->st_mode)) {
4665                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
4666                         "not a regular file\n",
4667                         fname, (unsigned int)psbuf->st_uid ));
4668                 return False;
4669         }
4670
4671         /* Ensure this doesn't have the other write bit set. */
4672         if (psbuf->st_mode & S_IWOTH) {
4673                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
4674                         "public write. Refusing to allow as a usershare file.\n",
4675                         fname, (unsigned int)psbuf->st_uid ));
4676                 return False;
4677         }
4678
4679         /* Should be 10k or less. */
4680         if (psbuf->st_size > MAX_USERSHARE_FILE_SIZE) {
4681                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
4682                         "too large (%u) to be a user share file.\n",
4683                         fname, (unsigned int)psbuf->st_uid,
4684                         (unsigned int)psbuf->st_size ));
4685                 return False;
4686         }
4687
4688         return True;
4689 }
4690
4691 /***************************************************************************
4692  Parse the contents of a usershare file.
4693 ***************************************************************************/
4694
4695 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
4696                         SMB_STRUCT_STAT *psbuf,
4697                         const char *servicename,
4698                         int snum,
4699                         char **lines,
4700                         int numlines,
4701                         pstring sharepath,
4702                         pstring comment,
4703                         SEC_DESC **ppsd,
4704                         BOOL *pallow_guest)
4705 {
4706         const char **prefixallowlist = lp_usershare_prefix_allow_list();
4707         const char **prefixdenylist = lp_usershare_prefix_deny_list();
4708         int us_vers;
4709         SMB_STRUCT_DIR *dp;
4710         SMB_STRUCT_STAT sbuf;
4711
4712         *pallow_guest = False;
4713
4714         if (numlines < 4) {
4715                 return USERSHARE_MALFORMED_FILE;
4716         }
4717
4718         if (strcmp(lines[0], "#VERSION 1") == 0) {
4719                 us_vers = 1;
4720         } else if (strcmp(lines[0], "#VERSION 2") == 0) {
4721                 us_vers = 2;
4722                 if (numlines < 5) {
4723                         return USERSHARE_MALFORMED_FILE;
4724                 }
4725         } else {
4726                 return USERSHARE_BAD_VERSION;
4727         }
4728
4729         if (strncmp(lines[1], "path=", 5) != 0) {
4730                 return USERSHARE_MALFORMED_PATH;
4731         }
4732
4733         pstrcpy(sharepath, &lines[1][5]);
4734         trim_string(sharepath, " ", " ");
4735
4736         if (strncmp(lines[2], "comment=", 8) != 0) {
4737                 return USERSHARE_MALFORMED_COMMENT_DEF;
4738         }
4739
4740         pstrcpy(comment, &lines[2][8]);
4741         trim_string(comment, " ", " ");
4742         trim_char(comment, '"', '"');
4743
4744         if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
4745                 return USERSHARE_MALFORMED_ACL_DEF;
4746         }
4747
4748         if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
4749                 return USERSHARE_ACL_ERR;
4750         }
4751
4752         if (us_vers == 2) {
4753                 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
4754                         return USERSHARE_MALFORMED_ACL_DEF;
4755                 }
4756                 if (lines[4][9] == 'y') {
4757                         *pallow_guest = True;
4758                 }
4759         }
4760
4761         if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->szPath) == 0)) {
4762                 /* Path didn't change, no checks needed. */
4763                 return USERSHARE_OK;
4764         }
4765
4766         /* The path *must* be absolute. */
4767         if (sharepath[0] != '/') {
4768                 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
4769                         servicename, sharepath));
4770                 return USERSHARE_PATH_NOT_ABSOLUTE;
4771         }
4772
4773         /* If there is a usershare prefix deny list ensure one of these paths
4774            doesn't match the start of the user given path. */
4775         if (prefixdenylist) {
4776                 int i;
4777                 for ( i=0; prefixdenylist[i]; i++ ) {
4778                         DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
4779                                 servicename, i, prefixdenylist[i], sharepath ));
4780                         if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
4781                                 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
4782                                         "usershare prefix deny list entries.\n",
4783                                         servicename, sharepath));
4784                                 return USERSHARE_PATH_IS_DENIED;
4785                         }
4786                 }
4787         }
4788
4789         /* If there is a usershare prefix allow list ensure one of these paths
4790            does match the start of the user given path. */
4791
4792         if (prefixallowlist) {
4793                 int i;
4794                 for ( i=0; prefixallowlist[i]; i++ ) {
4795                         DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
4796                                 servicename, i, prefixallowlist[i], sharepath ));
4797                         if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
4798                                 break;
4799                         }
4800                 }
4801                 if (prefixallowlist[i] == NULL) {
4802                         DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
4803                                 "usershare prefix allow list entries.\n",
4804                                 servicename, sharepath));
4805                         return USERSHARE_PATH_NOT_ALLOWED;
4806                 }
4807         }
4808
4809         /* Ensure this is pointing to a directory. */
4810         dp = sys_opendir(sharepath);
4811
4812         if (!dp) {
4813                 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
4814                         servicename, sharepath));
4815                 return USERSHARE_PATH_NOT_DIRECTORY;
4816         }
4817
4818         /* Ensure the owner of the usershare file has permission to share
4819            this directory. */
4820
4821         if (sys_stat(sharepath, &sbuf) == -1) {
4822                 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
4823                         servicename, sharepath, strerror(errno) ));
4824                 sys_closedir(dp);
4825                 return USERSHARE_POSIX_ERR;
4826         }
4827
4828         sys_closedir(dp);
4829
4830         if (!S_ISDIR(sbuf.st_mode)) {
4831                 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
4832                         servicename, sharepath ));
4833                 return USERSHARE_PATH_NOT_DIRECTORY;
4834         }
4835
4836         /* Check if sharing is restricted to owner-only. */
4837         /* psbuf is the stat of the usershare definition file,
4838            sbuf is the stat of the target directory to be shared. */
4839
4840         if (lp_usershare_owner_only()) {
4841                 /* root can share anything. */
4842                 if ((psbuf->st_uid != 0) && (sbuf.st_uid != psbuf->st_uid)) {
4843                         return USERSHARE_PATH_NOT_ALLOWED;
4844                 }
4845         }
4846
4847         return USERSHARE_OK;
4848 }
4849
4850 /***************************************************************************
4851  Deal with a usershare file.
4852  Returns:
4853         >= 0 - snum
4854         -1 - Bad name, invalid contents.
4855            - service name already existed and not a usershare, problem
4856             with permissions to share directory etc.
4857 ***************************************************************************/
4858
4859 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
4860 {
4861         SMB_STRUCT_STAT sbuf;
4862         SMB_STRUCT_STAT lsbuf;
4863         pstring fname;
4864         pstring sharepath;
4865         pstring comment;
4866         fstring service_name;
4867         char **lines = NULL;
4868         int numlines = 0;
4869         int fd = -1;
4870         int iService = -1;
4871         TALLOC_CTX *ctx = NULL;
4872         SEC_DESC *psd = NULL;
4873         BOOL guest_ok = False;
4874
4875         /* Ensure share name doesn't contain invalid characters. */
4876         if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
4877                 DEBUG(0,("process_usershare_file: share name %s contains "
4878                         "invalid characters (any of %s)\n",
4879                         file_name, INVALID_SHARENAME_CHARS ));
4880                 return -1;
4881         }
4882
4883         fstrcpy(service_name, file_name);
4884
4885         pstrcpy(fname, dir_name);
4886         pstrcat(fname, "/");
4887         pstrcat(fname, file_name);
4888
4889         /* Minimize the race condition by doing an lstat before we
4890            open and fstat. Ensure this isn't a symlink link. */
4891
4892         if (sys_lstat(fname, &lsbuf) != 0) {
4893                 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
4894                         fname, strerror(errno) ));
4895                 return -1;
4896         }
4897
4898         /* This must be a regular file, not a symlink, directory or
4899            other strange filetype. */
4900         if (!check_usershare_stat(fname, &lsbuf)) {
4901                 return -1;
4902         }
4903
4904         /* See if there is already a servicenum for this name. */
4905         /* tdb_fetch_int32 returns -1 if not found. */
4906         iService = (int)tdb_fetch_int32(ServiceHash, canonicalize_servicename(service_name) );
4907
4908         if (iService != -1 && ServicePtrs[iService]->usershare_last_mod == lsbuf.st_mtime) {
4909                 /* Nothing changed - Mark valid and return. */
4910                 DEBUG(10,("process_usershare_file: service %s not changed.\n",
4911                         service_name ));
4912                 ServicePtrs[iService]->usershare = USERSHARE_VALID;
4913                 return iService;
4914         }
4915
4916         /* Try and open the file read only - no symlinks allowed. */
4917 #ifdef O_NOFOLLOW
4918         fd = sys_open(fname, O_RDONLY|O_NOFOLLOW, 0);
4919 #else
4920         fd = sys_open(fname, O_RDONLY, 0);
4921 #endif
4922
4923         if (fd == -1) {
4924                 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
4925                         fname, strerror(errno) ));
4926                 return -1;
4927         }
4928
4929         /* Now fstat to be *SURE* it's a regular file. */
4930         if (sys_fstat(fd, &sbuf) != 0) {
4931                 close(fd);
4932                 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
4933                         fname, strerror(errno) ));
4934                 return -1;
4935         }
4936
4937         /* Is it the same dev/inode as was lstated ? */
4938         if (lsbuf.st_dev != sbuf.st_dev || lsbuf.st_ino != sbuf.st_ino) {
4939                 close(fd);
4940                 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
4941                         "Symlink spoofing going on ?\n", fname ));
4942                 return -1;
4943         }
4944
4945         /* This must be a regular file, not a symlink, directory or
4946            other strange filetype. */
4947         if (!check_usershare_stat(fname, &sbuf)) {
4948                 return -1;
4949         }
4950
4951         lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE);
4952
4953         close(fd);
4954         if (lines == NULL) {
4955                 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
4956                         fname, (unsigned int)sbuf.st_uid ));
4957                 return -1;
4958         }
4959
4960         /* Should we allow printers to be shared... ? */
4961         ctx = talloc_init("usershare_sd_xctx");
4962         if (!ctx) {
4963                 file_lines_free(lines);
4964                 return 1;
4965         }
4966
4967         if (parse_usershare_file(ctx, &sbuf, service_name,
4968                         iService, lines, numlines, sharepath,
4969                         comment, &psd, &guest_ok) != USERSHARE_OK) {
4970                 talloc_destroy(ctx);
4971                 file_lines_free(lines);
4972                 return -1;
4973         }
4974
4975         file_lines_free(lines);
4976
4977         /* Everything ok - add the service possibly using a template. */
4978         if (iService < 0) {
4979                 const service *sp = &sDefault;
4980                 if (snum_template != -1) {
4981                         sp = ServicePtrs[snum_template];
4982                 }
4983
4984                 if ((iService = add_a_service(sp, service_name)) < 0) {
4985                         DEBUG(0, ("process_usershare_file: Failed to add "
4986                                 "new service %s\n", service_name));
4987                         talloc_destroy(ctx);
4988                         return -1;
4989                 }
4990
4991                 /* Read only is controlled by usershare ACL below. */
4992                 ServicePtrs[iService]->bRead_only = False;
4993         }
4994
4995         /* Write the ACL of the new/modified share. */
4996         if (!set_share_security(service_name, psd)) {
4997                  DEBUG(0, ("process_usershare_file: Failed to set share "
4998                         "security for user share %s\n",
4999                         service_name ));
5000                 lp_remove_service(iService);
5001                 talloc_destroy(ctx);
5002                 return -1;
5003         }
5004
5005         talloc_destroy(ctx);
5006
5007         /* If from a template it may be marked invalid. */
5008         ServicePtrs[iService]->valid = True;
5009
5010         /* Set the service as a valid usershare. */
5011         ServicePtrs[iService]->usershare = USERSHARE_VALID;
5012
5013         /* Set guest access. */
5014         if (lp_usershare_allow_guests()) {
5015                 ServicePtrs[iService]->bGuest_ok = guest_ok;
5016         }
5017
5018         /* And note when it was loaded. */
5019         ServicePtrs[iService]->usershare_last_mod = sbuf.st_mtime;
5020         string_set(&ServicePtrs[iService]->szPath, sharepath);
5021         string_set(&ServicePtrs[iService]->comment, comment);
5022
5023         return iService;
5024 }
5025
5026 /***************************************************************************
5027  Checks if a usershare entry has been modified since last load.
5028 ***************************************************************************/
5029
5030 static BOOL usershare_exists(int iService, time_t *last_mod)
5031 {
5032         SMB_STRUCT_STAT lsbuf;
5033         const char *usersharepath = Globals.szUsersharePath;
5034         pstring fname;
5035
5036         pstrcpy(fname, usersharepath);
5037         pstrcat(fname, "/");
5038         pstrcat(fname, ServicePtrs[iService]->szService);
5039
5040         if (sys_lstat(fname, &lsbuf) != 0) {
5041                 return False;
5042         }
5043
5044         if (!S_ISREG(lsbuf.st_mode)) {
5045                 return False;
5046         }
5047
5048         *last_mod = lsbuf.st_mtime;
5049         return True;
5050 }
5051
5052 /***************************************************************************
5053  Load a usershare service by name. Returns a valid servicenumber or -1.
5054 ***************************************************************************/
5055
5056 int load_usershare_service(const char *servicename)
5057 {
5058         SMB_STRUCT_STAT sbuf;
5059         const char *usersharepath = Globals.szUsersharePath;
5060         int max_user_shares = Globals.iUsershareMaxShares;
5061         int snum_template = -1;
5062
5063         if (*usersharepath == 0 ||  max_user_shares == 0) {
5064                 return -1;
5065         }
5066
5067         if (sys_stat(usersharepath, &sbuf) != 0) {
5068                 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
5069                         usersharepath, strerror(errno) ));
5070                 return -1;
5071         }
5072
5073         if (!S_ISDIR(sbuf.st_mode)) {
5074                 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
5075                         usersharepath ));
5076                 return -1;
5077         }
5078
5079         /*
5080          * This directory must be owned by root, and have the 't' bit set.
5081          * It also must not be writable by "other".
5082          */
5083
5084 #ifdef S_ISVTX
5085         if (sbuf.st_uid != 0 || !(sbuf.st_mode & S_ISVTX) || (sbuf.st_mode & S_IWOTH)) {
5086 #else
5087         if (sbuf.st_uid != 0 || (sbuf.st_mode & S_IWOTH)) {
5088 #endif
5089                 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
5090                         "or does not have the sticky bit 't' set or is writable by anyone.\n",
5091                         usersharepath ));
5092                 return -1;
5093         }
5094
5095         /* Ensure the template share exists if it's set. */
5096         if (Globals.szUsershareTemplateShare[0]) {
5097                 /* We can't use lp_servicenumber here as we are recommending that
5098                    template shares have -valid=False set. */
5099                 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
5100                         if (ServicePtrs[snum_template]->szService &&
5101                                         strequal(ServicePtrs[snum_template]->szService,
5102                                                 Globals.szUsershareTemplateShare)) {
5103                                 break;
5104                         }
5105                 }
5106
5107                 if (snum_template == -1) {
5108                         DEBUG(0,("load_usershare_service: usershare template share %s "
5109                                 "does not exist.\n",
5110                                 Globals.szUsershareTemplateShare ));
5111                         return -1;
5112                 }
5113         }
5114
5115         return process_usershare_file(usersharepath, servicename, snum_template);
5116 }
5117
5118 /***************************************************************************
5119  Load all user defined shares from the user share directory.
5120  We only do this if we're enumerating the share list.
5121  This is the function that can delete usershares that have
5122  been removed.
5123 ***************************************************************************/
5124
5125 int load_usershare_shares(void)
5126 {
5127         SMB_STRUCT_DIR *dp;
5128         SMB_STRUCT_STAT sbuf;
5129         SMB_STRUCT_DIRENT *de;
5130         int num_usershares = 0;
5131         int max_user_shares = Globals.iUsershareMaxShares;
5132         unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
5133         unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
5134         unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
5135         int iService;
5136         int snum_template = -1;
5137         const char *usersharepath = Globals.szUsersharePath;
5138         int ret = lp_numservices();
5139
5140         if (max_user_shares == 0 || *usersharepath == '\0') {
5141                 return lp_numservices();
5142         }
5143
5144         if (sys_stat(usersharepath, &sbuf) != 0) {
5145                 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
5146                         usersharepath, strerror(errno) ));
5147                 return ret;
5148         }
5149
5150         /*
5151          * This directory must be owned by root, and have the 't' bit set.
5152          * It also must not be writable by "other".
5153          */
5154
5155 #ifdef S_ISVTX
5156         if (sbuf.st_uid != 0 || !(sbuf.st_mode & S_ISVTX) || (sbuf.st_mode & S_IWOTH)) {
5157 #else
5158         if (sbuf.st_uid != 0 || (sbuf.st_mode & S_IWOTH)) {
5159 #endif
5160                 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
5161                         "or does not have the sticky bit 't' set or is writable by anyone.\n",
5162                         usersharepath ));
5163                 return ret;
5164         }
5165
5166         /* Ensure the template share exists if it's set. */
5167         if (Globals.szUsershareTemplateShare[0]) {
5168                 /* We can't use lp_servicenumber here as we are recommending that
5169                    template shares have -valid=False set. */
5170                 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
5171                         if (ServicePtrs[snum_template]->szService &&
5172                                         strequal(ServicePtrs[snum_template]->szService,
5173                                                 Globals.szUsershareTemplateShare)) {
5174                                 break;
5175                         }
5176                 }
5177
5178                 if (snum_template == -1) {
5179                         DEBUG(0,("load_usershare_shares: usershare template share %s "
5180                                 "does not exist.\n",
5181                                 Globals.szUsershareTemplateShare ));
5182                         return ret;
5183                 }
5184         }
5185
5186         /* Mark all existing usershares as pending delete. */
5187         for (iService = iNumServices - 1; iService >= 0; iService--) {
5188                 if (VALID(iService) && ServicePtrs[iService]->usershare) {
5189                         ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
5190                 }
5191         }
5192
5193         dp = sys_opendir(usersharepath);
5194         if (!dp) {
5195                 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
5196                         usersharepath, strerror(errno) ));
5197                 return ret;
5198         }
5199
5200         for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
5201                         (de = sys_readdir(dp));
5202                         num_dir_entries++ ) {
5203                 int r;
5204                 const char *n = de->d_name;
5205
5206                 /* Ignore . and .. */
5207                 if (*n == '.') {
5208                         if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
5209                                 continue;
5210                         }
5211                 }
5212
5213                 if (n[0] == ':') {
5214                         /* Temporary file used when creating a share. */
5215                         num_tmp_dir_entries++;
5216                 }
5217
5218                 /* Allow 20% tmp entries. */
5219                 if (num_tmp_dir_entries > allowed_tmp_entries) {
5220                         DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
5221                                 "in directory %s\n",
5222                                 num_tmp_dir_entries, usersharepath));
5223                         break;
5224                 }
5225
5226                 r = process_usershare_file(usersharepath, n, snum_template);
5227                 if (r == 0) {
5228                         /* Update the services count. */
5229                         num_usershares++;
5230                         if (num_usershares >= max_user_shares) {
5231                                 DEBUG(0,("load_usershare_shares: max user shares reached "
5232                                         "on file %s in directory %s\n",
5233                                         n, usersharepath ));
5234                                 break;
5235                         }
5236                 } else if (r == -1) {
5237                         num_bad_dir_entries++;
5238                 }
5239
5240                 /* Allow 20% bad entries. */
5241                 if (num_bad_dir_entries > allowed_bad_entries) {
5242                         DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
5243                                 "in directory %s\n",
5244                                 num_bad_dir_entries, usersharepath));
5245                         break;
5246                 }
5247
5248                 /* Allow 20% bad entries. */
5249                 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
5250                         DEBUG(0,("load_usershare_shares: too many total entries (%u) "
5251                         "in directory %s\n",
5252                         num_dir_entries, usersharepath));
5253                         break;
5254                 }
5255         }
5256
5257         sys_closedir(dp);
5258
5259         /* Sweep through and delete any non-refreshed usershares that are
5260            not currently in use. */
5261         for (iService = iNumServices - 1; iService >= 0; iService--) {
5262                 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
5263                         if (conn_snum_used(iService)) {
5264                                 continue;
5265                         }
5266                         /* Remove from the share ACL db. */
5267                         DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
5268                                 lp_servicename(iService) ));
5269                         delete_share_security(snum2params_static(iService));
5270                         free_service_byindex(iService);
5271                 }
5272         }
5273
5274         return lp_numservices();
5275 }
5276
5277 /********************************************************
5278  Destroy global resources allocated in this file
5279 ********************************************************/
5280
5281 void gfree_loadparm(void)
5282 {
5283         struct file_lists *f;
5284         struct file_lists *next;
5285         int i;
5286
5287         lp_TALLOC_FREE();
5288
5289         /* Free the file lists */
5290
5291         f = file_lists;
5292         while( f ) {
5293                 next = f->next;
5294                 SAFE_FREE( f->name );
5295                 SAFE_FREE( f->subfname );
5296                 SAFE_FREE( f );
5297                 f = next;
5298         }
5299
5300         /* Free resources allocated to services */
5301
5302         for ( i = 0; i < iNumServices; i++ ) {
5303                 if ( VALID(i) ) {
5304                         free_service_byindex(i);
5305                 }
5306         }
5307
5308         SAFE_FREE( ServicePtrs );
5309         iNumServices = 0;
5310
5311         /* Now release all resources allocated to global
5312            parameters and the default service */
5313
5314         for (i = 0; parm_table[i].label; i++)
5315         {
5316                 if ( parm_table[i].type == P_STRING
5317                         || parm_table[i].type == P_USTRING )
5318                 {
5319                         string_free( (char**)parm_table[i].ptr );
5320                 }
5321                 else if (parm_table[i].type == P_LIST) {
5322                         str_list_free( (char***)parm_table[i].ptr );
5323                 }
5324         }
5325 }
5326
5327 /***************************************************************************
5328  Load the services array from the services file. Return True on success,
5329  False on failure.
5330 ***************************************************************************/
5331
5332 BOOL lp_load(const char *pszFname,
5333              BOOL global_only,
5334              BOOL save_defaults,
5335              BOOL add_ipc,
5336              BOOL initialize_globals)
5337 {
5338         pstring n2;
5339         BOOL bRetval;
5340         param_opt_struct *data, *pdata;
5341
5342         pstrcpy(n2, pszFname);
5343
5344         standard_sub_basic( get_current_username(), current_user_info.domain,
5345                             n2,sizeof(n2) );
5346
5347         add_to_file_list(pszFname, n2);
5348
5349         bRetval = False;
5350
5351         DEBUG(3, ("lp_load: refreshing parameters\n"));
5352
5353         bInGlobalSection = True;
5354         bGlobalOnly = global_only;
5355
5356         init_globals(! initialize_globals);
5357         debug_init();
5358
5359         if (save_defaults) {
5360                 init_locals();
5361                 lp_save_defaults();
5362         }
5363
5364         if (Globals.param_opt != NULL) {
5365                 data = Globals.param_opt;
5366                 while (data) {
5367                         string_free(&data->key);
5368                         string_free(&data->value);
5369                         str_list_free(&data->list);
5370                         pdata = data->next;
5371                         SAFE_FREE(data);
5372                         data = pdata;
5373                 }
5374                 Globals.param_opt = NULL;
5375         }
5376
5377         /* We get sections first, so have to start 'behind' to make up */
5378         iServiceIndex = -1;
5379         bRetval = pm_process(n2, do_section, do_parameter);
5380
5381         /* finish up the last section */
5382         DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
5383         if (bRetval)
5384                 if (iServiceIndex >= 0)
5385                         bRetval = service_ok(iServiceIndex);
5386
5387         lp_add_auto_services(lp_auto_services());
5388
5389         if (add_ipc) {
5390                 /* When 'restrict anonymous = 2' guest connections to ipc$
5391                    are denied */
5392                 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
5393                 if ( lp_enable_asu_support() )
5394                         lp_add_ipc("ADMIN$", False);
5395         }
5396
5397         set_server_role();
5398         set_default_server_announce_type();
5399         set_allowed_client_auth();
5400
5401         bLoaded = True;
5402
5403         /* Now we check bWINSsupport and set szWINSserver to 127.0.0.1 */
5404         /* if bWINSsupport is true and we are in the client            */
5405         if (in_client && Globals.bWINSsupport) {
5406                 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
5407         }
5408
5409         init_iconv();
5410
5411         return (bRetval);
5412 }
5413
5414 /***************************************************************************
5415  Reset the max number of services.
5416 ***************************************************************************/
5417
5418 void lp_resetnumservices(void)
5419 {
5420         iNumServices = 0;
5421 }
5422
5423 /***************************************************************************
5424  Return the max number of services.
5425 ***************************************************************************/
5426
5427 int lp_numservices(void)
5428 {
5429         return (iNumServices);
5430 }
5431
5432 /***************************************************************************
5433 Display the contents of the services array in human-readable form.
5434 ***************************************************************************/
5435
5436 void lp_dump(FILE *f, BOOL show_defaults, int maxtoprint)
5437 {
5438         int iService;
5439
5440         if (show_defaults)
5441                 defaults_saved = False;
5442
5443         dump_globals(f);
5444
5445         dump_a_service(&sDefault, f);
5446
5447         for (iService = 0; iService < maxtoprint; iService++) {
5448                 fprintf(f,"\n");
5449                 lp_dump_one(f, show_defaults, iService);
5450         }
5451 }
5452
5453 /***************************************************************************
5454 Display the contents of one service in human-readable form.
5455 ***************************************************************************/
5456
5457 void lp_dump_one(FILE * f, BOOL show_defaults, int snum)
5458 {
5459         if (VALID(snum)) {
5460                 if (ServicePtrs[snum]->szService[0] == '\0')
5461                         return;
5462                 dump_a_service(ServicePtrs[snum], f);
5463         }
5464 }
5465
5466 /***************************************************************************
5467 Return the number of the service with the given name, or -1 if it doesn't
5468 exist. Note that this is a DIFFERENT ANIMAL from the internal function
5469 getservicebyname()! This works ONLY if all services have been loaded, and
5470 does not copy the found service.
5471 ***************************************************************************/
5472
5473 int lp_servicenumber(const char *pszServiceName)
5474 {
5475         int iService;
5476         fstring serviceName;
5477
5478         if (!pszServiceName) {
5479                 return GLOBAL_SECTION_SNUM;
5480         }
5481
5482         for (iService = iNumServices - 1; iService >= 0; iService--) {
5483                 if (VALID(iService) && ServicePtrs[iService]->szService) {
5484                         /*
5485                          * The substitution here is used to support %U is
5486                          * service names
5487                          */
5488                         fstrcpy(serviceName, ServicePtrs[iService]->szService);
5489                         standard_sub_basic(get_current_username(),
5490                                            current_user_info.domain,
5491                                            serviceName,sizeof(serviceName));
5492                         if (strequal(serviceName, pszServiceName)) {
5493                                 break;
5494                         }
5495                 }
5496         }
5497
5498         if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
5499                 time_t last_mod;
5500
5501                 if (!usershare_exists(iService, &last_mod)) {
5502                         /* Remove the share security tdb entry for it. */
5503                         delete_share_security(snum2params_static(iService));
5504                         /* Remove it from the array. */
5505                         free_service_byindex(iService);
5506                         /* Doesn't exist anymore. */
5507                         return GLOBAL_SECTION_SNUM;
5508                 }
5509
5510                 /* Has it been modified ? If so delete and reload. */
5511                 if (ServicePtrs[iService]->usershare_last_mod < last_mod) {
5512                         /* Remove it from the array. */
5513                         free_service_byindex(iService);
5514                         /* and now reload it. */
5515                         iService = load_usershare_service(pszServiceName);
5516                 }
5517         }
5518
5519         if (iService < 0) {
5520                 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
5521                 return GLOBAL_SECTION_SNUM;
5522         }
5523
5524         return (iService);
5525 }
5526
5527 BOOL share_defined(const char *service_name)
5528 {
5529         return (lp_servicenumber(service_name) != -1);
5530 }
5531
5532 struct share_params *get_share_params(TALLOC_CTX *mem_ctx,
5533                                       const char *sharename)
5534 {
5535         struct share_params *result;
5536         char *sname;
5537         int snum;
5538
5539         if (!(sname = SMB_STRDUP(sharename))) {
5540                 return NULL;
5541         }
5542
5543         snum = find_service(sname);
5544         SAFE_FREE(sname);
5545
5546         if (snum < 0) {
5547                 return NULL;
5548         }
5549
5550         if (!(result = TALLOC_P(mem_ctx, struct share_params))) {
5551                 DEBUG(0, ("talloc failed\n"));
5552                 return NULL;
5553         }
5554
5555         result->service = snum;
5556         return result;
5557 }
5558
5559 struct share_iterator *share_list_all(TALLOC_CTX *mem_ctx)
5560 {
5561         struct share_iterator *result;
5562
5563         if (!(result = TALLOC_P(mem_ctx, struct share_iterator))) {
5564                 DEBUG(0, ("talloc failed\n"));
5565                 return NULL;
5566         }
5567
5568         result->next_id = 0;
5569         return result;
5570 }
5571
5572 struct share_params *next_share(struct share_iterator *list)
5573 {
5574         struct share_params *result;
5575
5576         while (!lp_snum_ok(list->next_id) &&
5577                (list->next_id < lp_numservices())) {
5578                 list->next_id += 1;
5579         }
5580
5581         if (list->next_id >= lp_numservices()) {
5582                 return NULL;
5583         }
5584
5585         if (!(result = TALLOC_P(list, struct share_params))) {
5586                 DEBUG(0, ("talloc failed\n"));
5587                 return NULL;
5588         }
5589
5590         result->service = list->next_id;
5591         list->next_id += 1;
5592         return result;
5593 }
5594
5595 struct share_params *next_printer(struct share_iterator *list)
5596 {
5597         struct share_params *result;
5598
5599         while ((result = next_share(list)) != NULL) {
5600                 if (lp_print_ok(result->service)) {
5601                         break;
5602                 }
5603         }
5604         return result;
5605 }
5606
5607 /*
5608  * This is a hack for a transition period until we transformed all code from
5609  * service numbers to struct share_params.
5610  */
5611
5612 struct share_params *snum2params_static(int snum)
5613 {
5614         static struct share_params result;
5615         result.service = snum;
5616         return &result;
5617 }
5618
5619 /*******************************************************************
5620  A useful volume label function.
5621 ********************************************************************/
5622
5623 const char *volume_label(int snum)
5624 {
5625         char *ret;
5626         const char *label = lp_volume(snum);
5627         if (!*label) {
5628                 label = lp_servicename(snum);
5629         }
5630
5631         /* This returns a 33 byte guarenteed null terminated string. */
5632         ret = talloc_strndup(main_loop_talloc_get(), label, 32);
5633         if (!ret) {
5634                 return "";
5635         }
5636         return ret;
5637 }
5638
5639 /*******************************************************************
5640  Set the server type we will announce as via nmbd.
5641 ********************************************************************/
5642
5643 static void set_default_server_announce_type(void)
5644 {
5645         default_server_announce = 0;
5646         default_server_announce |= SV_TYPE_WORKSTATION;
5647         default_server_announce |= SV_TYPE_SERVER;
5648         default_server_announce |= SV_TYPE_SERVER_UNIX;
5649
5650         /* note that the flag should be set only if we have a
5651            printer service but nmbd doesn't actually load the
5652            services so we can't tell   --jerry */
5653
5654         default_server_announce |= SV_TYPE_PRINTQ_SERVER;
5655
5656         switch (lp_announce_as()) {
5657                 case ANNOUNCE_AS_NT_SERVER:
5658                         default_server_announce |= SV_TYPE_SERVER_NT;
5659                         /* fall through... */
5660                 case ANNOUNCE_AS_NT_WORKSTATION:
5661                         default_server_announce |= SV_TYPE_NT;
5662                         break;
5663                 case ANNOUNCE_AS_WIN95:
5664                         default_server_announce |= SV_TYPE_WIN95_PLUS;
5665                         break;
5666                 case ANNOUNCE_AS_WFW:
5667                         default_server_announce |= SV_TYPE_WFW;
5668                         break;
5669                 default:
5670                         break;
5671         }
5672
5673         switch (lp_server_role()) {
5674                 case ROLE_DOMAIN_MEMBER:
5675                         default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
5676                         break;
5677                 case ROLE_DOMAIN_PDC:
5678                         default_server_announce |= SV_TYPE_DOMAIN_CTRL;
5679                         break;
5680                 case ROLE_DOMAIN_BDC:
5681                         default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
5682                         break;
5683                 case ROLE_STANDALONE:
5684                 default:
5685                         break;
5686         }
5687         if (lp_time_server())
5688                 default_server_announce |= SV_TYPE_TIME_SOURCE;
5689
5690         if (lp_host_msdfs())
5691                 default_server_announce |= SV_TYPE_DFS_SERVER;
5692 }
5693
5694 /***********************************************************
5695  returns role of Samba server
5696 ************************************************************/
5697
5698 int lp_server_role(void)
5699 {
5700         return server_role;
5701 }
5702
5703 /***********************************************************
5704  If we are PDC then prefer us as DMB
5705 ************************************************************/
5706
5707 BOOL lp_domain_master(void)
5708 {
5709         if (Globals.bDomainMaster == Auto)
5710                 return (lp_server_role() == ROLE_DOMAIN_PDC);
5711
5712         return Globals.bDomainMaster;
5713 }
5714
5715 /***********************************************************
5716  If we are DMB then prefer us as LMB
5717 ************************************************************/
5718
5719 BOOL lp_preferred_master(void)
5720 {
5721         if (Globals.bPreferredMaster == Auto)
5722                 return (lp_local_master() && lp_domain_master());
5723
5724         return Globals.bPreferredMaster;
5725 }
5726
5727 /*******************************************************************
5728  Remove a service.
5729 ********************************************************************/
5730
5731 void lp_remove_service(int snum)
5732 {
5733         ServicePtrs[snum]->valid = False;
5734         invalid_services[num_invalid_services++] = snum;
5735 }
5736
5737 /*******************************************************************
5738  Copy a service.
5739 ********************************************************************/
5740
5741 void lp_copy_service(int snum, const char *new_name)
5742 {
5743         do_section(new_name);
5744         if (snum >= 0) {
5745                 snum = lp_servicenumber(new_name);
5746                 if (snum >= 0)
5747                         lp_do_parameter(snum, "copy", lp_servicename(snum));
5748         }
5749 }
5750
5751
5752 /*******************************************************************
5753  Get the default server type we will announce as via nmbd.
5754 ********************************************************************/
5755
5756 int lp_default_server_announce(void)
5757 {
5758         return default_server_announce;
5759 }
5760
5761 /*******************************************************************
5762  Split the announce version into major and minor numbers.
5763 ********************************************************************/
5764
5765 int lp_major_announce_version(void)
5766 {
5767         static BOOL got_major = False;
5768         static int major_version = DEFAULT_MAJOR_VERSION;
5769         char *vers;
5770         char *p;
5771
5772         if (got_major)
5773                 return major_version;
5774
5775         got_major = True;
5776         if ((vers = lp_announce_version()) == NULL)
5777                 return major_version;
5778
5779         if ((p = strchr_m(vers, '.')) == 0)
5780                 return major_version;
5781
5782         *p = '\0';
5783         major_version = atoi(vers);
5784         return major_version;
5785 }
5786
5787 int lp_minor_announce_version(void)
5788 {
5789         static BOOL got_minor = False;
5790         static int minor_version = DEFAULT_MINOR_VERSION;
5791         char *vers;
5792         char *p;
5793
5794         if (got_minor)
5795                 return minor_version;
5796
5797         got_minor = True;
5798         if ((vers = lp_announce_version()) == NULL)
5799                 return minor_version;
5800
5801         if ((p = strchr_m(vers, '.')) == 0)
5802                 return minor_version;
5803
5804         p++;
5805         minor_version = atoi(p);
5806         return minor_version;
5807 }
5808
5809 /***********************************************************
5810  Set the global name resolution order (used in smbclient).
5811 ************************************************************/
5812
5813 void lp_set_name_resolve_order(const char *new_order)
5814 {
5815         string_set(&Globals.szNameResolveOrder, new_order);
5816 }
5817
5818 const char *lp_printername(int snum)
5819 {
5820         const char *ret = _lp_printername(snum);
5821         if (ret == NULL || (ret != NULL && *ret == '\0'))
5822                 ret = lp_const_servicename(snum);
5823
5824         return ret;
5825 }
5826
5827
5828 /***********************************************************
5829  Allow daemons such as winbindd to fix their logfile name.
5830 ************************************************************/
5831
5832 void lp_set_logfile(const char *name)
5833 {
5834         string_set(&Globals.szLogFile, name);
5835         pstrcpy(debugf, name);
5836 }
5837
5838 /*******************************************************************
5839  Return the max print jobs per queue.
5840 ********************************************************************/
5841
5842 int lp_maxprintjobs(int snum)
5843 {
5844         int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
5845         if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
5846                 maxjobs = PRINT_MAX_JOBID - 1;
5847
5848         return maxjobs;
5849 }
5850
5851 const char *lp_printcapname(void)
5852 {
5853         if ((Globals.szPrintcapname != NULL) &&
5854             (Globals.szPrintcapname[0] != '\0'))
5855                 return Globals.szPrintcapname;
5856
5857         if (sDefault.iPrinting == PRINT_CUPS) {
5858 #ifdef HAVE_CUPS
5859                 return "cups";
5860 #else
5861                 return "lpstat";
5862 #endif
5863         }
5864
5865         if (sDefault.iPrinting == PRINT_BSD)
5866                 return "/etc/printcap";
5867
5868         return PRINTCAP_NAME;
5869 }
5870
5871 /*******************************************************************
5872  Ensure we don't use sendfile if server smb signing is active.
5873 ********************************************************************/
5874
5875 static uint32 spoolss_state;
5876
5877 BOOL lp_disable_spoolss( void )
5878 {
5879         if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
5880                 spoolss_state = _lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
5881
5882         return spoolss_state == SVCCTL_STOPPED ? True : False;
5883 }
5884
5885 void lp_set_spoolss_state( uint32 state )
5886 {
5887         SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
5888
5889         spoolss_state = state;
5890 }
5891
5892 uint32 lp_get_spoolss_state( void )
5893 {
5894         return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
5895 }
5896
5897 /*******************************************************************
5898  Ensure we don't use sendfile if server smb signing is active.
5899 ********************************************************************/
5900
5901 BOOL lp_use_sendfile(int snum)
5902 {
5903         /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
5904         if (Protocol < PROTOCOL_NT1) {
5905                 return False;
5906         }
5907         return (_lp_use_sendfile(snum) && (get_remote_arch() != RA_WIN95) && !srv_is_signing_active());
5908 }
5909
5910 /*******************************************************************
5911  Turn off sendfile if we find the underlying OS doesn't support it.
5912 ********************************************************************/
5913
5914 void set_use_sendfile(int snum, BOOL val)
5915 {
5916         if (LP_SNUM_OK(snum))
5917                 ServicePtrs[snum]->bUseSendfile = val;
5918         else
5919                 sDefault.bUseSendfile = val;
5920 }
5921
5922 /*******************************************************************
5923  Turn off storing DOS attributes if this share doesn't support it.
5924 ********************************************************************/
5925
5926 void set_store_dos_attributes(int snum, BOOL val)
5927 {
5928         if (!LP_SNUM_OK(snum))
5929                 return;
5930         ServicePtrs[(snum)]->bStoreDosAttributes = val;
5931 }
5932
5933 void lp_set_mangling_method(const char *new_method)
5934 {
5935         string_set(&Globals.szManglingMethod, new_method);
5936 }
5937
5938 /*******************************************************************
5939  Global state for POSIX pathname processing.
5940 ********************************************************************/
5941
5942 static BOOL posix_pathnames;
5943
5944 BOOL lp_posix_pathnames(void)
5945 {
5946         return posix_pathnames;
5947 }
5948
5949 /*******************************************************************
5950  Change everything needed to ensure POSIX pathname processing (currently
5951  not much).
5952 ********************************************************************/
5953
5954 void lp_set_posix_pathnames(void)
5955 {
5956         posix_pathnames = True;
5957 }
5958
5959 /*******************************************************************
5960  Global state for POSIX lock processing - CIFS unix extensions.
5961 ********************************************************************/
5962
5963 BOOL posix_default_lock_was_set;
5964 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
5965
5966 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
5967 {
5968         if (posix_default_lock_was_set) {
5969                 return posix_cifsx_locktype;
5970         } else {
5971                 return fsp->posix_open ? POSIX_LOCK : WINDOWS_LOCK;
5972         }
5973 }
5974
5975 /*******************************************************************
5976 ********************************************************************/
5977
5978 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
5979 {
5980         posix_default_lock_was_set = True;
5981         posix_cifsx_locktype = val;
5982 }