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