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