source3/param/loadparm.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Parameter loading functions
   4    Copyright (C) Karl Auer 1993-1998
   5
   6    Largely re-written by Andrew Tridgell, September 1994
   7
   8    Copyright (C) Simo Sorce 2001
   9    Copyright (C) Alexander Bokovoy 2002
  10    Copyright (C) Stefan (metze) Metzmacher 2002
  11    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
  12
  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 userdom_struct current_user_info;
  60 extern pstring user_socket_options;
  61
  62 #ifndef GLOBAL_NAME
  63 #define GLOBAL_NAME "global"
  64 #endif
  65
  66 #ifndef PRINTERS_NAME
  67 #define PRINTERS_NAME "printers"
  68 #endif
  69
  70 #ifndef HOMES_NAME
  71 #define HOMES_NAME "homes"
  72 #endif
  73
  74 /* some helpful bits */
  75 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && ServicePtrs[(i)]->valid)
  76 #define VALID(i) ServicePtrs[i]->valid
  77
  78 int keepalive = DEFAULT_KEEPALIVE;
  79 BOOL use_getwd_cache = True;
  80
  81 extern int extra_time_offset;
  82
  83 static BOOL defaults_saved = False;
  84
  85 typedef struct _param_opt_struct param_opt_struct;
  86 struct _param_opt_struct {
  87         param_opt_struct *prev, *next;
  88         char *key;
  89         char *value;
  90         char **list;
  91 };
  92
  93 /*
  94  * This structure describes global (ie., server-wide) parameters.
  95  */
  96 typedef struct
  97 {
  98         char *smb_ports;
  99         char *dos_charset;
 100         char *unix_charset;
 101         char *display_charset;
 102         char *szPrintcapname;
 103         char *szEnumPortsCommand;
 104         char *szAddPrinterCommand;
 105         char *szDeletePrinterCommand;
 106         char *szOs2DriverMap;
 107         char *szLockDir;
 108         char *szPidDir;
 109         char *szRootdir;
 110         char *szDefaultService;
 111         char *szDfree;
 112         char *szGetQuota;
 113         char *szSetQuota;
 114         char *szMsgCommand;
 115         char *szHostsEquiv;
 116         char *szServerString;
 117         char *szAutoServices;
 118         char *szPasswdProgram;
 119         char *szPasswdChat;
 120         char *szLogFile;
 121         char *szConfigFile;
 122         char *szSMBPasswdFile;
 123         char *szPrivateDir;
 124         char **szPassdbBackend;
 125         char **szPreloadModules;
 126         char *szPasswordServer;
 127         char *szSocketOptions;
 128         char *szRealm;
 129         char *szAfsUsernameMap;
 130         char *szUsernameMap;
 131         char *szLogonScript;
 132         char *szLogonPath;
 133         char *szLogonDrive;
 134         char *szLogonHome;
 135         char **szWINSservers;
 136         char **szInterfaces;
 137         char *szRemoteAnnounce;
 138         char *szRemoteBrowseSync;
 139         char *szSocketAddress;
 140         char *szNISHomeMapName;
 141         char *szAnnounceVersion;        /* This is initialised in init_globals */
 142         char *szWorkgroup;
 143         char *szNetbiosName;
 144         char **szNetbiosAliases;
 145         char *szNetbiosScope;
 146         char *szDomainOtherSIDs;
 147         char *szNameResolveOrder;
 148         char *szPanicAction;
 149         char *szAddUserScript;
 150         char *szDelUserScript;
 151         char *szAddGroupScript;
 152         char *szDelGroupScript;
 153         char *szAddUserToGroupScript;
 154         char *szDelUserFromGroupScript;
 155         char *szSetPrimaryGroupScript;
 156         char *szAddMachineScript;
 157         char *szShutdownScript;
 158         char *szAbortShutdownScript;
 159         char *szCheckPasswordScript;
 160         char *szWINSHook;
 161         char *szWINSPartners;
 162         char *szUtmpDir;
 163         char *szWtmpDir;
 164         BOOL bUtmp;
 165         char *szIdmapUID;
 166         char *szIdmapGID;
 167         BOOL bEnableRidAlgorithm;
 168         int AlgorithmicRidBase;
 169         char *szTemplatePrimaryGroup;
 170         char *szTemplateHomedir;
 171         char *szTemplateShell;
 172         char *szWinbindSeparator;
 173         BOOL bWinbindEnableLocalAccounts;
 174         BOOL bWinbindEnumUsers;
 175         BOOL bWinbindEnumGroups;
 176         BOOL bWinbindUseDefaultDomain;
 177         BOOL bWinbindTrustedDomainsOnly;
 178         BOOL bWinbindNestedGroups;
 179         char *szWinbindBackend;
 180         char **szIdmapBackend;
 181         char *szAddShareCommand;
 182         char *szChangeShareCommand;
 183         char *szDeleteShareCommand;
 184         char *szGuestaccount;
 185         char *szManglingMethod;
 186         int mangle_prefix;
 187         int max_log_size;
 188         char *szLogLevel;
 189         int max_xmit;
 190         int max_mux;
 191         int max_open_files;
 192         int pwordlevel;
 193         int unamelevel;
 194         int deadtime;
 195         int maxprotocol;
 196         int minprotocol;
 197         int security;
 198         char **AuthMethods;
 199         BOOL paranoid_server_security;
 200         int maxdisksize;
 201         int lpqcachetime;
 202         int iMaxSmbdProcesses;
 203         BOOL bDisableSpoolss;
 204         int syslog;
 205         int os_level;
 206         int enhanced_browsing;
 207         int max_ttl;
 208         int max_wins_ttl;
 209         int min_wins_ttl;
 210         int lm_announce;
 211         int lm_interval;
 212         int announce_as;        /* This is initialised in init_globals */
 213         int machine_password_timeout;
 214         int change_notify_timeout;
 215         int map_to_guest;
 216         int min_passwd_length;
 217         int oplock_break_wait_time;
 218         int winbind_cache_time;
 219         int iLockSpinCount;
 220         int iLockSpinTime;
 221         char *szLdapMachineSuffix;
 222         char *szLdapUserSuffix;
 223         char *szLdapIdmapSuffix;
 224         char *szLdapGroupSuffix;
 225 #ifdef WITH_LDAP_SAMCONFIG
 226         int ldap_port;
 227         char *szLdapServer;
 228 #endif
 229         int ldap_ssl;
 230         char *szLdapSuffix;
 231         char *szLdapFilter;
 232         char *szLdapAdminDn;
 233         char *szAclCompat;
 234         char *szCupsServer;
 235         int ldap_passwd_sync;
 236         int ldap_replication_sleep;
 237         int ldap_timeout; /* This is initialised in init_globals */
 238         BOOL ldap_delete_dn;
 239         BOOL bMsAddPrinterWizard;
 240         BOOL bDNSproxy;
 241         BOOL bWINSsupport;
 242         BOOL bWINSproxy;
 243         BOOL bLocalMaster;
 244         BOOL bPreferredMaster;
 245         BOOL bDomainMaster;
 246         BOOL bDomainLogons;
 247         BOOL bEncryptPasswords;
 248         BOOL bUpdateEncrypt;
 249         int  clientSchannel;
 250         int  serverSchannel;
 251         BOOL bNullPasswords;
 252         BOOL bObeyPamRestrictions;
 253         BOOL bLoadPrinters;
 254         int PrintcapCacheTime;
 255         BOOL bLargeReadwrite;
 256         BOOL bReadRaw;
 257         BOOL bWriteRaw;
 258         BOOL bReadbmpx;
 259         BOOL bSyslogOnly;
 260         BOOL bBrowseList;
 261         BOOL bNISHomeMap;
 262         BOOL bTimeServer;
 263         BOOL bBindInterfacesOnly;
 264         BOOL bPamPasswordChange;
 265         BOOL bUnixPasswdSync;
 266         BOOL bPasswdChatDebug;
 267         int iPasswdChatTimeout;
 268         BOOL bTimestampLogs;
 269         BOOL bNTSmbSupport;
 270         BOOL bNTPipeSupport;
 271         BOOL bNTStatusSupport;
 272         BOOL bStatCache;
 273         BOOL bKernelOplocks;
 274         BOOL bAllowTrustedDomains;
 275         BOOL bLanmanAuth;
 276         BOOL bNTLMAuth;
 277         BOOL bUseSpnego;
 278         BOOL bClientLanManAuth;
 279         BOOL bClientNTLMv2Auth;
 280         BOOL bClientPlaintextAuth;
 281         BOOL bClientUseSpnego;
 282         BOOL bDebugHiresTimestamp;
 283         BOOL bDebugPid;
 284         BOOL bDebugUid;
 285         BOOL bHostMSDfs;
 286         BOOL bUseMmap;
 287         BOOL bHostnameLookups;
 288         BOOL bUnixExtensions;
 289         BOOL bDisableNetbios;
 290         BOOL bKernelChangeNotify;
 291         BOOL bUseKerberosKeytab;
 292         BOOL bDeferSharingViolations;
 293         int restrict_anonymous;
 294         int name_cache_timeout;
 295         int client_signing;
 296         int server_signing;
 297         param_opt_struct *param_opt;
 298 }
 299 global;
 300
 301 static global Globals;
 302
 303 /*
 304  * This structure describes a single service.
 305  */
 306 typedef struct
 307 {
 308         BOOL valid;
 309         BOOL autoloaded;
 310         char *szService;
 311         char *szPath;
 312         char *szUsername;
 313         char **szInvalidUsers;
 314         char **szValidUsers;
 315         char **szAdminUsers;
 316         char *szCopy;
 317         char *szInclude;
 318         char *szPreExec;
 319         char *szPostExec;
 320         char *szRootPreExec;
 321         char *szRootPostExec;
 322         char *szCupsOptions;
 323         char *szPrintcommand;
 324         char *szLpqcommand;
 325         char *szLprmcommand;
 326         char *szLppausecommand;
 327         char *szLpresumecommand;
 328         char *szQueuepausecommand;
 329         char *szQueueresumecommand;
 330         char *szPrintername;
 331         char *szDontdescend;
 332         char **szHostsallow;
 333         char **szHostsdeny;
 334         char *szMagicScript;
 335         char *szMagicOutput;
 336         char *szMangledMap;
 337         char *szVetoFiles;
 338         char *szHideFiles;
 339         char *szVetoOplockFiles;
 340         char *comment;
 341         char *force_user;
 342         char *force_group;
 343         char **readlist;
 344         char **writelist;
 345         char **printer_admin;
 346         char *volume;
 347         char *fstype;
 348         char **szVfsObjects;
 349         char *szMSDfsProxy;
 350         int iMinPrintSpace;
 351         int iMaxPrintJobs;
 352         int iMaxReportedPrintJobs;
 353         int iWriteCacheSize;
 354         int iCreate_mask;
 355         int iCreate_force_mode;
 356         int iSecurity_mask;
 357         int iSecurity_force_mode;
 358         int iDir_mask;
 359         int iDir_force_mode;
 360         int iDir_Security_mask;
 361         int iDir_Security_force_mode;
 362         int iMaxConnections;
 363         int iDefaultCase;
 364         int iPrinting;
 365         int iOplockContentionLimit;
 366         int iCSCPolicy;
 367         int iBlock_size;
 368         BOOL bPreexecClose;
 369         BOOL bRootpreexecClose;
 370         int  iCaseSensitive;
 371         BOOL bCasePreserve;
 372         BOOL bShortCasePreserve;
 373         BOOL bHideDotFiles;
 374         BOOL bHideSpecialFiles;
 375         BOOL bHideUnReadable;
 376         BOOL bHideUnWriteableFiles;
 377         BOOL bBrowseable;
 378         BOOL bAvailable;
 379         BOOL bRead_only;
 380         BOOL bNo_set_dir;
 381         BOOL bGuest_only;
 382         BOOL bGuest_ok;
 383         BOOL bPrint_ok;
 384         BOOL bMap_system;
 385         BOOL bMap_hidden;
 386         BOOL bMap_archive;
 387         BOOL bStoreDosAttributes;
 388         BOOL bLocking;
 389         int iStrictLocking;
 390         BOOL bPosixLocking;
 391         BOOL bShareModes;
 392         BOOL bOpLocks;
 393         BOOL bLevel2OpLocks;
 394         BOOL bOnlyUser;
 395         BOOL bMangledNames;
 396         BOOL bWidelinks;
 397         BOOL bSymlinks;
 398         BOOL bSyncAlways;
 399         BOOL bStrictAllocate;
 400         BOOL bStrictSync;
 401         char magic_char;
 402         BOOL *copymap;
 403         BOOL bDeleteReadonly;
 404         BOOL bFakeOplocks;
 405         BOOL bDeleteVetoFiles;
 406         BOOL bDosFilemode;
 407         BOOL bDosFiletimes;
 408         BOOL bDosFiletimeResolution;
 409         BOOL bFakeDirCreateTimes;
 410         BOOL bBlockingLocks;
 411         BOOL bInheritPerms;
 412         BOOL bInheritACLS;
 413         BOOL bMSDfsRoot;
 414         BOOL bUseClientDriver;
 415         BOOL bDefaultDevmode;
 416         BOOL bForcePrintername;
 417         BOOL bNTAclSupport;
 418         BOOL bForceUnknownAclUser;
 419         BOOL bUseSendfile;
 420         BOOL bProfileAcls;
 421         BOOL bMap_acl_inherit;
 422         BOOL bAfs_Share;
 423         BOOL bEASupport;
 424         param_opt_struct *param_opt;
 425
 426         char dummy[3];          /* for alignment */
 427 }
 428 service;
 429
 430
 431 /* This is a default service used to prime a services structure */
 432 static service sDefault = {
 433         True,                   /* valid */
 434         False,                  /* not autoloaded */
 435         NULL,                   /* szService */
 436         NULL,                   /* szPath */
 437         NULL,                   /* szUsername */
 438         NULL,                   /* szInvalidUsers */
 439         NULL,                   /* szValidUsers */
 440         NULL,                   /* szAdminUsers */
 441         NULL,                   /* szCopy */
 442         NULL,                   /* szInclude */
 443         NULL,                   /* szPreExec */
 444         NULL,                   /* szPostExec */
 445         NULL,                   /* szRootPreExec */
 446         NULL,                   /* szRootPostExec */
 447         NULL,                   /* szCupsOptions */
 448         NULL,                   /* szPrintcommand */
 449         NULL,                   /* szLpqcommand */
 450         NULL,                   /* szLprmcommand */
 451         NULL,                   /* szLppausecommand */
 452         NULL,                   /* szLpresumecommand */
 453         NULL,                   /* szQueuepausecommand */
 454         NULL,                   /* szQueueresumecommand */
 455         NULL,                   /* szPrintername */
 456         NULL,                   /* szDontdescend */
 457         NULL,                   /* szHostsallow */
 458         NULL,                   /* szHostsdeny */
 459         NULL,                   /* szMagicScript */
 460         NULL,                   /* szMagicOutput */
 461         NULL,                   /* szMangledMap */
 462         NULL,                   /* szVetoFiles */
 463         NULL,                   /* szHideFiles */
 464         NULL,                   /* szVetoOplockFiles */
 465         NULL,                   /* comment */
 466         NULL,                   /* force user */
 467         NULL,                   /* force group */
 468         NULL,                   /* readlist */
 469         NULL,                   /* writelist */
 470         NULL,                   /* printer admin */
 471         NULL,                   /* volume */
 472         NULL,                   /* fstype */
 473         NULL,                   /* vfs objects */
 474         NULL,                   /* szMSDfsProxy */
 475         0,                      /* iMinPrintSpace */
 476         1000,                   /* iMaxPrintJobs */
 477         0,                      /* iMaxReportedPrintJobs */
 478         0,                      /* iWriteCacheSize */
 479         0744,                   /* iCreate_mask */
 480         0000,                   /* iCreate_force_mode */
 481         0777,                   /* iSecurity_mask */
 482         0,                      /* iSecurity_force_mode */
 483         0755,                   /* iDir_mask */
 484         0000,                   /* iDir_force_mode */
 485         0777,                   /* iDir_Security_mask */
 486         0,                      /* iDir_Security_force_mode */
 487         0,                      /* iMaxConnections */
 488         CASE_LOWER,             /* iDefaultCase */
 489         DEFAULT_PRINTING,       /* iPrinting */
 490         2,                      /* iOplockContentionLimit */
 491         0,                      /* iCSCPolicy */
 492         1024,           /* iBlock_size */
 493         False,                  /* bPreexecClose */
 494         False,                  /* bRootpreexecClose */
 495         Auto,                   /* case sensitive */
 496         True,                   /* case preserve */
 497         True,                   /* short case preserve */
 498         True,                   /* bHideDotFiles */
 499         False,                  /* bHideSpecialFiles */
 500         False,                  /* bHideUnReadable */
 501         False,                  /* bHideUnWriteableFiles */
 502         True,                   /* bBrowseable */
 503         True,                   /* bAvailable */
 504         True,                   /* bRead_only */
 505         True,                   /* bNo_set_dir */
 506         False,                  /* bGuest_only */
 507         False,                  /* bGuest_ok */
 508         False,                  /* bPrint_ok */
 509         False,                  /* bMap_system */
 510         False,                  /* bMap_hidden */
 511         True,                   /* bMap_archive */
 512         False,                  /* bStoreDosAttributes */
 513         True,                   /* bLocking */
 514         True,                   /* iStrictLocking */
 515         True,                   /* bPosixLocking */
 516         True,                   /* bShareModes */
 517         True,                   /* bOpLocks */
 518         True,                   /* bLevel2OpLocks */
 519         False,                  /* bOnlyUser */
 520         True,                   /* bMangledNames */
 521         True,                   /* bWidelinks */
 522         True,                   /* bSymlinks */
 523         False,                  /* bSyncAlways */
 524         False,                  /* bStrictAllocate */
 525         False,                  /* bStrictSync */
 526         '~',                    /* magic char */
 527         NULL,                   /* copymap */
 528         False,                  /* bDeleteReadonly */
 529         False,                  /* bFakeOplocks */
 530         False,                  /* bDeleteVetoFiles */
 531         False,                  /* bDosFilemode */
 532         False,                  /* bDosFiletimes */
 533         False,                  /* bDosFiletimeResolution */
 534         False,                  /* bFakeDirCreateTimes */
 535         True,                   /* bBlockingLocks */
 536         False,                  /* bInheritPerms */
 537         False,                  /* bInheritACLS */
 538         False,                  /* bMSDfsRoot */
 539         False,                  /* bUseClientDriver */
 540         False,                  /* bDefaultDevmode */
 541         False,                  /* bForcePrintername */
 542         True,                   /* bNTAclSupport */
 543         False,                  /* bForceUnknownAclUser */
 544         False,                  /* bUseSendfile */
 545         False,                  /* bProfileAcls */
 546         False,                  /* bMap_acl_inherit */
 547         False,                  /* bAfs_Share */
 548         False,                  /* bEASupport */
 549
 550         NULL,                   /* Parametric options */
 551
 552         ""                      /* dummy */
 553 };
 554
 555 /* local variables */
 556 static service **ServicePtrs = NULL;
 557 static int iNumServices = 0;
 558 static int iServiceIndex = 0;
 559 static BOOL bInGlobalSection = True;
 560 static BOOL bGlobalOnly = False;
 561 static int server_role;
 562 static int default_server_announce;
 563
 564 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
 565
 566 /* prototypes for the special type handlers */
 567 static BOOL handle_include( int snum, const char *pszParmValue, char **ptr);
 568 static BOOL handle_copy( int snum, const char *pszParmValue, char **ptr);
 569 static BOOL handle_netbios_name( int snum, const char *pszParmValue, char **ptr);
 570 static BOOL handle_idmap_uid( int snum, const char *pszParmValue, char **ptr);
 571 static BOOL handle_idmap_gid( int snum, const char *pszParmValue, char **ptr);
 572 static BOOL handle_debug_list( int snum, const char *pszParmValue, char **ptr );
 573 static BOOL handle_workgroup( int snum, const char *pszParmValue, char **ptr );
 574 static BOOL handle_netbios_aliases( int snum, const char *pszParmValue, char **ptr );
 575 static BOOL handle_netbios_scope( int snum, const char *pszParmValue, char **ptr );
 576 static BOOL handle_charset( int snum, const char *pszParmValue, char **ptr );
 577 static BOOL handle_acl_compatibility( int snum, const char *pszParmValue, char **ptr);
 578 static BOOL handle_printing( int snum, const char *pszParmValue, char **ptr);
 579
 580 static void set_server_role(void);
 581 static void set_default_server_announce_type(void);
 582 static void set_allowed_client_auth(void);
 583
 584 static const struct enum_list enum_protocol[] = {
 585         {PROTOCOL_NT1, "NT1"},
 586         {PROTOCOL_LANMAN2, "LANMAN2"},
 587         {PROTOCOL_LANMAN1, "LANMAN1"},
 588         {PROTOCOL_CORE, "CORE"},
 589         {PROTOCOL_COREPLUS, "COREPLUS"},
 590         {PROTOCOL_COREPLUS, "CORE+"},
 591         {-1, NULL}
 592 };
 593
 594 static const struct enum_list enum_security[] = {
 595         {SEC_SHARE, "SHARE"},
 596         {SEC_USER, "USER"},
 597         {SEC_SERVER, "SERVER"},
 598         {SEC_DOMAIN, "DOMAIN"},
 599 #ifdef HAVE_ADS
 600         {SEC_ADS, "ADS"},
 601 #endif
 602         {-1, NULL}
 603 };
 604
 605 static const struct enum_list enum_printing[] = {
 606         {PRINT_SYSV, "sysv"},
 607         {PRINT_AIX, "aix"},
 608         {PRINT_HPUX, "hpux"},
 609         {PRINT_BSD, "bsd"},
 610         {PRINT_QNX, "qnx"},
 611         {PRINT_PLP, "plp"},
 612         {PRINT_LPRNG, "lprng"},
 613         {PRINT_CUPS, "cups"},
 614         {PRINT_LPRNT, "nt"},
 615         {PRINT_LPROS2, "os2"},
 616 #ifdef DEVELOPER
 617         {PRINT_TEST, "test"},
 618         {PRINT_VLP, "vlp"},
 619 #endif /* DEVELOPER */
 620         {-1, NULL}
 621 };
 622
 623 static const struct enum_list enum_ldap_ssl[] = {
 624 #ifdef WITH_LDAP_SAMCONFIG
 625         {LDAP_SSL_ON, "Yes"},
 626         {LDAP_SSL_ON, "yes"},
 627         {LDAP_SSL_ON, "on"},
 628         {LDAP_SSL_ON, "On"},
 629 #endif
 630         {LDAP_SSL_OFF, "no"},
 631         {LDAP_SSL_OFF, "No"},
 632         {LDAP_SSL_OFF, "off"},
 633         {LDAP_SSL_OFF, "Off"},
 634         {LDAP_SSL_START_TLS, "start tls"},
 635         {LDAP_SSL_START_TLS, "Start_tls"},
 636         {-1, NULL}
 637 };
 638
 639 static const struct enum_list enum_ldap_passwd_sync[] = {
 640         {LDAP_PASSWD_SYNC_OFF, "no"},
 641         {LDAP_PASSWD_SYNC_OFF, "No"},
 642         {LDAP_PASSWD_SYNC_OFF, "off"},
 643         {LDAP_PASSWD_SYNC_OFF, "Off"},
 644         {LDAP_PASSWD_SYNC_ON, "Yes"},
 645         {LDAP_PASSWD_SYNC_ON, "yes"},
 646         {LDAP_PASSWD_SYNC_ON, "on"},
 647         {LDAP_PASSWD_SYNC_ON, "On"},
 648         {LDAP_PASSWD_SYNC_ONLY, "Only"},
 649         {LDAP_PASSWD_SYNC_ONLY, "only"},
 650         {-1, NULL}
 651 };
 652
 653 /* Types of machine we can announce as. */
 654 #define ANNOUNCE_AS_NT_SERVER 1
 655 #define ANNOUNCE_AS_WIN95 2
 656 #define ANNOUNCE_AS_WFW 3
 657 #define ANNOUNCE_AS_NT_WORKSTATION 4
 658
 659 static const struct enum_list enum_announce_as[] = {
 660         {ANNOUNCE_AS_NT_SERVER, "NT"},
 661         {ANNOUNCE_AS_NT_SERVER, "NT Server"},
 662         {ANNOUNCE_AS_NT_WORKSTATION, "NT Workstation"},
 663         {ANNOUNCE_AS_WIN95, "win95"},
 664         {ANNOUNCE_AS_WFW, "WfW"},
 665         {-1, NULL}
 666 };
 667
 668 static const struct enum_list enum_case[] = {
 669         {CASE_LOWER, "lower"},
 670         {CASE_UPPER, "upper"},
 671         {-1, NULL}
 672 };
 673
 674 static const struct enum_list enum_bool_auto[] = {
 675         {False, "No"},
 676         {False, "False"},
 677         {False, "0"},
 678         {True, "Yes"},
 679         {True, "True"},
 680         {True, "1"},
 681         {Auto, "Auto"},
 682         {-1, NULL}
 683 };
 684
 685 /* Client-side offline caching policy types */
 686 #define CSC_POLICY_MANUAL 0
 687 #define CSC_POLICY_DOCUMENTS 1
 688 #define CSC_POLICY_PROGRAMS 2
 689 #define CSC_POLICY_DISABLE 3
 690
 691 static const struct enum_list enum_csc_policy[] = {
 692         {CSC_POLICY_MANUAL, "manual"},
 693         {CSC_POLICY_DOCUMENTS, "documents"},
 694         {CSC_POLICY_PROGRAMS, "programs"},
 695         {CSC_POLICY_DISABLE, "disable"},
 696         {-1, NULL}
 697 };
 698
 699 /* SMB signing types. */
 700 static const struct enum_list enum_smb_signing_vals[] = {
 701         {False, "No"},
 702         {False, "False"},
 703         {False, "0"},
 704         {False, "Off"},
 705         {False, "disabled"},
 706         {True, "Yes"},
 707         {True, "True"},
 708         {True, "1"},
 709         {True, "On"},
 710         {True, "enabled"},
 711         {Auto, "auto"},
 712         {Required, "required"},
 713         {Required, "mandatory"},
 714         {Required, "force"},
 715         {Required, "forced"},
 716         {Required, "enforced"},
 717         {-1, NULL}
 718 };
 719
 720
 721 /*
 722    Do you want session setups at user level security with a invalid
 723    password to be rejected or allowed in as guest? WinNT rejects them
 724    but it can be a pain as it means "net view" needs to use a password
 725
 726    You have 3 choices in the setting of map_to_guest:
 727
 728    "Never" means session setups with an invalid password
 729    are rejected. This is the default.
 730
 731    "Bad User" means session setups with an invalid password
 732    are rejected, unless the username does not exist, in which case it
 733    is treated as a guest login
 734
 735    "Bad Password" means session setups with an invalid password
 736    are treated as a guest login
 737
 738    Note that map_to_guest only has an effect in user or server
 739    level security.
 740 */
 741
 742 static const struct enum_list enum_map_to_guest[] = {
 743         {NEVER_MAP_TO_GUEST, "Never"},
 744         {MAP_TO_GUEST_ON_BAD_USER, "Bad User"},
 745         {MAP_TO_GUEST_ON_BAD_PASSWORD, "Bad Password"},
 746         {-1, NULL}
 747 };
 748
 749 /* Note: We do not initialise the defaults union - it is not allowed in ANSI C
 750  *
 751  * The FLAG_HIDE is explicit. Paramters set this way do NOT appear in any edit
 752  * screen in SWAT. This is used to exclude parameters as well as to squash all
 753  * parameters that have been duplicated by pseudonyms.
 754  *
 755  * NOTE: To display a parameter in BASIC view set FLAG_BASIC
 756  *       Any parameter that does NOT have FLAG_ADVANCED will not disply at all
 757  *       Set FLAG_SHARE and FLAG_PRINT to specifically display parameters in
 758  *        respective views.
 759  *
 760  * NOTE2: Handling of duplicated (synonym) paramters:
 761  *      Only the first occurance of a parameter should be enabled by FLAG_BASIC
 762  *      and/or FLAG_ADVANCED. All duplicates following the first mention should be
 763  *      set to FLAG_HIDE. ie: Make you must place the parameter that has the preferred
 764  *      name first, and all synonyms must follow it with the FLAG_HIDE attribute.
 765  */
 766
 767 static struct parm_struct parm_table[] = {
 768         {N_("Base Options"), P_SEP, P_SEPARATOR},
 769
 770         {"dos charset", P_STRING, P_GLOBAL, &Globals.dos_charset, handle_charset, NULL, FLAG_ADVANCED},
 771         {"unix charset", P_STRING, P_GLOBAL, &Globals.unix_charset, handle_charset, NULL, FLAG_ADVANCED},
 772         {"display charset", P_STRING, P_GLOBAL, &Globals.display_charset, handle_charset, NULL, FLAG_ADVANCED},
 773         {"comment", P_STRING, P_LOCAL, &sDefault.comment, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
 774         {"path", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
 775         {"directory", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_HIDE},
 776         {"workgroup", P_USTRING, P_GLOBAL, &Globals.szWorkgroup, handle_workgroup, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 777 #ifdef WITH_ADS
 778         {"realm", P_USTRING, P_GLOBAL, &Globals.szRealm, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 779 #endif
 780         {"netbios name", P_USTRING, P_GLOBAL, &Globals.szNetbiosName, handle_netbios_name, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 781         {"netbios aliases", P_LIST, P_GLOBAL, &Globals.szNetbiosAliases, handle_netbios_aliases,  NULL, FLAG_ADVANCED},
 782         {"netbios scope", P_USTRING, P_GLOBAL, &Globals.szNetbiosScope, handle_netbios_scope,  NULL, FLAG_ADVANCED},
 783         {"server string", P_STRING, P_GLOBAL, &Globals.szServerString, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED },
 784         {"interfaces", P_LIST, P_GLOBAL, &Globals.szInterfaces, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 785         {"bind interfaces only", P_BOOL, P_GLOBAL, &Globals.bBindInterfacesOnly, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
 786
 787         {N_("Security Options"), P_SEP, P_SEPARATOR},
 788
 789         {"security", P_ENUM, P_GLOBAL, &Globals.security, NULL, enum_security, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 790         {"auth methods", P_LIST, P_GLOBAL, &Globals.AuthMethods, NULL, NULL, FLAG_ADVANCED},
 791         {"encrypt passwords", P_BOOL, P_GLOBAL, &Globals.bEncryptPasswords, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
 792         {"update encrypted", P_BOOL, P_GLOBAL, &Globals.bUpdateEncrypt, NULL, NULL, FLAG_ADVANCED},
 793         {"client schannel", P_ENUM, P_GLOBAL, &Globals.clientSchannel, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
 794         {"server schannel", P_ENUM, P_GLOBAL, &Globals.serverSchannel, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
 795         {"allow trusted domains", P_BOOL, P_GLOBAL, &Globals.bAllowTrustedDomains, NULL, NULL, FLAG_ADVANCED},
 796         {"hosts equiv", P_STRING, P_GLOBAL, &Globals.szHostsEquiv, NULL, NULL, FLAG_ADVANCED},
 797         {"min password length", P_INTEGER, P_GLOBAL, &Globals.min_passwd_length, NULL, NULL, FLAG_ADVANCED},
 798         {"min passwd length", P_INTEGER, P_GLOBAL, &Globals.min_passwd_length, NULL, NULL, FLAG_ADVANCED},
 799         {"map to guest", P_ENUM, P_GLOBAL, &Globals.map_to_guest, NULL, enum_map_to_guest, FLAG_ADVANCED},
 800         {"null passwords", P_BOOL, P_GLOBAL, &Globals.bNullPasswords, NULL, NULL, FLAG_ADVANCED},
 801         {"obey pam restrictions", P_BOOL, P_GLOBAL, &Globals.bObeyPamRestrictions, NULL, NULL, FLAG_ADVANCED},
 802         {"password server", P_STRING, P_GLOBAL, &Globals.szPasswordServer, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
 803         {"smb passwd file", P_STRING, P_GLOBAL, &Globals.szSMBPasswdFile, NULL, NULL, FLAG_ADVANCED},
 804         {"private dir", P_STRING, P_GLOBAL, &Globals.szPrivateDir, NULL, NULL, FLAG_ADVANCED},
 805         {"passdb backend", P_LIST, P_GLOBAL, &Globals.szPassdbBackend, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
 806         {"algorithmic rid base", P_INTEGER, P_GLOBAL, &Globals.AlgorithmicRidBase, NULL, NULL, FLAG_ADVANCED},
 807         {"root directory", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_ADVANCED},
 808         {"root dir", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_HIDE},
 809         {"root", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_HIDE},
 810         {"guest account", P_STRING, P_GLOBAL, &Globals.szGuestaccount, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED},
 811
 812         {"pam password change", P_BOOL, P_GLOBAL, &Globals.bPamPasswordChange, NULL, NULL, FLAG_ADVANCED},
 813         {"passwd program", P_STRING, P_GLOBAL, &Globals.szPasswdProgram, NULL, NULL, FLAG_ADVANCED},
 814         {"passwd chat", P_STRING, P_GLOBAL, &Globals.szPasswdChat, NULL, NULL, FLAG_ADVANCED},
 815         {"passwd chat debug", P_BOOL, P_GLOBAL, &Globals.bPasswdChatDebug, NULL, NULL, FLAG_ADVANCED},
 816         {"passwd chat timeout", P_INTEGER, P_GLOBAL, &Globals.iPasswdChatTimeout, NULL, NULL, FLAG_ADVANCED},
 817         {"check password script", P_STRING, P_GLOBAL, &Globals.szCheckPasswordScript, NULL, NULL, FLAG_ADVANCED},
 818         {"username map", P_STRING, P_GLOBAL, &Globals.szUsernameMap, NULL, NULL, FLAG_ADVANCED},
 819         {"password level", P_INTEGER, P_GLOBAL, &Globals.pwordlevel, NULL, NULL, FLAG_ADVANCED},
 820         {"username level", P_INTEGER, P_GLOBAL, &Globals.unamelevel, NULL, NULL, FLAG_ADVANCED},
 821         {"unix password sync", P_BOOL, P_GLOBAL, &Globals.bUnixPasswdSync, NULL, NULL, FLAG_ADVANCED},
 822         {"restrict anonymous", P_INTEGER, P_GLOBAL, &Globals.restrict_anonymous, NULL, NULL, FLAG_ADVANCED},
 823         {"lanman auth", P_BOOL, P_GLOBAL, &Globals.bLanmanAuth, NULL, NULL, FLAG_ADVANCED},
 824         {"ntlm auth", P_BOOL, P_GLOBAL, &Globals.bNTLMAuth, NULL, NULL, FLAG_ADVANCED},
 825         {"client NTLMv2 auth", P_BOOL, P_GLOBAL, &Globals.bClientNTLMv2Auth, NULL, NULL, FLAG_ADVANCED},
 826         {"client lanman auth", P_BOOL, P_GLOBAL, &Globals.bClientLanManAuth, NULL, NULL, FLAG_ADVANCED},
 827         {"client plaintext auth", P_BOOL, P_GLOBAL, &Globals.bClientPlaintextAuth, NULL, NULL, FLAG_ADVANCED},
 828
 829         {"username", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 830         {"user", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_HIDE},
 831         {"users", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_HIDE},
 832
 833         {"invalid users", P_LIST, P_LOCAL, &sDefault.szInvalidUsers, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 834         {"valid users", P_LIST, P_LOCAL, &sDefault.szValidUsers, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 835         {"admin users", P_LIST, P_LOCAL, &sDefault.szAdminUsers, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 836         {"read list", P_LIST, P_LOCAL, &sDefault.readlist, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 837         {"write list", P_LIST, P_LOCAL, &sDefault.writelist, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 838         {"printer admin", P_LIST, P_LOCAL, &sDefault.printer_admin, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_PRINT},
 839         {"force user", P_STRING, P_LOCAL, &sDefault.force_user, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 840         {"force group", P_STRING, P_LOCAL, &sDefault.force_group, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 841         {"group", P_STRING, P_LOCAL, &sDefault.force_group, NULL, NULL, FLAG_ADVANCED},
 842
 843         {"read only", P_BOOL, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE},
 844         {"write ok", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
 845         {"writeable", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
 846         {"writable", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
 847
 848         {"create mask", P_OCTAL, P_LOCAL, &sDefault.iCreate_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 849         {"create mode", P_OCTAL, P_LOCAL, &sDefault.iCreate_mask, NULL, NULL, FLAG_HIDE},
 850         {"force create mode", P_OCTAL, P_LOCAL, &sDefault.iCreate_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 851         {"security mask", P_OCTAL, P_LOCAL, &sDefault.iSecurity_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 852         {"force security mode", P_OCTAL, P_LOCAL, &sDefault.iSecurity_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 853         {"directory mask", P_OCTAL, P_LOCAL, &sDefault.iDir_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 854         {"directory mode", P_OCTAL, P_LOCAL, &sDefault.iDir_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
 855         {"force directory mode", P_OCTAL, P_LOCAL, &sDefault.iDir_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 856         {"directory security mask", P_OCTAL, P_LOCAL, &sDefault.iDir_Security_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 857         {"force directory security mode", P_OCTAL, P_LOCAL, &sDefault.iDir_Security_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 858         {"force unknown acl user", P_BOOL, P_LOCAL, &sDefault.bForceUnknownAclUser, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 859         {"inherit permissions", P_BOOL, P_LOCAL, &sDefault.bInheritPerms, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 860         {"inherit acls", P_BOOL, P_LOCAL, &sDefault.bInheritACLS, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 861         {"guest only", P_BOOL, P_LOCAL, &sDefault.bGuest_only, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 862         {"only guest", P_BOOL, P_LOCAL, &sDefault.bGuest_only, NULL, NULL, FLAG_HIDE},
 863
 864         {"guest ok", P_BOOL, P_LOCAL, &sDefault.bGuest_ok, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
 865         {"public", P_BOOL, P_LOCAL, &sDefault.bGuest_ok, NULL, NULL, FLAG_HIDE},
 866
 867         {"only user", P_BOOL, P_LOCAL, &sDefault.bOnlyUser, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_DEPRECATED},
 868         {"hosts allow", P_LIST, P_LOCAL, &sDefault.szHostsallow, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
 869         {"allow hosts", P_LIST, P_LOCAL, &sDefault.szHostsallow, NULL, NULL, FLAG_HIDE},
 870         {"hosts deny", P_LIST, P_LOCAL, &sDefault.szHostsdeny, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
 871         {"deny hosts", P_LIST, P_LOCAL, &sDefault.szHostsdeny, NULL, NULL, FLAG_HIDE},
 872         {"preload modules", P_LIST, P_GLOBAL, &Globals.szPreloadModules, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
 873         {"use kerberos keytab", P_BOOL, P_GLOBAL, &Globals.bUseKerberosKeytab, NULL, NULL, FLAG_ADVANCED},
 874
 875         {N_("Logging Options"), P_SEP, P_SEPARATOR},
 876
 877         {"log level", P_STRING, P_GLOBAL, &Globals.szLogLevel, handle_debug_list, NULL, FLAG_ADVANCED},
 878         {"debuglevel", P_STRING, P_GLOBAL, &Globals.szLogLevel, handle_debug_list, NULL, FLAG_HIDE},
 879         {"syslog", P_INTEGER, P_GLOBAL, &Globals.syslog, NULL, NULL, FLAG_ADVANCED},
 880         {"syslog only", P_BOOL, P_GLOBAL, &Globals.bSyslogOnly, NULL, NULL, FLAG_ADVANCED},
 881         {"log file", P_STRING, P_GLOBAL, &Globals.szLogFile, NULL, NULL, FLAG_ADVANCED},
 882
 883         {"max log size", P_INTEGER, P_GLOBAL, &Globals.max_log_size, NULL, NULL, FLAG_ADVANCED},
 884         {"debug timestamp", P_BOOL, P_GLOBAL, &Globals.bTimestampLogs, NULL, NULL, FLAG_ADVANCED},
 885         {"timestamp logs", P_BOOL, P_GLOBAL, &Globals.bTimestampLogs, NULL, NULL, FLAG_ADVANCED},
 886         {"debug hires timestamp", P_BOOL, P_GLOBAL, &Globals.bDebugHiresTimestamp, NULL, NULL, FLAG_ADVANCED},
 887         {"debug pid", P_BOOL, P_GLOBAL, &Globals.bDebugPid, NULL, NULL, FLAG_ADVANCED},
 888         {"debug uid", P_BOOL, P_GLOBAL, &Globals.bDebugUid, NULL, NULL, FLAG_ADVANCED},
 889
 890         {N_("Protocol Options"), P_SEP, P_SEPARATOR},
 891
 892         {"smb ports", P_STRING, P_GLOBAL, &Globals.smb_ports, NULL, NULL, FLAG_ADVANCED},
 893         {"large readwrite", P_BOOL, P_GLOBAL, &Globals.bLargeReadwrite, NULL, NULL, FLAG_ADVANCED},
 894         {"max protocol", P_ENUM, P_GLOBAL, &Globals.maxprotocol, NULL, enum_protocol, FLAG_ADVANCED},
 895         {"protocol", P_ENUM, P_GLOBAL, &Globals.maxprotocol, NULL, enum_protocol, FLAG_ADVANCED},
 896         {"min protocol", P_ENUM, P_GLOBAL, &Globals.minprotocol, NULL, enum_protocol, FLAG_ADVANCED},
 897         {"read bmpx", P_BOOL, P_GLOBAL, &Globals.bReadbmpx, NULL, NULL, FLAG_ADVANCED},
 898         {"read raw", P_BOOL, P_GLOBAL, &Globals.bReadRaw, NULL, NULL, FLAG_ADVANCED},
 899         {"write raw", P_BOOL, P_GLOBAL, &Globals.bWriteRaw, NULL, NULL, FLAG_ADVANCED},
 900         {"disable netbios", P_BOOL, P_GLOBAL, &Globals.bDisableNetbios, NULL, NULL, FLAG_ADVANCED},
 901
 902         {"acl compatibility", P_STRING, P_GLOBAL, &Globals.szAclCompat, handle_acl_compatibility,  NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 903         { "defer sharing violations", P_BOOL, P_GLOBAL, &Globals.bDeferSharingViolations, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
 904         {"ea support", P_BOOL, P_LOCAL, &sDefault.bEASupport, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 905         {"nt acl support", P_BOOL, P_LOCAL, &sDefault.bNTAclSupport, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 906         {"nt pipe support", P_BOOL, P_GLOBAL, &Globals.bNTPipeSupport, NULL, NULL, FLAG_ADVANCED},
 907         {"nt status support", P_BOOL, P_GLOBAL, &Globals.bNTStatusSupport, NULL, NULL, FLAG_ADVANCED},
 908         {"profile acls", P_BOOL, P_LOCAL, &sDefault.bProfileAcls, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
 909
 910         {"announce version", P_STRING, P_GLOBAL, &Globals.szAnnounceVersion, NULL, NULL, FLAG_ADVANCED},
 911         {"announce as", P_ENUM, P_GLOBAL, &Globals.announce_as, NULL, enum_announce_as,  FLAG_ADVANCED},
 912         {"map acl inherit", P_BOOL, P_LOCAL, &sDefault.bMap_acl_inherit, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 913         {"afs share", P_BOOL, P_LOCAL, &sDefault.bAfs_Share, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 914         {"max mux", P_INTEGER, P_GLOBAL, &Globals.max_mux, NULL, NULL, FLAG_ADVANCED},
 915         {"max xmit", P_INTEGER, P_GLOBAL, &Globals.max_xmit, NULL, NULL, FLAG_ADVANCED},
 916
 917         {"name resolve order", P_STRING, P_GLOBAL, &Globals.szNameResolveOrder, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
 918         {"max ttl", P_INTEGER, P_GLOBAL, &Globals.max_ttl, NULL, NULL, FLAG_ADVANCED},
 919         {"max wins ttl", P_INTEGER, P_GLOBAL, &Globals.max_wins_ttl, NULL, NULL, FLAG_ADVANCED},
 920         {"min wins ttl", P_INTEGER, P_GLOBAL, &Globals.min_wins_ttl, NULL, NULL, FLAG_ADVANCED},
 921         {"time server", P_BOOL, P_GLOBAL, &Globals.bTimeServer, NULL, NULL, FLAG_ADVANCED},
 922         {"unix extensions", P_BOOL, P_GLOBAL, &Globals.bUnixExtensions, NULL, NULL, FLAG_ADVANCED},
 923         {"use spnego", P_BOOL, P_GLOBAL, &Globals.bUseSpnego, NULL, NULL, FLAG_ADVANCED},
 924         {"client signing", P_ENUM, P_GLOBAL, &Globals.client_signing, NULL, enum_smb_signing_vals, FLAG_ADVANCED},
 925         {"server signing", P_ENUM, P_GLOBAL, &Globals.server_signing, NULL, enum_smb_signing_vals, FLAG_ADVANCED},
 926         {"client use spnego", P_BOOL, P_GLOBAL, &Globals.bClientUseSpnego, NULL, NULL, FLAG_ADVANCED},
 927
 928         {N_("Tuning Options"), P_SEP, P_SEPARATOR},
 929
 930         {"block size", P_INTEGER, P_LOCAL, &sDefault.iBlock_size, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 931         {"change notify timeout", P_INTEGER, P_GLOBAL, &Globals.change_notify_timeout, NULL, NULL, FLAG_ADVANCED},
 932         {"deadtime", P_INTEGER, P_GLOBAL, &Globals.deadtime, NULL, NULL, FLAG_ADVANCED},
 933         {"getwd cache", P_BOOL, P_GLOBAL, &use_getwd_cache, NULL, NULL, FLAG_ADVANCED},
 934         {"keepalive", P_INTEGER, P_GLOBAL, &keepalive, NULL, NULL, FLAG_ADVANCED},
 935         {"kernel change notify", P_BOOL, P_GLOBAL, &Globals.bKernelChangeNotify, NULL, NULL, FLAG_ADVANCED},
 936
 937         {"lpq cache time", P_INTEGER, P_GLOBAL, &Globals.lpqcachetime, NULL, NULL, FLAG_ADVANCED},
 938         {"max smbd processes", P_INTEGER, P_GLOBAL, &Globals.iMaxSmbdProcesses, NULL, NULL, FLAG_ADVANCED},
 939         {"max connections", P_INTEGER, P_LOCAL, &sDefault.iMaxConnections, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 940         {"paranoid server security", P_BOOL, P_GLOBAL, &Globals.paranoid_server_security, NULL, NULL, FLAG_ADVANCED},
 941         {"max disk size", P_INTEGER, P_GLOBAL, &Globals.maxdisksize, NULL, NULL, FLAG_ADVANCED},
 942         {"max open files", P_INTEGER, P_GLOBAL, &Globals.max_open_files, NULL, NULL, FLAG_ADVANCED},
 943         {"min print space", P_INTEGER, P_LOCAL, &sDefault.iMinPrintSpace, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 944
 945         {"socket options", P_GSTRING, P_GLOBAL, user_socket_options, NULL, NULL, FLAG_ADVANCED},
 946         {"strict allocate", P_BOOL, P_LOCAL, &sDefault.bStrictAllocate, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 947         {"strict sync", P_BOOL, P_LOCAL, &sDefault.bStrictSync, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 948         {"sync always", P_BOOL, P_LOCAL, &sDefault.bSyncAlways, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 949         {"use mmap", P_BOOL, P_GLOBAL, &Globals.bUseMmap, NULL, NULL, FLAG_ADVANCED},
 950         {"use sendfile", P_BOOL, P_LOCAL, &sDefault.bUseSendfile, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 951         {"hostname lookups", P_BOOL, P_GLOBAL, &Globals.bHostnameLookups, NULL, NULL, FLAG_ADVANCED},
 952         {"write cache size", P_INTEGER, P_LOCAL, &sDefault.iWriteCacheSize, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
 953
 954         {"name cache timeout", P_INTEGER, P_GLOBAL, &Globals.name_cache_timeout, NULL, NULL, FLAG_ADVANCED},
 955
 956         {N_("Printing Options"), P_SEP, P_SEPARATOR},
 957
 958         {"max reported print jobs", P_INTEGER, P_LOCAL, &sDefault.iMaxReportedPrintJobs, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 959         {"max print jobs", P_INTEGER, P_LOCAL, &sDefault.iMaxPrintJobs, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 960         {"load printers", P_BOOL, P_GLOBAL, &Globals.bLoadPrinters, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 961         {"printcap cache time", P_INTEGER, P_GLOBAL, &Globals.PrintcapCacheTime, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 962         {"printcap name", P_STRING, P_GLOBAL, &Globals.szPrintcapname, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 963         {"printcap", P_STRING, P_GLOBAL, &Globals.szPrintcapname, NULL, NULL, FLAG_HIDE},
 964         {"printable", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 965         {"print ok", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_HIDE},
 966         {"printing", P_ENUM, P_LOCAL, &sDefault.iPrinting, handle_printing, enum_printing, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 967         {"cups options", P_STRING, P_LOCAL, &sDefault.szCupsOptions, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 968         {"cups server", P_STRING, P_GLOBAL, &Globals.szCupsServer, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 969         {"print command", P_STRING, P_LOCAL, &sDefault.szPrintcommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 970         {"disable spoolss", P_BOOL, P_GLOBAL, &Globals.bDisableSpoolss, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 971         {"lpq command", P_STRING, P_LOCAL, &sDefault.szLpqcommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 972         {"lprm command", P_STRING, P_LOCAL, &sDefault.szLprmcommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 973         {"lppause command", P_STRING, P_LOCAL, &sDefault.szLppausecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 974         {"lpresume command", P_STRING, P_LOCAL, &sDefault.szLpresumecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 975         {"queuepause command", P_STRING, P_LOCAL, &sDefault.szQueuepausecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 976         {"queueresume command", P_STRING, P_LOCAL, &sDefault.szQueueresumecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
 977
 978         {"enumports command", P_STRING, P_GLOBAL, &Globals.szEnumPortsCommand, NULL, NULL, FLAG_ADVANCED},
 979         {"addprinter command", P_STRING, P_GLOBAL, &Globals.szAddPrinterCommand, NULL, NULL, FLAG_ADVANCED},
 980         {"deleteprinter command", P_STRING, P_GLOBAL, &Globals.szDeletePrinterCommand, NULL, NULL, FLAG_ADVANCED},
 981         {"show add printer wizard", P_BOOL, P_GLOBAL, &Globals.bMsAddPrinterWizard, NULL, NULL, FLAG_ADVANCED},
 982         {"os2 driver map", P_STRING, P_GLOBAL, &Globals.szOs2DriverMap, NULL, NULL, FLAG_ADVANCED},
 983
 984         {"printer name", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 985         {"printer", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_HIDE},
 986         {"use client driver", P_BOOL, P_LOCAL, &sDefault.bUseClientDriver, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 987         {"default devmode", P_BOOL, P_LOCAL, &sDefault.bDefaultDevmode, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 988         {"force printername", P_BOOL, P_LOCAL, &sDefault.bForcePrintername, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
 989
 990         {N_("Filename Handling"), P_SEP, P_SEPARATOR},
 991         {"mangling method", P_STRING, P_GLOBAL, &Globals.szManglingMethod, NULL, NULL, FLAG_ADVANCED},
 992         {"mangle prefix", P_INTEGER, P_GLOBAL, &Globals.mangle_prefix, NULL, NULL, FLAG_ADVANCED},
 993
 994         {"default case", P_ENUM, P_LOCAL, &sDefault.iDefaultCase, NULL, enum_case, FLAG_ADVANCED | FLAG_SHARE},
 995         {"case sensitive", P_ENUM, P_LOCAL, &sDefault.iCaseSensitive, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 996         {"casesignames", P_ENUM, P_LOCAL, &sDefault.iCaseSensitive, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL | FLAG_HIDE},
 997         {"preserve case", P_BOOL, P_LOCAL, &sDefault.bCasePreserve, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 998         {"short preserve case", P_BOOL, P_LOCAL, &sDefault.bShortCasePreserve, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
 999         {"mangling char", P_CHAR, P_LOCAL, &sDefault.magic_char, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1000         {"hide dot files", P_BOOL, P_LOCAL, &sDefault.bHideDotFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1001         {"hide special files", P_BOOL, P_LOCAL, &sDefault.bHideSpecialFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1002         {"hide unreadable", P_BOOL, P_LOCAL, &sDefault.bHideUnReadable, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1003         {"hide unwriteable files", P_BOOL, P_LOCAL, &sDefault.bHideUnWriteableFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1004         {"delete veto files", P_BOOL, P_LOCAL, &sDefault.bDeleteVetoFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1005         {"veto files", P_STRING, P_LOCAL, &sDefault.szVetoFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL },
1006         {"hide files", P_STRING, P_LOCAL, &sDefault.szHideFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL },
1007         {"veto oplock files", P_STRING, P_LOCAL, &sDefault.szVetoOplockFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL },
1008         {"map system", P_BOOL, P_LOCAL, &sDefault.bMap_system, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1009         {"map hidden", P_BOOL, P_LOCAL, &sDefault.bMap_hidden, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1010         {"map archive", P_BOOL, P_LOCAL, &sDefault.bMap_archive, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1011         {"mangled names", P_BOOL, P_LOCAL, &sDefault.bMangledNames, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1012         {"mangled map", P_STRING, P_LOCAL, &sDefault.szMangledMap, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL | FLAG_DEPRECATED },
1013         {"stat cache", P_BOOL, P_GLOBAL, &Globals.bStatCache, NULL, NULL, FLAG_ADVANCED},
1014         {"store dos attributes", P_BOOL, P_LOCAL, &sDefault.bStoreDosAttributes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1015
1016         {N_("Domain Options"), P_SEP, P_SEPARATOR},
1017
1018         {"machine password timeout", P_INTEGER, P_GLOBAL, &Globals.machine_password_timeout, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
1019
1020         {N_("Logon Options"), P_SEP, P_SEPARATOR},
1021
1022         {"add user script", P_STRING, P_GLOBAL, &Globals.szAddUserScript, NULL, NULL, FLAG_ADVANCED},
1023         {"delete user script", P_STRING, P_GLOBAL, &Globals.szDelUserScript, NULL, NULL, FLAG_ADVANCED},
1024         {"add group script", P_STRING, P_GLOBAL, &Globals.szAddGroupScript, NULL, NULL, FLAG_ADVANCED},
1025         {"delete group script", P_STRING, P_GLOBAL, &Globals.szDelGroupScript, NULL, NULL, FLAG_ADVANCED},
1026         {"add user to group script", P_STRING, P_GLOBAL, &Globals.szAddUserToGroupScript, NULL, NULL, FLAG_ADVANCED},
1027         {"delete user from group script", P_STRING, P_GLOBAL, &Globals.szDelUserFromGroupScript, NULL, NULL, FLAG_ADVANCED},
1028         {"set primary group script", P_STRING, P_GLOBAL, &Globals.szSetPrimaryGroupScript, NULL, NULL, FLAG_ADVANCED},
1029         {"add machine script", P_STRING, P_GLOBAL, &Globals.szAddMachineScript, NULL, NULL, FLAG_ADVANCED},
1030         {"shutdown script", P_STRING, P_GLOBAL, &Globals.szShutdownScript, NULL, NULL, FLAG_ADVANCED},
1031         {"abort shutdown script", P_STRING, P_GLOBAL, &Globals.szAbortShutdownScript, NULL, NULL, FLAG_ADVANCED},
1032
1033         {"logon script", P_STRING, P_GLOBAL, &Globals.szLogonScript, NULL, NULL, FLAG_ADVANCED},
1034         {"logon path", P_STRING, P_GLOBAL, &Globals.szLogonPath, NULL, NULL, FLAG_ADVANCED},
1035         {"logon drive", P_STRING, P_GLOBAL, &Globals.szLogonDrive, NULL, NULL, FLAG_ADVANCED},
1036         {"logon home", P_STRING, P_GLOBAL, &Globals.szLogonHome, NULL, NULL, FLAG_ADVANCED},
1037         {"domain logons", P_BOOL, P_GLOBAL, &Globals.bDomainLogons, NULL, NULL, FLAG_ADVANCED},
1038
1039         {N_("Browse Options"), P_SEP, P_SEPARATOR},
1040
1041         {"os level", P_INTEGER, P_GLOBAL, &Globals.os_level, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED},
1042         {"lm announce", P_ENUM, P_GLOBAL, &Globals.lm_announce, NULL, enum_bool_auto, FLAG_ADVANCED},
1043         {"lm interval", P_INTEGER, P_GLOBAL, &Globals.lm_interval, NULL, NULL, FLAG_ADVANCED},
1044         {"preferred master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
1045         {"prefered master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_HIDE},
1046         {"local master", P_BOOL, P_GLOBAL, &Globals.bLocalMaster, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED},
1047         {"domain master", P_ENUM, P_GLOBAL, &Globals.bDomainMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
1048         {"browse list", P_BOOL, P_GLOBAL, &Globals.bBrowseList, NULL, NULL, FLAG_ADVANCED},
1049         {"browseable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1050         {"browsable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_HIDE},
1051         {"enhanced browsing", P_BOOL, P_GLOBAL, &Globals.enhanced_browsing, NULL, NULL, FLAG_ADVANCED},
1052
1053         {N_("WINS Options"), P_SEP, P_SEPARATOR},
1054
1055         {"dns proxy", P_BOOL, P_GLOBAL, &Globals.bDNSproxy, NULL, NULL, FLAG_ADVANCED},
1056         {"wins proxy", P_BOOL, P_GLOBAL, &Globals.bWINSproxy, NULL, NULL, FLAG_ADVANCED},
1057
1058         {"wins server", P_LIST, P_GLOBAL, &Globals.szWINSservers, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
1059         {"wins support", P_BOOL, P_GLOBAL, &Globals.bWINSsupport, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
1060         {"wins hook", P_STRING, P_GLOBAL, &Globals.szWINSHook, NULL, NULL, FLAG_ADVANCED},
1061         {"wins partners", P_STRING, P_GLOBAL, &Globals.szWINSPartners, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
1062
1063         {N_("Locking Options"), P_SEP, P_SEPARATOR},
1064
1065         {"blocking locks", P_BOOL, P_LOCAL, &sDefault.bBlockingLocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1066         {"csc policy", P_ENUM, P_LOCAL, &sDefault.iCSCPolicy, NULL, enum_csc_policy, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1067         {"fake oplocks", P_BOOL, P_LOCAL, &sDefault.bFakeOplocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1068         {"kernel oplocks", P_BOOL, P_GLOBAL, &Globals.bKernelOplocks, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1069         {"locking", P_BOOL, P_LOCAL, &sDefault.bLocking, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1070         {"lock spin count", P_INTEGER, P_GLOBAL, &Globals.iLockSpinCount, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1071         {"lock spin time", P_INTEGER, P_GLOBAL, &Globals.iLockSpinTime, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1072
1073         {"oplocks", P_BOOL, P_LOCAL, &sDefault.bOpLocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1074         {"level2 oplocks", P_BOOL, P_LOCAL, &sDefault.bLevel2OpLocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1075         {"oplock break wait time", P_INTEGER, P_GLOBAL, &Globals.oplock_break_wait_time, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1076         {"oplock contention limit", P_INTEGER, P_LOCAL, &sDefault.iOplockContentionLimit, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1077         {"posix locking", P_BOOL, P_LOCAL, &sDefault.bPosixLocking, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1078         {"strict locking", P_ENUM, P_LOCAL, &sDefault.iStrictLocking, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1079         {"share modes", P_BOOL, P_LOCAL,  &sDefault.bShareModes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1080
1081         {N_("Ldap Options"), P_SEP, P_SEPARATOR},
1082
1083 #ifdef WITH_LDAP_SAMCONFIG
1084         {"ldap server", P_STRING, P_GLOBAL, &Globals.szLdapServer, NULL, NULL, FLAG_ADVANCED},
1085         {"ldap port", P_INTEGER, P_GLOBAL, &Globals.ldap_port, NULL, NULL, FLAG_ADVANCED},
1086 #endif
1087         {"ldap admin dn", P_STRING, P_GLOBAL, &Globals.szLdapAdminDn, NULL, NULL, FLAG_ADVANCED},
1088         {"ldap delete dn", P_BOOL, P_GLOBAL, &Globals.ldap_delete_dn, NULL, NULL, FLAG_ADVANCED},
1089         {"ldap filter", P_STRING, P_GLOBAL, &Globals.szLdapFilter, NULL, NULL, FLAG_ADVANCED},
1090         {"ldap group suffix", P_STRING, P_GLOBAL, &Globals.szLdapGroupSuffix, NULL, NULL, FLAG_ADVANCED},
1091         {"ldap idmap suffix", P_STRING, P_GLOBAL, &Globals.szLdapIdmapSuffix, NULL, NULL, FLAG_ADVANCED},
1092         {"ldap machine suffix", P_STRING, P_GLOBAL, &Globals.szLdapMachineSuffix, NULL, NULL, FLAG_ADVANCED},
1093         {"ldap passwd sync", P_ENUM, P_GLOBAL, &Globals.ldap_passwd_sync, NULL, enum_ldap_passwd_sync, FLAG_ADVANCED},
1094         {"ldap replication sleep", P_INTEGER, P_GLOBAL, &Globals.ldap_replication_sleep, NULL, NULL, FLAG_ADVANCED},
1095         {"ldap suffix", P_STRING, P_GLOBAL, &Globals.szLdapSuffix, NULL, NULL, FLAG_ADVANCED},
1096         {"ldap ssl", P_ENUM, P_GLOBAL, &Globals.ldap_ssl, NULL, enum_ldap_ssl, FLAG_ADVANCED},
1097         {"ldap timeout", P_INTEGER, P_GLOBAL, &Globals.ldap_timeout, NULL, NULL, FLAG_ADVANCED},
1098         {"ldap user suffix", P_STRING, P_GLOBAL, &Globals.szLdapUserSuffix, NULL, NULL, FLAG_ADVANCED},
1099
1100         {N_("Miscellaneous Options"), P_SEP, P_SEPARATOR},
1101         {"add share command", P_STRING, P_GLOBAL, &Globals.szAddShareCommand, NULL, NULL, FLAG_ADVANCED},
1102         {"change share command", P_STRING, P_GLOBAL, &Globals.szChangeShareCommand, NULL, NULL, FLAG_ADVANCED},
1103         {"delete share command", P_STRING, P_GLOBAL, &Globals.szDeleteShareCommand, NULL, NULL, FLAG_ADVANCED},
1104
1105         {"config file", P_STRING, P_GLOBAL, &Globals.szConfigFile, NULL, NULL, FLAG_HIDE},
1106         {"preload", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED},
1107         {"auto services", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED},
1108         {"lock directory", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_ADVANCED},
1109         {"lock dir", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_HIDE},
1110         {"pid directory", P_STRING, P_GLOBAL, &Globals.szPidDir, NULL, NULL, FLAG_ADVANCED},
1111 #ifdef WITH_UTMP
1112         {"utmp directory", P_STRING, P_GLOBAL, &Globals.szUtmpDir, NULL, NULL, FLAG_ADVANCED},
1113         {"wtmp directory", P_STRING, P_GLOBAL, &Globals.szWtmpDir, NULL, NULL, FLAG_ADVANCED},
1114         {"utmp", P_BOOL, P_GLOBAL, &Globals.bUtmp, NULL, NULL, FLAG_ADVANCED},
1115 #endif
1116
1117         {"default service", P_STRING, P_GLOBAL, &Globals.szDefaultService, NULL, NULL, FLAG_ADVANCED},
1118         {"default", P_STRING, P_GLOBAL, &Globals.szDefaultService, NULL, NULL, FLAG_ADVANCED},
1119         {"message command", P_STRING, P_GLOBAL, &Globals.szMsgCommand, NULL, NULL, FLAG_ADVANCED},
1120         {"dfree command", P_STRING, P_GLOBAL, &Globals.szDfree, NULL, NULL, FLAG_ADVANCED},
1121         {"get quota command", P_STRING, P_GLOBAL, &Globals.szGetQuota, NULL, NULL, FLAG_ADVANCED},
1122         {"set quota command", P_STRING, P_GLOBAL, &Globals.szSetQuota, NULL, NULL, FLAG_ADVANCED},
1123         {"remote announce", P_STRING, P_GLOBAL, &Globals.szRemoteAnnounce, NULL, NULL, FLAG_ADVANCED},
1124         {"remote browse sync", P_STRING, P_GLOBAL, &Globals.szRemoteBrowseSync, NULL, NULL, FLAG_ADVANCED},
1125         {"socket address", P_STRING, P_GLOBAL, &Globals.szSocketAddress, NULL, NULL, FLAG_ADVANCED},
1126         {"homedir map", P_STRING, P_GLOBAL, &Globals.szNISHomeMapName, NULL, NULL, FLAG_ADVANCED},
1127         {"afs username map", P_STRING, P_GLOBAL, &Globals.szAfsUsernameMap, NULL, NULL, FLAG_ADVANCED},
1128         {"time offset", P_INTEGER, P_GLOBAL, &extra_time_offset, NULL, NULL, FLAG_ADVANCED},
1129         {"NIS homedir", P_BOOL, P_GLOBAL, &Globals.bNISHomeMap, NULL, NULL, FLAG_ADVANCED},
1130         {"-valid", P_BOOL, P_LOCAL, &sDefault.valid, NULL, NULL, FLAG_HIDE},
1131
1132         {"copy", P_STRING, P_LOCAL, &sDefault.szCopy, handle_copy, NULL, FLAG_HIDE},
1133         {"include", P_STRING, P_LOCAL, &sDefault.szInclude, handle_include, NULL, FLAG_HIDE},
1134         {"preexec", P_STRING, P_LOCAL, &sDefault.szPreExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1135         {"exec", P_STRING, P_LOCAL, &sDefault.szPreExec, NULL, NULL, FLAG_ADVANCED},
1136
1137         {"preexec close", P_BOOL, P_LOCAL, &sDefault.bPreexecClose, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1138         {"postexec", P_STRING, P_LOCAL, &sDefault.szPostExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1139         {"root preexec", P_STRING, P_LOCAL, &sDefault.szRootPreExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1140         {"root preexec close", P_BOOL, P_LOCAL, &sDefault.bRootpreexecClose, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1141         {"root postexec", P_STRING, P_LOCAL, &sDefault.szRootPostExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1142         {"available", P_BOOL, P_LOCAL, &sDefault.bAvailable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1143         {"volume", P_STRING, P_LOCAL, &sDefault.volume, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE },
1144         {"fstype", P_STRING, P_LOCAL, &sDefault.fstype, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1145         {"set directory", P_BOOLREV, P_LOCAL, &sDefault.bNo_set_dir, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1146         {"wide links", P_BOOL, P_LOCAL, &sDefault.bWidelinks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1147         {"follow symlinks", P_BOOL, P_LOCAL, &sDefault.bSymlinks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1148         {"dont descend", P_STRING, P_LOCAL, &sDefault.szDontdescend, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1149         {"magic script", P_STRING, P_LOCAL, &sDefault.szMagicScript, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1150         {"magic output", P_STRING, P_LOCAL, &sDefault.szMagicOutput, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1151         {"delete readonly", P_BOOL, P_LOCAL, &sDefault.bDeleteReadonly, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1152         {"dos filemode", P_BOOL, P_LOCAL, &sDefault.bDosFilemode, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1153         {"dos filetimes", P_BOOL, P_LOCAL, &sDefault.bDosFiletimes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1154         {"dos filetime resolution", P_BOOL, P_LOCAL, &sDefault.bDosFiletimeResolution, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1155
1156         {"fake directory create times", P_BOOL, P_LOCAL, &sDefault.bFakeDirCreateTimes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1157         {"panic action", P_STRING, P_GLOBAL, &Globals.szPanicAction, NULL, NULL, FLAG_ADVANCED},
1158
1159         {N_("VFS module options"), P_SEP, P_SEPARATOR},
1160
1161         {"vfs objects", P_LIST, P_LOCAL, &sDefault.szVfsObjects, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1162         {"vfs object", P_LIST, P_LOCAL, &sDefault.szVfsObjects, NULL, NULL, FLAG_HIDE},
1163
1164
1165         {"msdfs root", P_BOOL, P_LOCAL, &sDefault.bMSDfsRoot, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1166         {"msdfs proxy", P_STRING, P_LOCAL, &sDefault.szMSDfsProxy, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1167         {"host msdfs", P_BOOL, P_GLOBAL, &Globals.bHostMSDfs, NULL, NULL, FLAG_ADVANCED},
1168
1169         {N_("Winbind options"), P_SEP, P_SEPARATOR},
1170
1171         {"enable rid algorithm", P_BOOL, P_GLOBAL, &Globals.bEnableRidAlgorithm, NULL, NULL, FLAG_DEPRECATED},
1172         {"idmap backend", P_LIST, P_GLOBAL, &Globals.szIdmapBackend, NULL, NULL, FLAG_ADVANCED},
1173         {"idmap uid", P_STRING, P_GLOBAL, &Globals.szIdmapUID, handle_idmap_uid, NULL, FLAG_ADVANCED},
1174         {"winbind uid", P_STRING, P_GLOBAL, &Globals.szIdmapUID, handle_idmap_uid, NULL, FLAG_HIDE},
1175         {"idmap gid", P_STRING, P_GLOBAL, &Globals.szIdmapGID, handle_idmap_gid, NULL, FLAG_ADVANCED},
1176         {"winbind gid", P_STRING, P_GLOBAL, &Globals.szIdmapGID, handle_idmap_gid, NULL, FLAG_HIDE},
1177         {"template primary group", P_STRING, P_GLOBAL, &Globals.szTemplatePrimaryGroup, NULL, NULL, FLAG_ADVANCED},
1178         {"template homedir", P_STRING, P_GLOBAL, &Globals.szTemplateHomedir, NULL, NULL, FLAG_ADVANCED},
1179         {"template shell", P_STRING, P_GLOBAL, &Globals.szTemplateShell, NULL, NULL, FLAG_ADVANCED},
1180         {"winbind separator", P_STRING, P_GLOBAL, &Globals.szWinbindSeparator, NULL, NULL, FLAG_ADVANCED},
1181         {"winbind cache time", P_INTEGER, P_GLOBAL, &Globals.winbind_cache_time, NULL, NULL, FLAG_ADVANCED},
1182         {"winbind enable local accounts", P_BOOL, P_GLOBAL, &Globals.bWinbindEnableLocalAccounts, NULL, NULL, FLAG_ADVANCED},
1183         {"winbind enum users", P_BOOL, P_GLOBAL, &Globals.bWinbindEnumUsers, NULL, NULL, FLAG_ADVANCED},
1184         {"winbind enum groups", P_BOOL, P_GLOBAL, &Globals.bWinbindEnumGroups, NULL, NULL, FLAG_ADVANCED},
1185         {"winbind use default domain", P_BOOL, P_GLOBAL, &Globals.bWinbindUseDefaultDomain, NULL, NULL, FLAG_ADVANCED},
1186         {"winbind trusted domains only", P_BOOL, P_GLOBAL, &Globals.bWinbindTrustedDomainsOnly, NULL, NULL, FLAG_ADVANCED},
1187         {"winbind nested groups", P_BOOL, P_GLOBAL, &Globals.bWinbindNestedGroups, NULL, NULL, FLAG_ADVANCED},
1188
1189         {NULL,  P_BOOL,  P_NONE,  NULL,  NULL,  NULL,  0}
1190 };
1191
1192 /***************************************************************************
1193  Initialise the sDefault parameter structure for the printer values.
1194 ***************************************************************************/
1195
1196 static void init_printer_values(service *pService)
1197 {
1198         /* choose defaults depending on the type of printing */
1199         switch (pService->iPrinting) {
1200                 case PRINT_BSD:
1201                 case PRINT_AIX:
1202                 case PRINT_LPRNT:
1203                 case PRINT_LPROS2:
1204                         string_set(&pService->szLpqcommand, "lpq -P'%p'");
1205                         string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
1206                         string_set(&pService->szPrintcommand, "lpr -r -P'%p' %s");
1207                         break;
1208
1209                 case PRINT_LPRNG:
1210                 case PRINT_PLP:
1211                         string_set(&pService->szLpqcommand, "lpq -P'%p'");
1212                         string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
1213                         string_set(&pService->szPrintcommand, "lpr -r -P'%p' %s");
1214                         string_set(&pService->szQueuepausecommand, "lpc stop '%p'");
1215                         string_set(&pService->szQueueresumecommand, "lpc start '%p'");
1216                         string_set(&pService->szLppausecommand, "lpc hold '%p' %j");
1217                         string_set(&pService->szLpresumecommand, "lpc release '%p' %j");
1218                         break;
1219
1220                 case PRINT_CUPS:
1221 #ifdef HAVE_CUPS
1222                         string_set(&pService->szLpqcommand, "");
1223                         string_set(&pService->szLprmcommand, "");
1224                         string_set(&pService->szPrintcommand, "");
1225                         string_set(&pService->szLppausecommand, "");
1226                         string_set(&pService->szLpresumecommand, "");
1227                         string_set(&pService->szQueuepausecommand, "");
1228                         string_set(&pService->szQueueresumecommand, "");
1229 #else
1230                         string_set(&pService->szLpqcommand, "/usr/bin/lpstat -o '%p'");
1231                         string_set(&pService->szLprmcommand, "/usr/bin/cancel '%p-%j'");
1232                         string_set(&pService->szPrintcommand, "/usr/bin/lp -d '%p' %s; rm %s");
1233                         string_set(&pService->szLppausecommand, "lp -i '%p-%j' -H hold");
1234                         string_set(&pService->szLpresumecommand, "lp -i '%p-%j' -H resume");
1235                         string_set(&pService->szQueuepausecommand, "/usr/bin/disable '%p'");
1236                         string_set(&pService->szQueueresumecommand, "/usr/bin/enable '%p'");
1237 #endif /* HAVE_CUPS */
1238                         break;
1239
1240                 case PRINT_SYSV:
1241                 case PRINT_HPUX:
1242                         string_set(&pService->szLpqcommand, "lpstat -o%p");
1243                         string_set(&pService->szLprmcommand, "cancel %p-%j");
1244                         string_set(&pService->szPrintcommand, "lp -c -d%p %s; rm %s");
1245                         string_set(&pService->szQueuepausecommand, "disable %p");
1246                         string_set(&pService->szQueueresumecommand, "enable %p");
1247 #ifndef HPUX
1248                         string_set(&pService->szLppausecommand, "lp -i %p-%j -H hold");
1249                         string_set(&pService->szLpresumecommand, "lp -i %p-%j -H resume");
1250 #endif /* HPUX */
1251                         break;
1252
1253                 case PRINT_QNX:
1254                         string_set(&pService->szLpqcommand, "lpq -P%p");
1255                         string_set(&pService->szLprmcommand, "lprm -P%p %j");
1256                         string_set(&pService->szPrintcommand, "lp -r -P%p %s");
1257                         break;
1258
1259 #ifdef DEVELOPER
1260         case PRINT_TEST:
1261         case PRINT_VLP:
1262                 string_set(&pService->szPrintcommand, "vlp print %p %s");
1263                 string_set(&pService->szLpqcommand, "vlp lpq %p");
1264                 string_set(&pService->szLprmcommand, "vlp lprm %p %j");
1265                 string_set(&pService->szLppausecommand, "vlp lppause %p %j");
1266                 string_set(&pService->szLpresumecommand, "vlp lpresum %p %j");
1267                 string_set(&pService->szQueuepausecommand, "vlp queuepause %p");
1268                 string_set(&pService->szQueueresumecommand, "vlp queueresume %p");
1269                 break;
1270 #endif /* DEVELOPER */
1271
1272         }
1273 }
1274
1275 /***************************************************************************
1276  Initialise the global parameter structure.
1277 ***************************************************************************/
1278
1279 static void init_globals(void)
1280 {
1281         static BOOL done_init = False;
1282         pstring s;
1283
1284         if (!done_init) {
1285                 int i;
1286
1287                 /* The logfile can be set before this is invoked. Free it if so. */
1288                 if (Globals.szLogFile != NULL) {
1289                         string_free(&Globals.szLogFile);
1290                         Globals.szLogFile = NULL;
1291                 }
1292
1293                 memset((void *)&Globals, '\0', sizeof(Globals));
1294
1295                 for (i = 0; parm_table[i].label; i++)
1296                         if ((parm_table[i].type == P_STRING ||
1297                              parm_table[i].type == P_USTRING) &&
1298                             parm_table[i].ptr)
1299                                 string_set(parm_table[i].ptr, "");
1300
1301                 string_set(&sDefault.fstype, FSTYPE_STRING);
1302
1303                 init_printer_values(&sDefault);
1304
1305                 done_init = True;
1306         }
1307
1308
1309         DEBUG(3, ("Initialising global parameters\n"));
1310
1311         string_set(&Globals.szSMBPasswdFile, dyn_SMB_PASSWD_FILE);
1312         string_set(&Globals.szPrivateDir, dyn_PRIVATE_DIR);
1313
1314         /* use the new 'hash2' method by default, with a prefix of 1 */
1315         string_set(&Globals.szManglingMethod, "hash2");
1316         Globals.mangle_prefix = 1;
1317
1318         string_set(&Globals.szGuestaccount, GUEST_ACCOUNT);
1319
1320         /* using UTF8 by default allows us to support all chars */
1321         string_set(&Globals.unix_charset, DEFAULT_UNIX_CHARSET);
1322
1323 #if defined(HAVE_NL_LANGINFO) && defined(CODESET)
1324         /* If the system supports nl_langinfo(), try to grab the value
1325            from the user's locale */
1326         string_set(&Globals.display_charset, "LOCALE");
1327 #else
1328         string_set(&Globals.display_charset, DEFAULT_DISPLAY_CHARSET);
1329 #endif
1330
1331         /* Use codepage 850 as a default for the dos character set */
1332         string_set(&Globals.dos_charset, DEFAULT_DOS_CHARSET);
1333
1334         /*
1335          * Allow the default PASSWD_CHAT to be overridden in local.h.
1336          */
1337         string_set(&Globals.szPasswdChat, DEFAULT_PASSWD_CHAT);
1338
1339         set_global_myname(myhostname());
1340         string_set(&Globals.szNetbiosName,global_myname());
1341
1342         set_global_myworkgroup(WORKGROUP);
1343         string_set(&Globals.szWorkgroup, lp_workgroup());
1344
1345         string_set(&Globals.szPasswdProgram, "");
1346         string_set(&Globals.szPidDir, dyn_PIDDIR);
1347         string_set(&Globals.szLockDir, dyn_LOCKDIR);
1348         string_set(&Globals.szSocketAddress, "0.0.0.0");
1349         pstrcpy(s, "Samba ");
1350         pstrcat(s, SAMBA_VERSION_STRING);
1351         string_set(&Globals.szServerString, s);
1352         slprintf(s, sizeof(s) - 1, "%d.%d", DEFAULT_MAJOR_VERSION,
1353                  DEFAULT_MINOR_VERSION);
1354         string_set(&Globals.szAnnounceVersion, s);
1355
1356         pstrcpy(user_socket_options, DEFAULT_SOCKET_OPTIONS);
1357
1358         string_set(&Globals.szLogonDrive, "");
1359         /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
1360         string_set(&Globals.szLogonHome, "\\\\%N\\%U");
1361         string_set(&Globals.szLogonPath, "\\\\%N\\%U\\profile");
1362
1363         string_set(&Globals.szNameResolveOrder, "lmhosts wins host bcast");
1364         string_set(&Globals.szPasswordServer, "*");
1365
1366         Globals.AlgorithmicRidBase = BASE_RID;
1367
1368         Globals.bLoadPrinters = True;
1369         Globals.PrintcapCacheTime = 0;
1370         /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
1371         /* Discovered by 2 days of pain by Don McCall @ HP :-). */
1372         Globals.max_xmit = 0x4104;
1373         Globals.max_mux = 50;   /* This is *needed* for profile support. */
1374         Globals.lpqcachetime = 30;      /* changed to handle large print servers better -- jerry */
1375         Globals.bDisableSpoolss = False;
1376         Globals.iMaxSmbdProcesses = 0;/* no limit specified */
1377         Globals.pwordlevel = 0;
1378         Globals.unamelevel = 0;
1379         Globals.deadtime = 0;
1380         Globals.bLargeReadwrite = True;
1381         Globals.max_log_size = 5000;
1382         Globals.max_open_files = MAX_OPEN_FILES;
1383         Globals.maxprotocol = PROTOCOL_NT1;
1384         Globals.minprotocol = PROTOCOL_CORE;
1385         Globals.security = SEC_USER;
1386         Globals.paranoid_server_security = True;
1387         Globals.bEncryptPasswords = True;
1388         Globals.bUpdateEncrypt = False;
1389         Globals.clientSchannel = Auto;
1390         Globals.serverSchannel = Auto;
1391         Globals.bReadRaw = True;
1392         Globals.bWriteRaw = True;
1393         Globals.bReadbmpx = False;
1394         Globals.bNullPasswords = False;
1395         Globals.bObeyPamRestrictions = False;
1396         Globals.syslog = 1;
1397         Globals.bSyslogOnly = False;
1398         Globals.bTimestampLogs = True;
1399         string_set(&Globals.szLogLevel, "0");
1400         Globals.bDebugHiresTimestamp = False;
1401         Globals.bDebugPid = False;
1402         Globals.bDebugUid = False;
1403         Globals.max_ttl = 60 * 60 * 24 * 3;     /* 3 days default. */
1404         Globals.max_wins_ttl = 60 * 60 * 24 * 6;        /* 6 days default. */
1405         Globals.min_wins_ttl = 60 * 60 * 6;     /* 6 hours default. */
1406         Globals.machine_password_timeout = 60 * 60 * 24 * 7;    /* 7 days default. */
1407         Globals.change_notify_timeout = 60;     /* 1 minute default. */
1408         Globals.bKernelChangeNotify = True;     /* On if we have it. */
1409         Globals.lm_announce = 2;        /* = Auto: send only if LM clients found */
1410         Globals.lm_interval = 60;
1411         Globals.announce_as = ANNOUNCE_AS_NT_SERVER;
1412 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1413         Globals.bNISHomeMap = False;
1414 #ifdef WITH_NISPLUS_HOME
1415         string_set(&Globals.szNISHomeMapName, "auto_home.org_dir");
1416 #else
1417         string_set(&Globals.szNISHomeMapName, "auto.home");
1418 #endif
1419 #endif
1420         Globals.bTimeServer = False;
1421         Globals.bBindInterfacesOnly = False;
1422         Globals.bUnixPasswdSync = False;
1423         Globals.bPamPasswordChange = False;
1424         Globals.bPasswdChatDebug = False;
1425         Globals.iPasswdChatTimeout = 2; /* 2 second default. */
1426         Globals.bNTPipeSupport = True;  /* Do NT pipes by default. */
1427         Globals.bNTStatusSupport = True; /* Use NT status by default. */
1428         Globals.bStatCache = True;      /* use stat cache by default */
1429         Globals.restrict_anonymous = 0;
1430         Globals.bClientLanManAuth = True;       /* Do use the LanMan hash if it is available */
1431         Globals.bClientPlaintextAuth = True;    /* Do use a plaintext password if is requested by the server */
1432         Globals.bLanmanAuth = True;     /* Do use the LanMan hash if it is available */
1433         Globals.bNTLMAuth = True;       /* Do use NTLMv1 if it is available (otherwise NTLMv2) */
1434         Globals.bClientNTLMv2Auth = False; /* Client should not use NTLMv2, as we can't tell that the server supports it. */
1435         /* Note, that we will use NTLM2 session security (which is different), if it is available */
1436
1437         Globals.map_to_guest = 0;       /* By Default, "Never" */
1438         Globals.min_passwd_length = MINPASSWDLENGTH;    /* By Default, 5. */
1439         Globals.oplock_break_wait_time = 0;     /* By Default, 0 msecs. */
1440         Globals.enhanced_browsing = True;
1441         Globals.iLockSpinCount = 3; /* Try 3 times. */
1442         Globals.iLockSpinTime = 10; /* usec. */
1443 #ifdef MMAP_BLACKLIST
1444         Globals.bUseMmap = False;
1445 #else
1446         Globals.bUseMmap = True;
1447 #endif
1448         Globals.bUnixExtensions = True;
1449
1450         /* hostname lookups can be very expensive and are broken on
1451            a large number of sites (tridge) */
1452         Globals.bHostnameLookups = False;
1453
1454         str_list_free(&Globals.szPassdbBackend);
1455 #ifdef WITH_LDAP_SAMCONFIG
1456         string_set(&Globals.szLdapServer, "localhost");
1457         Globals.ldap_port = 636;
1458         Globals.szPassdbBackend = str_list_make("ldapsam_compat", NULL);
1459 #else
1460         Globals.szPassdbBackend = str_list_make("smbpasswd", NULL);
1461 #endif /* WITH_LDAP_SAMCONFIG */
1462
1463         string_set(&Globals.szLdapSuffix, "");
1464         string_set(&Globals.szLdapFilter, "(uid=%u)");
1465         string_set(&Globals.szLdapMachineSuffix, "");
1466         string_set(&Globals.szLdapUserSuffix, "");
1467         string_set(&Globals.szLdapGroupSuffix, "");
1468         string_set(&Globals.szLdapIdmapSuffix, "");
1469
1470         string_set(&Globals.szLdapAdminDn, "");
1471         Globals.ldap_ssl = LDAP_SSL_ON;
1472         Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
1473         Globals.ldap_delete_dn = False;
1474         Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
1475         Globals.ldap_timeout = LDAP_CONNECT_DEFAULT_TIMEOUT;
1476
1477 /* these parameters are set to defaults that are more appropriate
1478    for the increasing samba install base:
1479
1480    as a member of the workgroup, that will possibly become a
1481    _local_ master browser (lm = True).  this is opposed to a forced
1482    local master browser startup (pm = True).
1483
1484    doesn't provide WINS server service by default (wsupp = False),
1485    and doesn't provide domain master browser services by default, either.
1486
1487 */
1488
1489         Globals.bMsAddPrinterWizard = True;
1490         Globals.bPreferredMaster = Auto;        /* depending on bDomainMaster */
1491         Globals.os_level = 20;
1492         Globals.bLocalMaster = True;
1493         Globals.bDomainMaster = Auto;   /* depending on bDomainLogons */
1494         Globals.bDomainLogons = False;
1495         Globals.bBrowseList = True;
1496         Globals.bWINSsupport = False;
1497         Globals.bWINSproxy = False;
1498
1499         Globals.bDNSproxy = True;
1500
1501         /* this just means to use them if they exist */
1502         Globals.bKernelOplocks = True;
1503
1504         Globals.bAllowTrustedDomains = True;
1505
1506         string_set(&Globals.szTemplateShell, "/bin/false");
1507         string_set(&Globals.szTemplateHomedir, "/home/%D/%U");
1508         string_set(&Globals.szTemplatePrimaryGroup, "nobody");
1509         string_set(&Globals.szWinbindSeparator, "\\");
1510         string_set(&Globals.szAclCompat, "");
1511         string_set(&Globals.szCupsServer, "");
1512
1513         Globals.winbind_cache_time = 300;       /* 5 minutes */
1514         Globals.bWinbindEnableLocalAccounts = False;
1515         Globals.bWinbindEnumUsers = True;
1516         Globals.bWinbindEnumGroups = True;
1517         Globals.bWinbindUseDefaultDomain = False;
1518         Globals.bWinbindTrustedDomainsOnly = False;
1519         Globals.bWinbindNestedGroups = False;
1520
1521         Globals.bEnableRidAlgorithm = True;
1522
1523         Globals.name_cache_timeout = 660; /* In seconds */
1524
1525         Globals.bUseSpnego = True;
1526         Globals.bClientUseSpnego = True;
1527
1528         Globals.client_signing = Auto;
1529         Globals.server_signing = False;
1530
1531         Globals.bDeferSharingViolations = True;
1532         string_set(&Globals.smb_ports, SMB_PORTS);
1533 }
1534
1535 static TALLOC_CTX *lp_talloc;
1536
1537 /******************************************************************* a
1538  Free up temporary memory - called from the main loop.
1539 ********************************************************************/
1540
1541 void lp_talloc_free(void)
1542 {
1543         if (!lp_talloc)
1544                 return;
1545         talloc_destroy(lp_talloc);
1546         lp_talloc = NULL;
1547 }
1548
1549 /*******************************************************************
1550  Convenience routine to grab string parameters into temporary memory
1551  and run standard_sub_basic on them. The buffers can be written to by
1552  callers without affecting the source string.
1553 ********************************************************************/
1554
1555 static char *lp_string(const char *s)
1556 {
1557         char *ret, *tmpstr;
1558
1559         /* The follow debug is useful for tracking down memory problems
1560            especially if you have an inner loop that is calling a lp_*()
1561            function that returns a string.  Perhaps this debug should be
1562            present all the time? */
1563
1564 #if 0
1565         DEBUG(10, ("lp_string(%s)\n", s));
1566 #endif
1567
1568         if (!lp_talloc)
1569                 lp_talloc = talloc_init("lp_talloc");
1570
1571         tmpstr = alloc_sub_basic(current_user_info.smb_name, s);
1572         if (trim_char(tmpstr, '\"', '\"')) {
1573                 if (strchr(tmpstr,'\"') != NULL) {
1574                         SAFE_FREE(tmpstr);
1575                         tmpstr = alloc_sub_basic(current_user_info.smb_name,s);
1576                 }
1577         }
1578         ret = talloc_strdup(lp_talloc, tmpstr);
1579         SAFE_FREE(tmpstr);
1580
1581         return (ret);
1582 }
1583
1584 /*
1585    In this section all the functions that are used to access the
1586    parameters from the rest of the program are defined
1587 */
1588
1589 #define FN_GLOBAL_STRING(fn_name,ptr) \
1590  char *fn_name(void) {return(lp_string(*(char **)(ptr) ? *(char **)(ptr) : ""));}
1591 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1592  const char *fn_name(void) {return(*(const char **)(ptr) ? *(const char **)(ptr) : "");}
1593 #define FN_GLOBAL_LIST(fn_name,ptr) \
1594  const char **fn_name(void) {return(*(const char ***)(ptr));}
1595 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1596  BOOL fn_name(void) {return(*(BOOL *)(ptr));}
1597 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1598  char fn_name(void) {return(*(char *)(ptr));}
1599 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1600  int fn_name(void) {return(*(int *)(ptr));}
1601
1602 #define FN_LOCAL_STRING(fn_name,val) \
1603  char *fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
1604 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1605  const char *fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1606 #define FN_LOCAL_LIST(fn_name,val) \
1607  const char **fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1608 #define FN_LOCAL_BOOL(fn_name,val) \
1609  BOOL fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1610 #define FN_LOCAL_CHAR(fn_name,val) \
1611  char fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1612 #define FN_LOCAL_INTEGER(fn_name,val) \
1613  int fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1614
1615 FN_GLOBAL_STRING(lp_smb_ports, &Globals.smb_ports)
1616 FN_GLOBAL_STRING(lp_dos_charset, &Globals.dos_charset)
1617 FN_GLOBAL_STRING(lp_unix_charset, &Globals.unix_charset)
1618 FN_GLOBAL_STRING(lp_display_charset, &Globals.display_charset)
1619 FN_GLOBAL_STRING(lp_logfile, &Globals.szLogFile)
1620 FN_GLOBAL_STRING(lp_configfile, &Globals.szConfigFile)
1621 FN_GLOBAL_STRING(lp_smb_passwd_file, &Globals.szSMBPasswdFile)
1622 FN_GLOBAL_STRING(lp_private_dir, &Globals.szPrivateDir)
1623 FN_GLOBAL_STRING(lp_serverstring, &Globals.szServerString)
1624 FN_GLOBAL_INTEGER(lp_printcap_cache_time, &Globals.PrintcapCacheTime)
1625 FN_GLOBAL_STRING(lp_enumports_cmd, &Globals.szEnumPortsCommand)
1626 FN_GLOBAL_STRING(lp_addprinter_cmd, &Globals.szAddPrinterCommand)
1627 FN_GLOBAL_STRING(lp_deleteprinter_cmd, &Globals.szDeletePrinterCommand)
1628 FN_GLOBAL_STRING(lp_os2_driver_map, &Globals.szOs2DriverMap)
1629 FN_GLOBAL_STRING(lp_lockdir, &Globals.szLockDir)
1630 FN_GLOBAL_STRING(lp_piddir, &Globals.szPidDir)
1631 FN_GLOBAL_STRING(lp_mangling_method, &Globals.szManglingMethod)
1632 FN_GLOBAL_INTEGER(lp_mangle_prefix, &Globals.mangle_prefix)
1633 FN_GLOBAL_STRING(lp_utmpdir, &Globals.szUtmpDir)
1634 FN_GLOBAL_STRING(lp_wtmpdir, &Globals.szWtmpDir)
1635 FN_GLOBAL_BOOL(lp_utmp, &Globals.bUtmp)
1636 FN_GLOBAL_STRING(lp_rootdir, &Globals.szRootdir)
1637 FN_GLOBAL_STRING(lp_defaultservice, &Globals.szDefaultService)
1638 FN_GLOBAL_STRING(lp_msg_command, &Globals.szMsgCommand)
1639 FN_GLOBAL_STRING(lp_dfree_command, &Globals.szDfree)
1640 FN_GLOBAL_STRING(lp_get_quota_command, &Globals.szGetQuota)
1641 FN_GLOBAL_STRING(lp_set_quota_command, &Globals.szSetQuota)
1642 FN_GLOBAL_STRING(lp_hosts_equiv, &Globals.szHostsEquiv)
1643 FN_GLOBAL_STRING(lp_auto_services, &Globals.szAutoServices)
1644 FN_GLOBAL_STRING(lp_passwd_program, &Globals.szPasswdProgram)
1645 FN_GLOBAL_STRING(lp_passwd_chat, &Globals.szPasswdChat)
1646 FN_GLOBAL_STRING(lp_passwordserver, &Globals.szPasswordServer)
1647 FN_GLOBAL_STRING(lp_name_resolve_order, &Globals.szNameResolveOrder)
1648 FN_GLOBAL_STRING(lp_realm, &Globals.szRealm)
1649 FN_GLOBAL_CONST_STRING(lp_afs_username_map, &Globals.szAfsUsernameMap)
1650 FN_GLOBAL_STRING(lp_username_map, &Globals.szUsernameMap)
1651 FN_GLOBAL_CONST_STRING(lp_logon_script, &Globals.szLogonScript)
1652 FN_GLOBAL_CONST_STRING(lp_logon_path, &Globals.szLogonPath)
1653 FN_GLOBAL_CONST_STRING(lp_logon_drive, &Globals.szLogonDrive)
1654 FN_GLOBAL_CONST_STRING(lp_logon_home, &Globals.szLogonHome)
1655 FN_GLOBAL_STRING(lp_remote_announce, &Globals.szRemoteAnnounce)
1656 FN_GLOBAL_STRING(lp_remote_browse_sync, &Globals.szRemoteBrowseSync)
1657 FN_GLOBAL_LIST(lp_wins_server_list, &Globals.szWINSservers)
1658 FN_GLOBAL_LIST(lp_interfaces, &Globals.szInterfaces)
1659 FN_GLOBAL_STRING(lp_socket_address, &Globals.szSocketAddress)
1660 FN_GLOBAL_STRING(lp_nis_home_map_name, &Globals.szNISHomeMapName)
1661 static FN_GLOBAL_STRING(lp_announce_version, &Globals.szAnnounceVersion)
1662 FN_GLOBAL_LIST(lp_netbios_aliases, &Globals.szNetbiosAliases)
1663 FN_GLOBAL_LIST(lp_passdb_backend, &Globals.szPassdbBackend)
1664 FN_GLOBAL_LIST(lp_preload_modules, &Globals.szPreloadModules)
1665 FN_GLOBAL_STRING(lp_panic_action, &Globals.szPanicAction)
1666 FN_GLOBAL_STRING(lp_adduser_script, &Globals.szAddUserScript)
1667 FN_GLOBAL_STRING(lp_deluser_script, &Globals.szDelUserScript)
1668
1669 FN_GLOBAL_CONST_STRING(lp_guestaccount, &Globals.szGuestaccount)
1670 FN_GLOBAL_STRING(lp_addgroup_script, &Globals.szAddGroupScript)
1671 FN_GLOBAL_STRING(lp_delgroup_script, &Globals.szDelGroupScript)
1672 FN_GLOBAL_STRING(lp_addusertogroup_script, &Globals.szAddUserToGroupScript)
1673 FN_GLOBAL_STRING(lp_deluserfromgroup_script, &Globals.szDelUserFromGroupScript)
1674 FN_GLOBAL_STRING(lp_setprimarygroup_script, &Globals.szSetPrimaryGroupScript)
1675
1676 FN_GLOBAL_STRING(lp_addmachine_script, &Globals.szAddMachineScript)
1677
1678 FN_GLOBAL_STRING(lp_shutdown_script, &Globals.szShutdownScript)
1679 FN_GLOBAL_STRING(lp_abort_shutdown_script, &Globals.szAbortShutdownScript)
1680
1681 FN_GLOBAL_STRING(lp_check_password_script, &Globals.szCheckPasswordScript)
1682
1683 FN_GLOBAL_STRING(lp_wins_hook, &Globals.szWINSHook)
1684 FN_GLOBAL_STRING(lp_wins_partners, &Globals.szWINSPartners)
1685 FN_GLOBAL_STRING(lp_template_primary_group, &Globals.szTemplatePrimaryGroup)
1686 FN_GLOBAL_CONST_STRING(lp_template_homedir, &Globals.szTemplateHomedir)
1687 FN_GLOBAL_CONST_STRING(lp_template_shell, &Globals.szTemplateShell)
1688 FN_GLOBAL_CONST_STRING(lp_winbind_separator, &Globals.szWinbindSeparator)
1689 FN_GLOBAL_STRING(lp_acl_compatibility, &Globals.szAclCompat)
1690 FN_GLOBAL_BOOL(lp_winbind_enable_local_accounts, &Globals.bWinbindEnableLocalAccounts)
1691 FN_GLOBAL_BOOL(lp_winbind_enum_users, &Globals.bWinbindEnumUsers)
1692 FN_GLOBAL_BOOL(lp_winbind_enum_groups, &Globals.bWinbindEnumGroups)
1693 FN_GLOBAL_BOOL(lp_winbind_use_default_domain, &Globals.bWinbindUseDefaultDomain)
1694 FN_GLOBAL_BOOL(lp_winbind_trusted_domains_only, &Globals.bWinbindTrustedDomainsOnly)
1695 FN_GLOBAL_BOOL(lp_winbind_nested_groups, &Globals.bWinbindNestedGroups)
1696
1697 FN_GLOBAL_LIST(lp_idmap_backend, &Globals.szIdmapBackend)
1698 FN_GLOBAL_BOOL(lp_enable_rid_algorithm, &Globals.bEnableRidAlgorithm)
1699
1700 #ifdef WITH_LDAP_SAMCONFIG
1701 FN_GLOBAL_STRING(lp_ldap_server, &Globals.szLdapServer)
1702 FN_GLOBAL_INTEGER(lp_ldap_port, &Globals.ldap_port)
1703 #endif
1704 FN_GLOBAL_STRING(lp_ldap_suffix, &Globals.szLdapSuffix)
1705 FN_GLOBAL_STRING(lp_ldap_filter, &Globals.szLdapFilter)
1706 FN_GLOBAL_STRING(lp_ldap_admin_dn, &Globals.szLdapAdminDn)
1707 FN_GLOBAL_INTEGER(lp_ldap_ssl, &Globals.ldap_ssl)
1708 FN_GLOBAL_INTEGER(lp_ldap_passwd_sync, &Globals.ldap_passwd_sync)
1709 FN_GLOBAL_BOOL(lp_ldap_delete_dn, &Globals.ldap_delete_dn)
1710 FN_GLOBAL_INTEGER(lp_ldap_replication_sleep, &Globals.ldap_replication_sleep)
1711 FN_GLOBAL_INTEGER(lp_ldap_timeout, &Globals.ldap_timeout)
1712 FN_GLOBAL_STRING(lp_add_share_cmd, &Globals.szAddShareCommand)
1713 FN_GLOBAL_STRING(lp_change_share_cmd, &Globals.szChangeShareCommand)
1714 FN_GLOBAL_STRING(lp_delete_share_cmd, &Globals.szDeleteShareCommand)
1715
1716 FN_GLOBAL_BOOL(lp_disable_netbios, &Globals.bDisableNetbios)
1717 FN_GLOBAL_BOOL(lp_ms_add_printer_wizard, &Globals.bMsAddPrinterWizard)
1718 FN_GLOBAL_BOOL(lp_dns_proxy, &Globals.bDNSproxy)
1719 FN_GLOBAL_BOOL(lp_wins_support, &Globals.bWINSsupport)
1720 FN_GLOBAL_BOOL(lp_we_are_a_wins_server, &Globals.bWINSsupport)
1721 FN_GLOBAL_BOOL(lp_wins_proxy, &Globals.bWINSproxy)
1722 FN_GLOBAL_BOOL(lp_local_master, &Globals.bLocalMaster)
1723 FN_GLOBAL_BOOL(lp_domain_logons, &Globals.bDomainLogons)
1724 FN_GLOBAL_BOOL(lp_load_printers, &Globals.bLoadPrinters)
1725 FN_GLOBAL_BOOL(lp_readbmpx, &Globals.bReadbmpx)
1726 FN_GLOBAL_BOOL(lp_readraw, &Globals.bReadRaw)
1727 FN_GLOBAL_BOOL(lp_large_readwrite, &Globals.bLargeReadwrite)
1728 FN_GLOBAL_BOOL(lp_writeraw, &Globals.bWriteRaw)
1729 FN_GLOBAL_BOOL(lp_null_passwords, &Globals.bNullPasswords)
1730 FN_GLOBAL_BOOL(lp_obey_pam_restrictions, &Globals.bObeyPamRestrictions)
1731 FN_GLOBAL_BOOL(lp_encrypted_passwords, &Globals.bEncryptPasswords)
1732 FN_GLOBAL_BOOL(lp_update_encrypted, &Globals.bUpdateEncrypt)
1733 FN_GLOBAL_INTEGER(lp_client_schannel, &Globals.clientSchannel)
1734 FN_GLOBAL_INTEGER(lp_server_schannel, &Globals.serverSchannel)
1735 FN_GLOBAL_BOOL(lp_syslog_only, &Globals.bSyslogOnly)
1736 FN_GLOBAL_BOOL(lp_timestamp_logs, &Globals.bTimestampLogs)
1737 FN_GLOBAL_BOOL(lp_debug_hires_timestamp, &Globals.bDebugHiresTimestamp)
1738 FN_GLOBAL_BOOL(lp_debug_pid, &Globals.bDebugPid)
1739 FN_GLOBAL_BOOL(lp_debug_uid, &Globals.bDebugUid)
1740 FN_GLOBAL_BOOL(lp_browse_list, &Globals.bBrowseList)
1741 FN_GLOBAL_BOOL(lp_nis_home_map, &Globals.bNISHomeMap)
1742 static FN_GLOBAL_BOOL(lp_time_server, &Globals.bTimeServer)
1743 FN_GLOBAL_BOOL(lp_bind_interfaces_only, &Globals.bBindInterfacesOnly)
1744 FN_GLOBAL_BOOL(lp_pam_password_change, &Globals.bPamPasswordChange)
1745 FN_GLOBAL_BOOL(lp_unix_password_sync, &Globals.bUnixPasswdSync)
1746 FN_GLOBAL_BOOL(lp_passwd_chat_debug, &Globals.bPasswdChatDebug)
1747 FN_GLOBAL_INTEGER(lp_passwd_chat_timeout, &Globals.iPasswdChatTimeout)
1748 FN_GLOBAL_BOOL(lp_nt_pipe_support, &Globals.bNTPipeSupport)
1749 FN_GLOBAL_BOOL(lp_nt_status_support, &Globals.bNTStatusSupport)
1750 FN_GLOBAL_BOOL(lp_stat_cache, &Globals.bStatCache)
1751 FN_GLOBAL_BOOL(lp_allow_trusted_domains, &Globals.bAllowTrustedDomains)
1752 FN_GLOBAL_INTEGER(lp_restrict_anonymous, &Globals.restrict_anonymous)
1753 FN_GLOBAL_BOOL(lp_lanman_auth, &Globals.bLanmanAuth)
1754 FN_GLOBAL_BOOL(lp_ntlm_auth, &Globals.bNTLMAuth)
1755 FN_GLOBAL_BOOL(lp_client_plaintext_auth, &Globals.bClientPlaintextAuth)
1756 FN_GLOBAL_BOOL(lp_client_lanman_auth, &Globals.bClientLanManAuth)
1757 FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, &Globals.bClientNTLMv2Auth)
1758 FN_GLOBAL_BOOL(lp_host_msdfs, &Globals.bHostMSDfs)
1759 FN_GLOBAL_BOOL(lp_kernel_oplocks, &Globals.bKernelOplocks)
1760 FN_GLOBAL_BOOL(lp_enhanced_browsing, &Globals.enhanced_browsing)
1761 FN_GLOBAL_BOOL(lp_use_mmap, &Globals.bUseMmap)
1762 FN_GLOBAL_BOOL(lp_unix_extensions, &Globals.bUnixExtensions)
1763 FN_GLOBAL_BOOL(lp_use_spnego, &Globals.bUseSpnego)
1764 FN_GLOBAL_BOOL(lp_client_use_spnego, &Globals.bClientUseSpnego)
1765 FN_GLOBAL_BOOL(lp_hostname_lookups, &Globals.bHostnameLookups)
1766 FN_GLOBAL_BOOL(lp_kernel_change_notify, &Globals.bKernelChangeNotify)
1767 FN_GLOBAL_BOOL(lp_use_kerberos_keytab, &Globals.bUseKerberosKeytab)
1768 FN_GLOBAL_BOOL(lp_defer_sharing_violations, &Globals.bDeferSharingViolations)
1769 FN_GLOBAL_INTEGER(lp_os_level, &Globals.os_level)
1770 FN_GLOBAL_INTEGER(lp_max_ttl, &Globals.max_ttl)
1771 FN_GLOBAL_INTEGER(lp_max_wins_ttl, &Globals.max_wins_ttl)
1772 FN_GLOBAL_INTEGER(lp_min_wins_ttl, &Globals.min_wins_ttl)
1773 FN_GLOBAL_INTEGER(lp_max_log_size, &Globals.max_log_size)
1774 FN_GLOBAL_INTEGER(lp_max_open_files, &Globals.max_open_files)
1775 FN_GLOBAL_INTEGER(lp_maxxmit, &Globals.max_xmit)
1776 FN_GLOBAL_INTEGER(lp_maxmux, &Globals.max_mux)
1777 FN_GLOBAL_INTEGER(lp_passwordlevel, &Globals.pwordlevel)
1778 FN_GLOBAL_INTEGER(lp_usernamelevel, &Globals.unamelevel)
1779 FN_GLOBAL_INTEGER(lp_deadtime, &Globals.deadtime)
1780 FN_GLOBAL_INTEGER(lp_maxprotocol, &Globals.maxprotocol)
1781 FN_GLOBAL_INTEGER(lp_minprotocol, &Globals.minprotocol)
1782 FN_GLOBAL_INTEGER(lp_security, &Globals.security)
1783 FN_GLOBAL_LIST(lp_auth_methods, &Globals.AuthMethods)
1784 FN_GLOBAL_BOOL(lp_paranoid_server_security, &Globals.paranoid_server_security)
1785 FN_GLOBAL_INTEGER(lp_maxdisksize, &Globals.maxdisksize)
1786 FN_GLOBAL_INTEGER(lp_lpqcachetime, &Globals.lpqcachetime)
1787 FN_GLOBAL_INTEGER(lp_max_smbd_processes, &Globals.iMaxSmbdProcesses)
1788 FN_GLOBAL_INTEGER(lp_disable_spoolss, &Globals.bDisableSpoolss)
1789 FN_GLOBAL_INTEGER(lp_syslog, &Globals.syslog)
1790 static FN_GLOBAL_INTEGER(lp_announce_as, &Globals.announce_as)
1791 FN_GLOBAL_INTEGER(lp_lm_announce, &Globals.lm_announce)
1792 FN_GLOBAL_INTEGER(lp_lm_interval, &Globals.lm_interval)
1793 FN_GLOBAL_INTEGER(lp_machine_password_timeout, &Globals.machine_password_timeout)
1794 FN_GLOBAL_INTEGER(lp_change_notify_timeout, &Globals.change_notify_timeout)
1795 FN_GLOBAL_INTEGER(lp_map_to_guest, &Globals.map_to_guest)
1796 FN_GLOBAL_INTEGER(lp_min_passwd_length, &Globals.min_passwd_length)
1797 FN_GLOBAL_INTEGER(lp_oplock_break_wait_time, &Globals.oplock_break_wait_time)
1798 FN_GLOBAL_INTEGER(lp_lock_spin_count, &Globals.iLockSpinCount)
1799 FN_GLOBAL_INTEGER(lp_lock_sleep_time, &Globals.iLockSpinTime)
1800 FN_LOCAL_STRING(lp_preexec, szPreExec)
1801 FN_LOCAL_STRING(lp_postexec, szPostExec)
1802 FN_LOCAL_STRING(lp_rootpreexec, szRootPreExec)
1803 FN_LOCAL_STRING(lp_rootpostexec, szRootPostExec)
1804 FN_LOCAL_STRING(lp_servicename, szService)
1805 FN_LOCAL_CONST_STRING(lp_const_servicename, szService)
1806 FN_LOCAL_STRING(lp_pathname, szPath)
1807 FN_LOCAL_STRING(lp_dontdescend, szDontdescend)
1808 FN_LOCAL_STRING(lp_username, szUsername)
1809 FN_LOCAL_LIST(lp_invalid_users, szInvalidUsers)
1810 FN_LOCAL_LIST(lp_valid_users, szValidUsers)
1811 FN_LOCAL_LIST(lp_admin_users, szAdminUsers)
1812 FN_LOCAL_STRING(lp_cups_options, szCupsOptions)
1813 FN_GLOBAL_STRING(lp_cups_server, &Globals.szCupsServer)
1814 FN_LOCAL_STRING(lp_printcommand, szPrintcommand)
1815 FN_LOCAL_STRING(lp_lpqcommand, szLpqcommand)
1816 FN_LOCAL_STRING(lp_lprmcommand, szLprmcommand)
1817 FN_LOCAL_STRING(lp_lppausecommand, szLppausecommand)
1818 FN_LOCAL_STRING(lp_lpresumecommand, szLpresumecommand)
1819 FN_LOCAL_STRING(lp_queuepausecommand, szQueuepausecommand)
1820 FN_LOCAL_STRING(lp_queueresumecommand, szQueueresumecommand)
1821 static FN_LOCAL_STRING(_lp_printername, szPrintername)
1822 FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
1823 FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
1824 FN_LOCAL_STRING(lp_magicscript, szMagicScript)
1825 FN_LOCAL_STRING(lp_magicoutput, szMagicOutput)
1826 FN_LOCAL_STRING(lp_comment, comment)
1827 FN_LOCAL_STRING(lp_force_user, force_user)
1828 FN_LOCAL_STRING(lp_force_group, force_group)
1829 FN_LOCAL_LIST(lp_readlist, readlist)
1830 FN_LOCAL_LIST(lp_writelist, writelist)
1831 FN_LOCAL_LIST(lp_printer_admin, printer_admin)
1832 FN_LOCAL_STRING(lp_fstype, fstype)
1833 FN_LOCAL_LIST(lp_vfs_objects, szVfsObjects)
1834 FN_LOCAL_STRING(lp_msdfs_proxy, szMSDfsProxy)
1835 static FN_LOCAL_STRING(lp_volume, volume)
1836 FN_LOCAL_STRING(lp_mangled_map, szMangledMap)
1837 FN_LOCAL_STRING(lp_veto_files, szVetoFiles)
1838 FN_LOCAL_STRING(lp_hide_files, szHideFiles)
1839 FN_LOCAL_STRING(lp_veto_oplocks, szVetoOplockFiles)
1840 FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
1841 FN_LOCAL_BOOL(lp_autoloaded, autoloaded)
1842 FN_LOCAL_BOOL(lp_preexec_close, bPreexecClose)
1843 FN_LOCAL_BOOL(lp_rootpreexec_close, bRootpreexecClose)
1844 FN_LOCAL_INTEGER(lp_casesensitive, iCaseSensitive)
1845 FN_LOCAL_BOOL(lp_preservecase, bCasePreserve)
1846 FN_LOCAL_BOOL(lp_shortpreservecase, bShortCasePreserve)
1847 FN_LOCAL_BOOL(lp_hide_dot_files, bHideDotFiles)
1848 FN_LOCAL_BOOL(lp_hide_special_files, bHideSpecialFiles)
1849 FN_LOCAL_BOOL(lp_hideunreadable, bHideUnReadable)
1850 FN_LOCAL_BOOL(lp_hideunwriteable_files, bHideUnWriteableFiles)
1851 FN_LOCAL_BOOL(lp_browseable, bBrowseable)
1852 FN_LOCAL_BOOL(lp_readonly, bRead_only)
1853 FN_LOCAL_BOOL(lp_no_set_dir, bNo_set_dir)
1854 FN_LOCAL_BOOL(lp_guest_ok, bGuest_ok)
1855 FN_LOCAL_BOOL(lp_guest_only, bGuest_only)
1856 FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
1857 FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
1858 FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
1859 FN_LOCAL_BOOL(lp_store_dos_attributes, bStoreDosAttributes)
1860 FN_LOCAL_BOOL(lp_locking, bLocking)
1861 FN_LOCAL_INTEGER(lp_strict_locking, iStrictLocking)
1862 FN_LOCAL_BOOL(lp_posix_locking, bPosixLocking)
1863 FN_LOCAL_BOOL(lp_share_modes, bShareModes)
1864 FN_LOCAL_BOOL(lp_oplocks, bOpLocks)
1865 FN_LOCAL_BOOL(lp_level2_oplocks, bLevel2OpLocks)
1866 FN_LOCAL_BOOL(lp_onlyuser, bOnlyUser)
1867 FN_LOCAL_BOOL(lp_manglednames, bMangledNames)
1868 FN_LOCAL_BOOL(lp_widelinks, bWidelinks)
1869 FN_LOCAL_BOOL(lp_symlinks, bSymlinks)
1870 FN_LOCAL_BOOL(lp_syncalways, bSyncAlways)
1871 FN_LOCAL_BOOL(lp_strict_allocate, bStrictAllocate)
1872 FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
1873 FN_LOCAL_BOOL(lp_map_system, bMap_system)
1874 FN_LOCAL_BOOL(lp_delete_readonly, bDeleteReadonly)
1875 FN_LOCAL_BOOL(lp_fake_oplocks, bFakeOplocks)
1876 FN_LOCAL_BOOL(lp_recursive_veto_delete, bDeleteVetoFiles)
1877 FN_LOCAL_BOOL(lp_dos_filemode, bDosFilemode)
1878 FN_LOCAL_BOOL(lp_dos_filetimes, bDosFiletimes)
1879 FN_LOCAL_BOOL(lp_dos_filetime_resolution, bDosFiletimeResolution)
1880 FN_LOCAL_BOOL(lp_fake_dir_create_times, bFakeDirCreateTimes)
1881 FN_LOCAL_BOOL(lp_blocking_locks, bBlockingLocks)
1882 FN_LOCAL_BOOL(lp_inherit_perms, bInheritPerms)
1883 FN_LOCAL_BOOL(lp_inherit_acls, bInheritACLS)
1884 FN_LOCAL_BOOL(lp_use_client_driver, bUseClientDriver)
1885 FN_LOCAL_BOOL(lp_default_devmode, bDefaultDevmode)
1886 FN_LOCAL_BOOL(lp_force_printername, bForcePrintername)
1887 FN_LOCAL_BOOL(lp_nt_acl_support, bNTAclSupport)
1888 FN_LOCAL_BOOL(lp_force_unknown_acl_user, bForceUnknownAclUser)
1889 FN_LOCAL_BOOL(lp_ea_support, bEASupport)
1890 FN_LOCAL_BOOL(_lp_use_sendfile, bUseSendfile)
1891 FN_LOCAL_BOOL(lp_profile_acls, bProfileAcls)
1892 FN_LOCAL_BOOL(lp_map_acl_inherit, bMap_acl_inherit)
1893 FN_LOCAL_BOOL(lp_afs_share, bAfs_Share)
1894 FN_LOCAL_INTEGER(lp_create_mask, iCreate_mask)
1895 FN_LOCAL_INTEGER(lp_force_create_mode, iCreate_force_mode)
1896 FN_LOCAL_INTEGER(lp_security_mask, iSecurity_mask)
1897 FN_LOCAL_INTEGER(lp_force_security_mode, iSecurity_force_mode)
1898 FN_LOCAL_INTEGER(lp_dir_mask, iDir_mask)
1899 FN_LOCAL_INTEGER(lp_force_dir_mode, iDir_force_mode)
1900 FN_LOCAL_INTEGER(lp_dir_security_mask, iDir_Security_mask)
1901 FN_LOCAL_INTEGER(lp_force_dir_security_mode, iDir_Security_force_mode)
1902 FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
1903 FN_LOCAL_INTEGER(lp_defaultcase, iDefaultCase)
1904 FN_LOCAL_INTEGER(lp_minprintspace, iMinPrintSpace)
1905 FN_LOCAL_INTEGER(lp_printing, iPrinting)
1906 FN_LOCAL_INTEGER(lp_max_reported_jobs, iMaxReportedPrintJobs)
1907 FN_LOCAL_INTEGER(lp_oplock_contention_limit, iOplockContentionLimit)
1908 FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
1909 FN_LOCAL_INTEGER(lp_write_cache_size, iWriteCacheSize)
1910 FN_LOCAL_INTEGER(lp_block_size, iBlock_size)
1911 FN_LOCAL_CHAR(lp_magicchar, magic_char)
1912 FN_GLOBAL_INTEGER(lp_winbind_cache_time, &Globals.winbind_cache_time)
1913 FN_GLOBAL_INTEGER(lp_algorithmic_rid_base, &Globals.AlgorithmicRidBase)
1914 FN_GLOBAL_INTEGER(lp_name_cache_timeout, &Globals.name_cache_timeout)
1915 FN_GLOBAL_INTEGER(lp_client_signing, &Globals.client_signing)
1916 FN_GLOBAL_INTEGER(lp_server_signing, &Globals.server_signing)
1917
1918 /* local prototypes */
1919
1920 static int map_parameter(const char *pszParmName);
1921 static BOOL set_boolean(BOOL *pb, const char *pszParmValue);
1922 static int getservicebyname(const char *pszServiceName,
1923                             service * pserviceDest);
1924 static void copy_service(service * pserviceDest,
1925                          service * pserviceSource, BOOL *pcopymapDest);
1926 static BOOL service_ok(int iService);
1927 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue);
1928 static BOOL do_section(const char *pszSectionName);
1929 static void init_copymap(service * pservice);
1930
1931 /* This is a helper function for parametrical options support. */
1932 /* It returns a pointer to parametrical option value if it exists or NULL otherwise */
1933 /* Actual parametrical functions are quite simple */
1934 static param_opt_struct *get_parametrics(int snum, const char *type, const char *option)
1935 {
1936         BOOL global_section = False;
1937         char* param_key;
1938         param_opt_struct *data;
1939
1940         if (snum >= iNumServices) return NULL;
1941
1942         if (snum < 0) {
1943                 data = Globals.param_opt;
1944                 global_section = True;
1945         } else {
1946                 data = ServicePtrs[snum]->param_opt;
1947         }
1948
1949         asprintf(&param_key, "%s:%s", type, option);
1950         if (!param_key) {
1951                 DEBUG(0,("asprintf failed!\n"));
1952                 return NULL;
1953         }
1954
1955         while (data) {
1956                 if (strcmp(data->key, param_key) == 0) {
1957                         string_free(&param_key);
1958                         return data;
1959                 }
1960                 data = data->next;
1961         }
1962
1963         if (!global_section) {
1964                 /* Try to fetch the same option but from globals */
1965                 /* but only if we are not already working with Globals */
1966                 data = Globals.param_opt;
1967                 while (data) {
1968                         if (strcmp(data->key, param_key) == 0) {
1969                                 string_free(&param_key);
1970                                 return data;
1971                         }
1972                         data = data->next;
1973                 }
1974         }
1975
1976         string_free(&param_key);
1977
1978         return NULL;
1979 }
1980
1981
1982 /*******************************************************************
1983 convenience routine to return int parameters.
1984 ********************************************************************/
1985 static int lp_int(const char *s)
1986 {
1987
1988         if (!s) {
1989                 DEBUG(0,("lp_int(%s): is called with NULL!\n",s));
1990                 return (-1);
1991         }
1992
1993         return atoi(s);
1994 }
1995
1996 /*******************************************************************
1997 convenience routine to return unsigned long parameters.
1998 ********************************************************************/
1999 static int lp_ulong(const char *s)
2000 {
2001
2002         if (!s) {
2003                 DEBUG(0,("lp_int(%s): is called with NULL!\n",s));
2004                 return (-1);
2005         }
2006
2007         return strtoul(s, NULL, 10);
2008 }
2009
2010 /*******************************************************************
2011 convenience routine to return boolean parameters.
2012 ********************************************************************/
2013 static BOOL lp_bool(const char *s)
2014 {
2015         BOOL ret = False;
2016
2017         if (!s) {
2018                 DEBUG(0,("lp_bool(%s): is called with NULL!\n",s));
2019                 return False;
2020         }
2021
2022         if (!set_boolean(&ret,s)) {
2023                 DEBUG(0,("lp_bool(%s): value is not boolean!\n",s));
2024                 return False;
2025         }
2026
2027         return ret;
2028 }
2029
2030 /*******************************************************************
2031 convenience routine to return enum parameters.
2032 ********************************************************************/
2033 static int lp_enum(const char *s,const struct enum_list *_enum)
2034 {
2035         int i;
2036
2037         if (!s || !_enum) {
2038                 DEBUG(0,("lp_enum(%s,enum): is called with NULL!\n",s));
2039                 return (-1);
2040         }
2041
2042         for (i=0; _enum[i].name; i++) {
2043                 if (strequal(_enum[i].name,s))
2044                         return _enum[i].value;
2045         }
2046
2047         DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
2048         return (-1);
2049 }
2050
2051
2052 /* DO NOT USE lp_parm_string ANYMORE!!!!
2053  * use lp_parm_const_string or lp_parm_talloc_string
2054  *
2055  * lp_parm_string is only used to let old modules find this symbol
2056  */
2057 #undef lp_parm_string
2058  char *lp_parm_string(const char *servicename, const char *type, const char *option)
2059 {
2060         return lp_parm_talloc_string(lp_servicenumber(servicename), type, option, NULL);
2061 }
2062
2063 /* Return parametric option from a given service. Type is a part of option before ':' */
2064 /* Parametric option has following syntax: 'Type: option = value' */
2065 /* the returned value is talloced in lp_talloc */
2066 char *lp_parm_talloc_string(int snum, const char *type, const char *option, const char *def)
2067 {
2068         param_opt_struct *data = get_parametrics(snum, type, option);
2069
2070         if (data == NULL||data->value==NULL) {
2071                 if (def) {
2072                         return lp_string(def);
2073                 } else {
2074                         return NULL;
2075                 }
2076         }
2077
2078         return lp_string(data->value);
2079 }
2080
2081 /* Return parametric option from a given service. Type is a part of option before ':' */
2082 /* Parametric option has following syntax: 'Type: option = value' */
2083 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
2084 {
2085         param_opt_struct *data = get_parametrics(snum, type, option);
2086
2087         if (data == NULL||data->value==NULL)
2088                 return def;
2089
2090         return data->value;
2091 }
2092
2093 /* Return parametric option from a given service. Type is a part of option before ':' */
2094 /* Parametric option has following syntax: 'Type: option = value' */
2095
2096 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
2097 {
2098         param_opt_struct *data = get_parametrics(snum, type, option);
2099
2100         if (data == NULL||data->value==NULL)
2101                 return (const char **)def;
2102
2103         if (data->list==NULL) {
2104                 data->list = str_list_make(data->value, NULL);
2105         }
2106
2107         return (const char **)data->list;
2108 }
2109
2110 /* Return parametric option from a given service. Type is a part of option before ':' */
2111 /* Parametric option has following syntax: 'Type: option = value' */
2112
2113 int lp_parm_int(int snum, const char *type, const char *option, int def)
2114 {
2115         param_opt_struct *data = get_parametrics(snum, type, option);
2116
2117         if (data && data->value && *data->value)
2118                 return lp_int(data->value);
2119
2120         return def;
2121 }
2122
2123 /* Return parametric option from a given service. Type is a part of option before ':' */
2124 /* Parametric option has following syntax: 'Type: option = value' */
2125
2126 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
2127 {
2128         param_opt_struct *data = get_parametrics(snum, type, option);
2129
2130         if (data && data->value && *data->value)
2131                 return lp_ulong(data->value);
2132
2133         return def;
2134 }
2135
2136 /* Return parametric option from a given service. Type is a part of option before ':' */
2137 /* Parametric option has following syntax: 'Type: option = value' */
2138
2139 BOOL lp_parm_bool(int snum, const char *type, const char *option, BOOL def)
2140 {
2141         param_opt_struct *data = get_parametrics(snum, type, option);
2142
2143         if (data && data->value && *data->value)
2144                 return lp_bool(data->value);
2145
2146         return def;
2147 }
2148
2149 /* Return parametric option from a given service. Type is a part of option before ':' */
2150 /* Parametric option has following syntax: 'Type: option = value' */
2151
2152 int lp_parm_enum(int snum, const char *type, const char *option,
2153                  const struct enum_list *_enum, int def)
2154 {
2155         param_opt_struct *data = get_parametrics(snum, type, option);
2156
2157         if (data && data->value && *data->value && _enum)
2158                 return lp_enum(data->value, _enum);
2159
2160         return def;
2161 }
2162
2163
2164 /***************************************************************************
2165  Initialise a service to the defaults.
2166 ***************************************************************************/
2167
2168 static void init_service(service * pservice)
2169 {
2170         memset((char *)pservice, '\0', sizeof(service));
2171         copy_service(pservice, &sDefault, NULL);
2172 }
2173
2174 /***************************************************************************
2175  Free the dynamically allocated parts of a service struct.
2176 ***************************************************************************/
2177
2178 static void free_service(service *pservice)
2179 {
2180         int i;
2181         param_opt_struct *data, *pdata;
2182         if (!pservice)
2183                 return;
2184
2185         if (pservice->szService)
2186                 DEBUG(5, ("free_service: Freeing service %s\n",
2187                        pservice->szService));
2188
2189         string_free(&pservice->szService);
2190         SAFE_FREE(pservice->copymap);
2191
2192         for (i = 0; parm_table[i].label; i++) {
2193                 if ((parm_table[i].type == P_STRING ||
2194                      parm_table[i].type == P_USTRING) &&
2195                     parm_table[i].class == P_LOCAL)
2196                         string_free((char **)
2197                                     (((char *)pservice) +
2198                                      PTR_DIFF(parm_table[i].ptr, &sDefault)));
2199                 else if (parm_table[i].type == P_LIST &&
2200                          parm_table[i].class == P_LOCAL)
2201                              str_list_free((char ***)
2202                                             (((char *)pservice) +
2203                                              PTR_DIFF(parm_table[i].ptr, &sDefault)));
2204         }
2205
2206         data = pservice->param_opt;
2207         if (data)
2208                 DEBUG(5,("Freeing parametrics:\n"));
2209         while (data) {
2210                 DEBUG(5,("[%s = %s]\n", data->key, data->value));
2211                 string_free(&data->key);
2212                 string_free(&data->value);
2213                 str_list_free(&data->list);
2214                 pdata = data->next;
2215                 SAFE_FREE(data);
2216                 data = pdata;
2217         }
2218
2219         ZERO_STRUCTP(pservice);
2220 }
2221
2222 /***************************************************************************
2223  Add a new service to the services array initialising it with the given
2224  service.
2225 ***************************************************************************/
2226
2227 static int add_a_service(const service *pservice, const char *name)
2228 {
2229         int i;
2230         service tservice;
2231         int num_to_alloc = iNumServices + 1;
2232         param_opt_struct *data, *pdata;
2233
2234         tservice = *pservice;
2235
2236         /* it might already exist */
2237         if (name) {
2238                 i = getservicebyname(name, NULL);
2239                 if (i >= 0) {
2240                         /* Clean all parametric options for service */
2241                         /* They will be added during parsing again */
2242                         data = ServicePtrs[i]->param_opt;
2243                         while (data) {
2244                                 string_free(&data->key);
2245                                 string_free(&data->value);
2246                                 str_list_free(&data->list);
2247                                 pdata = data->next;
2248                                 SAFE_FREE(data);
2249                                 data = pdata;
2250                         }
2251                         ServicePtrs[i]->param_opt = NULL;
2252                         return (i);
2253                 }
2254         }
2255
2256         /* find an invalid one */
2257         for (i = 0; i < iNumServices; i++)
2258                 if (!ServicePtrs[i]->valid)
2259                         break;
2260
2261         /* if not, then create one */
2262         if (i == iNumServices) {
2263                 service **tsp;
2264
2265                 tsp = SMB_REALLOC_ARRAY(ServicePtrs, service *, num_to_alloc);
2266
2267                 if (!tsp) {
2268                         DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
2269                         return (-1);
2270                 }
2271                 else {
2272                         ServicePtrs = tsp;
2273                         ServicePtrs[iNumServices] = SMB_MALLOC_P(service);
2274                 }
2275                 if (!ServicePtrs[iNumServices]) {
2276                         DEBUG(0,("add_a_service: out of memory!\n"));
2277                         return (-1);
2278                 }
2279
2280                 iNumServices++;
2281         } else
2282                 free_service(ServicePtrs[i]);
2283
2284         ServicePtrs[i]->valid = True;
2285
2286         init_service(ServicePtrs[i]);
2287         copy_service(ServicePtrs[i], &tservice, NULL);
2288         if (name)
2289                 string_set(&ServicePtrs[i]->szService, name);
2290
2291         DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
2292                 i, ServicePtrs[i]->szService));
2293
2294         return (i);
2295 }
2296
2297 /***************************************************************************
2298  Add a new home service, with the specified home directory, defaults coming
2299  from service ifrom.
2300 ***************************************************************************/
2301
2302 BOOL lp_add_home(const char *pszHomename, int iDefaultService,
2303                  const char *user, const char *pszHomedir)
2304 {
2305         int i;
2306         pstring newHomedir;
2307
2308         i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
2309
2310         if (i < 0)
2311                 return (False);
2312
2313         if (!(*(ServicePtrs[iDefaultService]->szPath))
2314             || strequal(ServicePtrs[iDefaultService]->szPath, lp_pathname(GLOBAL_SECTION_SNUM))) {
2315                 pstrcpy(newHomedir, pszHomedir);
2316                 string_set(&ServicePtrs[i]->szPath, newHomedir);
2317         }
2318
2319         if (!(*(ServicePtrs[i]->comment))) {
2320                 pstring comment;
2321                 slprintf(comment, sizeof(comment) - 1,
2322                          "Home directory of %s", user);
2323                 string_set(&ServicePtrs[i]->comment, comment);
2324         }
2325
2326         /* set the browseable flag from the gloabl default */
2327
2328         ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2329
2330         ServicePtrs[i]->autoloaded = True;
2331
2332         DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
2333                user, ServicePtrs[i]->szPath ));
2334
2335         return (True);
2336 }
2337
2338 /***************************************************************************
2339  Add a new service, based on an old one.
2340 ***************************************************************************/
2341
2342 int lp_add_service(const char *pszService, int iDefaultService)
2343 {
2344         return (add_a_service(ServicePtrs[iDefaultService], pszService));
2345 }
2346
2347 /***************************************************************************
2348  Add the IPC service.
2349 ***************************************************************************/
2350
2351 static BOOL lp_add_ipc(const char *ipc_name, BOOL guest_ok)
2352 {
2353         pstring comment;
2354         int i = add_a_service(&sDefault, ipc_name);
2355
2356         if (i < 0)
2357                 return (False);
2358
2359         slprintf(comment, sizeof(comment) - 1,
2360                  "IPC Service (%s)", Globals.szServerString);
2361
2362         string_set(&ServicePtrs[i]->szPath, tmpdir());
2363         string_set(&ServicePtrs[i]->szUsername, "");
2364         string_set(&ServicePtrs[i]->comment, comment);
2365         string_set(&ServicePtrs[i]->fstype, "IPC");
2366         ServicePtrs[i]->iMaxConnections = 0;
2367         ServicePtrs[i]->bAvailable = True;
2368         ServicePtrs[i]->bRead_only = True;
2369         ServicePtrs[i]->bGuest_only = False;
2370         ServicePtrs[i]->bGuest_ok = guest_ok;
2371         ServicePtrs[i]->bPrint_ok = False;
2372         ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2373
2374         DEBUG(3, ("adding IPC service\n"));
2375
2376         return (True);
2377 }
2378
2379 /***************************************************************************
2380  Add a new printer service, with defaults coming from service iFrom.
2381 ***************************************************************************/
2382
2383 BOOL lp_add_printer(const char *pszPrintername, int iDefaultService)
2384 {
2385         const char *comment = "From Printcap";
2386         int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
2387
2388         if (i < 0)
2389                 return (False);
2390
2391         /* note that we do NOT default the availability flag to True - */
2392         /* we take it from the default service passed. This allows all */
2393         /* dynamic printers to be disabled by disabling the [printers] */
2394         /* entry (if/when the 'available' keyword is implemented!).    */
2395
2396         /* the printer name is set to the service name. */
2397         string_set(&ServicePtrs[i]->szPrintername, pszPrintername);
2398         string_set(&ServicePtrs[i]->comment, comment);
2399
2400         /* set the browseable flag from the gloabl default */
2401         ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2402
2403         /* Printers cannot be read_only. */
2404         ServicePtrs[i]->bRead_only = False;
2405         /* No share modes on printer services. */
2406         ServicePtrs[i]->bShareModes = False;
2407         /* No oplocks on printer services. */
2408         ServicePtrs[i]->bOpLocks = False;
2409         /* Printer services must be printable. */
2410         ServicePtrs[i]->bPrint_ok = True;
2411
2412         DEBUG(3, ("adding printer service %s\n", pszPrintername));
2413
2414         return (True);
2415 }
2416
2417 /***************************************************************************
2418  Map a parameter's string representation to something we can use.
2419  Returns False if the parameter string is not recognised, else TRUE.
2420 ***************************************************************************/
2421
2422 static int map_parameter(const char *pszParmName)
2423 {
2424         int iIndex;
2425
2426         if (*pszParmName == '-')
2427                 return (-1);
2428
2429         for (iIndex = 0; parm_table[iIndex].label; iIndex++)
2430                 if (strwicmp(parm_table[iIndex].label, pszParmName) == 0)
2431                         return (iIndex);
2432
2433         /* Warn only if it isn't parametric option */
2434         if (strchr(pszParmName, ':') == NULL)
2435                 DEBUG(0, ("Unknown parameter encountered: \"%s\"\n", pszParmName));
2436         /* We do return 'fail' for parametric options as well because they are
2437            stored in different storage
2438          */
2439         return (-1);
2440 }
2441
2442 /***************************************************************************
2443  Set a boolean variable from the text value stored in the passed string.
2444  Returns True in success, False if the passed string does not correctly
2445  represent a boolean.
2446 ***************************************************************************/
2447
2448 static BOOL set_boolean(BOOL *pb, const char *pszParmValue)
2449 {
2450         BOOL bRetval;
2451
2452         bRetval = True;
2453         if (strwicmp(pszParmValue, "yes") == 0 ||
2454             strwicmp(pszParmValue, "true") == 0 ||
2455             strwicmp(pszParmValue, "1") == 0)
2456                 *pb = True;
2457         else if (strwicmp(pszParmValue, "no") == 0 ||
2458                     strwicmp(pszParmValue, "False") == 0 ||
2459                     strwicmp(pszParmValue, "0") == 0)
2460                 *pb = False;
2461         else {
2462                 DEBUG(0,
2463                       ("ERROR: Badly formed boolean in configuration file: \"%s\".\n",
2464                        pszParmValue));
2465                 bRetval = False;
2466         }
2467         return (bRetval);
2468 }
2469
2470 /***************************************************************************
2471 Find a service by name. Otherwise works like get_service.
2472 ***************************************************************************/
2473
2474 static int getservicebyname(const char *pszServiceName, service * pserviceDest)
2475 {
2476         int iService;
2477
2478         for (iService = iNumServices - 1; iService >= 0; iService--)
2479                 if (VALID(iService) &&
2480                     strwicmp(ServicePtrs[iService]->szService, pszServiceName) == 0) {
2481                         if (pserviceDest != NULL)
2482                                 copy_service(pserviceDest, ServicePtrs[iService], NULL);
2483                         break;
2484                 }
2485
2486         return (iService);
2487 }
2488
2489 /***************************************************************************
2490  Copy a service structure to another.
2491  If pcopymapDest is NULL then copy all fields
2492 ***************************************************************************/
2493
2494 static void copy_service(service * pserviceDest, service * pserviceSource, BOOL *pcopymapDest)
2495 {
2496         int i;
2497         BOOL bcopyall = (pcopymapDest == NULL);
2498         param_opt_struct *data, *pdata, *paramo;
2499         BOOL not_added;
2500
2501         for (i = 0; parm_table[i].label; i++)
2502                 if (parm_table[i].ptr && parm_table[i].class == P_LOCAL &&
2503                     (bcopyall || pcopymapDest[i])) {
2504                         void *def_ptr = parm_table[i].ptr;
2505                         void *src_ptr =
2506                                 ((char *)pserviceSource) + PTR_DIFF(def_ptr,
2507                                                                     &sDefault);
2508                         void *dest_ptr =
2509                                 ((char *)pserviceDest) + PTR_DIFF(def_ptr,
2510                                                                   &sDefault);
2511
2512                         switch (parm_table[i].type) {
2513                                 case P_BOOL:
2514                                 case P_BOOLREV:
2515                                         *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
2516                                         break;
2517
2518                                 case P_INTEGER:
2519                                 case P_ENUM:
2520                                 case P_OCTAL:
2521                                         *(int *)dest_ptr = *(int *)src_ptr;
2522                                         break;
2523
2524                                 case P_CHAR:
2525                                         *(char *)dest_ptr = *(char *)src_ptr;
2526                                         break;
2527
2528                                 case P_STRING:
2529                                         string_set(dest_ptr,
2530                                                    *(char **)src_ptr);
2531                                         break;
2532
2533                                 case P_USTRING:
2534                                         string_set(dest_ptr,
2535                                                    *(char **)src_ptr);
2536                                         strupper_m(*(char **)dest_ptr);
2537                                         break;
2538                                 case P_LIST:
2539                                         str_list_free((char ***)dest_ptr);
2540                                         str_list_copy((char ***)dest_ptr, *(const char ***)src_ptr);
2541                                         break;
2542                                 default:
2543                                         break;
2544                         }
2545                 }
2546
2547         if (bcopyall) {
2548                 init_copymap(pserviceDest);
2549                 if (pserviceSource->copymap)
2550                         memcpy((void *)pserviceDest->copymap,
2551                                (void *)pserviceSource->copymap,
2552                                sizeof(BOOL) * NUMPARAMETERS);
2553         }
2554
2555         data = pserviceSource->param_opt;
2556         while (data) {
2557                 not_added = True;
2558                 pdata = pserviceDest->param_opt;
2559                 /* Traverse destination */
2560                 while (pdata) {
2561                         /* If we already have same option, override it */
2562                         if (strcmp(pdata->key, data->key) == 0) {
2563                                 string_free(&pdata->value);
2564                                 str_list_free(&data->list);
2565                                 pdata->value = SMB_STRDUP(data->value);
2566                                 not_added = False;
2567                                 break;
2568                         }
2569                         pdata = pdata->next;
2570                 }
2571                 if (not_added) {
2572                     paramo = SMB_XMALLOC_P(param_opt_struct);
2573                     paramo->key = SMB_STRDUP(data->key);
2574                     paramo->value = SMB_STRDUP(data->value);
2575                     paramo->list = NULL;
2576                     DLIST_ADD(pserviceDest->param_opt, paramo);
2577                 }
2578                 data = data->next;
2579         }
2580 }
2581
2582 /***************************************************************************
2583 Check a service for consistency. Return False if the service is in any way
2584 incomplete or faulty, else True.
2585 ***************************************************************************/
2586
2587 static BOOL service_ok(int iService)
2588 {
2589         BOOL bRetval;
2590
2591         bRetval = True;
2592         if (ServicePtrs[iService]->szService[0] == '\0') {
2593                 DEBUG(0, ("The following message indicates an internal error:\n"));
2594                 DEBUG(0, ("No service name in service entry.\n"));
2595                 bRetval = False;
2596         }
2597
2598         /* The [printers] entry MUST be printable. I'm all for flexibility, but */
2599         /* I can't see why you'd want a non-printable printer service...        */
2600         if (strwicmp(ServicePtrs[iService]->szService, PRINTERS_NAME) == 0) {
2601                 if (!ServicePtrs[iService]->bPrint_ok) {
2602                         DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
2603                                ServicePtrs[iService]->szService));
2604                         ServicePtrs[iService]->bPrint_ok = True;
2605                 }
2606                 /* [printers] service must also be non-browsable. */
2607                 if (ServicePtrs[iService]->bBrowseable)
2608                         ServicePtrs[iService]->bBrowseable = False;
2609         }
2610
2611         if (ServicePtrs[iService]->szPath[0] == '\0' &&
2612             strwicmp(ServicePtrs[iService]->szService, HOMES_NAME) != 0) {
2613                 DEBUG(0, ("No path in service %s - using %s\n",
2614                        ServicePtrs[iService]->szService, tmpdir()));
2615                 string_set(&ServicePtrs[iService]->szPath, tmpdir());
2616         }
2617
2618         /* If a service is flagged unavailable, log the fact at level 0. */
2619         if (!ServicePtrs[iService]->bAvailable)
2620                 DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
2621                           ServicePtrs[iService]->szService));
2622
2623         return (bRetval);
2624 }
2625
2626 static struct file_lists {
2627         struct file_lists *next;
2628         char *name;
2629         char *subfname;
2630         time_t modtime;
2631 } *file_lists = NULL;
2632
2633 /*******************************************************************
2634  Keep a linked list of all config files so we know when one has changed
2635  it's date and needs to be reloaded.
2636 ********************************************************************/
2637
2638 static void add_to_file_list(const char *fname, const char *subfname)
2639 {
2640         struct file_lists *f = file_lists;
2641
2642         while (f) {
2643                 if (f->name && !strcmp(f->name, fname))
2644                         break;
2645                 f = f->next;
2646         }
2647
2648         if (!f) {
2649                 f = SMB_MALLOC_P(struct file_lists);
2650                 if (!f)
2651                         return;
2652                 f->next = file_lists;
2653                 f->name = SMB_STRDUP(fname);
2654                 if (!f->name) {
2655                         SAFE_FREE(f);
2656                         return;
2657                 }
2658                 f->subfname = SMB_STRDUP(subfname);
2659                 if (!f->subfname) {
2660                         SAFE_FREE(f);
2661                         return;
2662                 }
2663                 file_lists = f;
2664                 f->modtime = file_modtime(subfname);
2665         } else {
2666                 time_t t = file_modtime(subfname);
2667                 if (t)
2668                         f->modtime = t;
2669         }
2670 }
2671
2672 /*******************************************************************
2673  Check if a config file has changed date.
2674 ********************************************************************/
2675
2676 BOOL lp_file_list_changed(void)
2677 {
2678         struct file_lists *f = file_lists;
2679         char *username;
2680
2681         DEBUG(6, ("lp_file_list_changed()\n"));
2682
2683         /* get the username for substituion -- preference to the current_user_info */
2684         if ( strlen( current_user_info.smb_name ) != 0 )
2685                 username = current_user_info.smb_name;
2686         else
2687                 username = sub_get_smb_name();
2688
2689
2690         while (f) {
2691                 pstring n2;
2692                 time_t mod_time;
2693
2694                 pstrcpy(n2, f->name);
2695                 standard_sub_basic( username, n2, sizeof(n2) );
2696
2697                 DEBUGADD(6, ("file %s -> %s  last mod_time: %s\n",
2698                              f->name, n2, ctime(&f->modtime)));
2699
2700                 mod_time = file_modtime(n2);
2701
2702                 if (mod_time && ((f->modtime != mod_time) || (f->subfname == NULL) || (strcmp(n2, f->subfname) != 0))) {
2703                         DEBUGADD(6,
2704                                  ("file %s modified: %s\n", n2,
2705                                   ctime(&mod_time)));
2706                         f->modtime = mod_time;
2707                         SAFE_FREE(f->subfname);
2708                         f->subfname = SMB_STRDUP(n2);
2709                         return (True);
2710                 }
2711                 f = f->next;
2712         }
2713         return (False);
2714 }
2715
2716 /***************************************************************************
2717  Run standard_sub_basic on netbios name... needed because global_myname
2718  is not accessed through any lp_ macro.
2719  Note: We must *NOT* use string_set() here as ptr points to global_myname.
2720 ***************************************************************************/
2721
2722 static BOOL handle_netbios_name(int snum, const char *pszParmValue, char **ptr)
2723 {
2724         BOOL ret;
2725         pstring netbios_name;
2726
2727         pstrcpy(netbios_name, pszParmValue);
2728
2729         standard_sub_basic(current_user_info.smb_name, netbios_name,sizeof(netbios_name));
2730
2731         ret = set_global_myname(netbios_name);
2732         string_set(&Globals.szNetbiosName,global_myname());
2733
2734         DEBUG(4, ("handle_netbios_name: set global_myname to: %s\n",
2735                global_myname()));
2736
2737         return ret;
2738 }
2739
2740 static BOOL handle_charset(int snum, const char *pszParmValue, char **ptr)
2741 {
2742         if (strcmp(*ptr, pszParmValue) != 0) {
2743                 string_set(ptr, pszParmValue);
2744                 init_iconv();
2745         }
2746         return True;
2747 }
2748
2749 static BOOL handle_workgroup(int snum, const char *pszParmValue, char **ptr)
2750 {
2751         BOOL ret;
2752
2753         ret = set_global_myworkgroup(pszParmValue);
2754         string_set(&Globals.szWorkgroup,lp_workgroup());
2755
2756         return ret;
2757 }
2758
2759 static BOOL handle_netbios_scope(int snum, const char *pszParmValue, char **ptr)
2760 {
2761         BOOL ret;
2762
2763         ret = set_global_scope(pszParmValue);
2764         string_set(&Globals.szNetbiosScope,global_scope());
2765
2766         return ret;
2767 }
2768
2769 static BOOL handle_netbios_aliases(int snum, const char *pszParmValue, char **ptr)
2770 {
2771         str_list_free(&Globals.szNetbiosAliases);
2772         Globals.szNetbiosAliases = str_list_make(pszParmValue, NULL);
2773         return set_netbios_aliases((const char **)Globals.szNetbiosAliases);
2774 }
2775
2776 /***************************************************************************
2777  Handle the include operation.
2778 ***************************************************************************/
2779
2780 static BOOL handle_include(int snum, const char *pszParmValue, char **ptr)
2781 {
2782         pstring fname;
2783         pstrcpy(fname, pszParmValue);
2784
2785         standard_sub_basic(current_user_info.smb_name, fname,sizeof(fname));
2786
2787         add_to_file_list(pszParmValue, fname);
2788
2789         string_set(ptr, fname);
2790
2791         if (file_exist(fname, NULL))
2792                 return (pm_process(fname, do_section, do_parameter));
2793
2794         DEBUG(2, ("Can't find include file %s\n", fname));
2795
2796         return (False);
2797 }
2798
2799 /***************************************************************************
2800  Handle the interpretation of the copy parameter.
2801 ***************************************************************************/
2802
2803 static BOOL handle_copy(int snum, const char *pszParmValue, char **ptr)
2804 {
2805         BOOL bRetval;
2806         int iTemp;
2807         service serviceTemp;
2808
2809         string_set(ptr, pszParmValue);
2810
2811         init_service(&serviceTemp);
2812
2813         bRetval = False;
2814
2815         DEBUG(3, ("Copying service from service %s\n", pszParmValue));
2816
2817         if ((iTemp = getservicebyname(pszParmValue, &serviceTemp)) >= 0) {
2818                 if (iTemp == iServiceIndex) {
2819                         DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
2820                 } else {
2821                         copy_service(ServicePtrs[iServiceIndex],
2822                                      &serviceTemp,
2823                                      ServicePtrs[iServiceIndex]->copymap);
2824                         bRetval = True;
2825                 }
2826         } else {
2827                 DEBUG(0, ("Unable to copy service - source not found: %s\n", pszParmValue));
2828                 bRetval = False;
2829         }
2830
2831         free_service(&serviceTemp);
2832         return (bRetval);
2833 }
2834
2835 /***************************************************************************
2836  Handle idmap/non unix account uid and gid allocation parameters.  The format of these
2837  parameters is:
2838
2839  [global]
2840
2841         idmap uid = 1000-1999
2842         idmap gid = 700-899
2843
2844  We only do simple parsing checks here.  The strings are parsed into useful
2845  structures in the idmap daemon code.
2846
2847 ***************************************************************************/
2848
2849 /* Some lp_ routines to return idmap [ug]id information */
2850
2851 static uid_t idmap_uid_low, idmap_uid_high;
2852 static gid_t idmap_gid_low, idmap_gid_high;
2853
2854 BOOL lp_idmap_uid(uid_t *low, uid_t *high)
2855 {
2856         if (idmap_uid_low == 0 || idmap_uid_high == 0)
2857                 return False;
2858
2859         if (low)
2860                 *low = idmap_uid_low;
2861
2862         if (high)
2863                 *high = idmap_uid_high;
2864
2865         return True;
2866 }
2867
2868 BOOL lp_idmap_gid(gid_t *low, gid_t *high)
2869 {
2870         if (idmap_gid_low == 0 || idmap_gid_high == 0)
2871                 return False;
2872
2873         if (low)
2874                 *low = idmap_gid_low;
2875
2876         if (high)
2877                 *high = idmap_gid_high;
2878
2879         return True;
2880 }
2881
2882 /* Do some simple checks on "idmap [ug]id" parameter values */
2883
2884 static BOOL handle_idmap_uid(int snum, const char *pszParmValue, char **ptr)
2885 {
2886         uint32 low, high;
2887
2888         if (sscanf(pszParmValue, "%u-%u", &low, &high) != 2 || high < low)
2889                 return False;
2890
2891         /* Parse OK */
2892
2893         string_set(ptr, pszParmValue);
2894
2895         idmap_uid_low = low;
2896         idmap_uid_high = high;
2897
2898         return True;
2899 }
2900
2901 static BOOL handle_idmap_gid(int snum, const char *pszParmValue, char **ptr)
2902 {
2903         uint32 low, high;
2904
2905         if (sscanf(pszParmValue, "%u-%u", &low, &high) != 2 || high < low)
2906                 return False;
2907
2908         /* Parse OK */
2909
2910         string_set(ptr, pszParmValue);
2911
2912         idmap_gid_low = low;
2913         idmap_gid_high = high;
2914
2915         return True;
2916 }
2917
2918 /***************************************************************************
2919  Handle the DEBUG level list.
2920 ***************************************************************************/
2921
2922 static BOOL handle_debug_list( int snum, const char *pszParmValueIn, char **ptr )
2923 {
2924         pstring pszParmValue;
2925
2926         pstrcpy(pszParmValue, pszParmValueIn);
2927         string_set(ptr, pszParmValueIn);
2928         return debug_parse_levels( pszParmValue );
2929 }
2930
2931 /***************************************************************************
2932  Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2933 ***************************************************************************/
2934
2935 static char* append_ldap_suffix( const char *str )
2936 {
2937         char *suffix_string;
2938
2939
2940         if (!lp_talloc)
2941                 lp_talloc = talloc_init("lp_talloc");
2942
2943         suffix_string = talloc_asprintf( lp_talloc, "%s,%s", str, Globals.szLdapSuffix );
2944         if ( !suffix_string ) {
2945                 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2946                 return NULL;
2947         }
2948
2949         return suffix_string;
2950 }
2951
2952 char *lp_ldap_machine_suffix(void)
2953 {
2954         if (Globals.szLdapMachineSuffix[0])
2955                 return append_ldap_suffix(Globals.szLdapMachineSuffix);
2956
2957         return lp_string(Globals.szLdapSuffix);
2958 }
2959
2960 char *lp_ldap_user_suffix(void)
2961 {
2962         if (Globals.szLdapUserSuffix[0])
2963                 return append_ldap_suffix(Globals.szLdapUserSuffix);
2964
2965         return lp_string(Globals.szLdapSuffix);
2966 }
2967
2968 char *lp_ldap_group_suffix(void)
2969 {
2970         if (Globals.szLdapGroupSuffix[0])
2971                 return append_ldap_suffix(Globals.szLdapGroupSuffix);
2972
2973         return lp_string(Globals.szLdapSuffix);
2974 }
2975
2976 char *lp_ldap_idmap_suffix(void)
2977 {
2978         if (Globals.szLdapIdmapSuffix[0])
2979                 return append_ldap_suffix(Globals.szLdapIdmapSuffix);
2980
2981         return lp_string(Globals.szLdapSuffix);
2982 }
2983
2984 /***************************************************************************
2985 ***************************************************************************/
2986
2987 static BOOL handle_acl_compatibility(int snum, const char *pszParmValue, char **ptr)
2988 {
2989         if (strequal(pszParmValue, "auto"))
2990                 string_set(ptr, "");
2991         else if (strequal(pszParmValue, "winnt"))
2992                 string_set(ptr, "winnt");
2993         else if (strequal(pszParmValue, "win2k"))
2994                 string_set(ptr, "win2k");
2995         else
2996                 return False;
2997
2998         return True;
2999 }
3000
3001 /****************************************************************************
3002  set the value for a P_ENUM
3003  ***************************************************************************/
3004
3005 static void lp_set_enum_parm( struct parm_struct *parm, const char *pszParmValue,
3006                               int *ptr )
3007 {
3008         int i;
3009
3010         for (i = 0; parm->enum_list[i].name; i++) {
3011                 if ( strequal(pszParmValue, parm->enum_list[i].name)) {
3012                         *ptr = parm->enum_list[i].value;
3013                         break;
3014                 }
3015         }
3016 }
3017
3018 /***************************************************************************
3019 ***************************************************************************/
3020
3021 static BOOL handle_printing(int snum, const char *pszParmValue, char **ptr)
3022 {
3023         static int parm_num = -1;
3024         service *s;
3025
3026         if ( parm_num == -1 )
3027                 parm_num = map_parameter( "printing" );
3028
3029         lp_set_enum_parm( &parm_table[parm_num], pszParmValue, (int*)ptr );
3030
3031         if ( snum < 0 )
3032                 s = &sDefault;
3033         else
3034                 s = ServicePtrs[snum];
3035
3036         init_printer_values( s );
3037
3038         return True;
3039 }
3040
3041
3042 /***************************************************************************
3043  Initialise a copymap.
3044 ***************************************************************************/
3045
3046 static void init_copymap(service * pservice)
3047 {
3048         int i;
3049         SAFE_FREE(pservice->copymap);
3050         pservice->copymap = SMB_MALLOC_ARRAY(BOOL,NUMPARAMETERS);
3051         if (!pservice->copymap)
3052                 DEBUG(0,
3053                       ("Couldn't allocate copymap!! (size %d)\n",
3054                        (int)NUMPARAMETERS));
3055         else
3056                 for (i = 0; i < NUMPARAMETERS; i++)
3057                         pservice->copymap[i] = True;
3058 }
3059
3060 /***************************************************************************
3061  Return the local pointer to a parameter given the service number and the
3062  pointer into the default structure.
3063 ***************************************************************************/
3064
3065 void *lp_local_ptr(int snum, void *ptr)
3066 {
3067         return (void *)(((char *)ServicePtrs[snum]) + PTR_DIFF(ptr, &sDefault));
3068 }
3069
3070 /***************************************************************************
3071  Process a parameter for a particular service number. If snum < 0
3072  then assume we are in the globals.
3073 ***************************************************************************/
3074
3075 BOOL lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
3076 {
3077         int parmnum, i, slen;
3078         void *parm_ptr = NULL;  /* where we are going to store the result */
3079         void *def_ptr = NULL;
3080         pstring param_key;
3081         char *sep;
3082         param_opt_struct *paramo, *data;
3083         BOOL not_added;
3084
3085         parmnum = map_parameter(pszParmName);
3086
3087         if (parmnum < 0) {
3088                 if ((sep=strchr(pszParmName, ':')) != NULL) {
3089                         *sep = '\0';
3090                         ZERO_STRUCT(param_key);
3091                         pstr_sprintf(param_key, "%s:", pszParmName);
3092                         slen = strlen(param_key);
3093                         pstrcat(param_key, sep+1);
3094                         trim_char(param_key+slen, ' ', ' ');
3095                         not_added = True;
3096                         data = (snum < 0) ? Globals.param_opt :
3097                                 ServicePtrs[snum]->param_opt;
3098                         /* Traverse destination */
3099                         while (data) {
3100                                 /* If we already have same option, override it */
3101                                 if (strcmp(data->key, param_key) == 0) {
3102                                         string_free(&data->value);
3103                                         str_list_free(&data->list);
3104                                         data->value = SMB_STRDUP(pszParmValue);
3105                                         not_added = False;
3106                                         break;
3107                                 }
3108                                 data = data->next;
3109                         }
3110                         if (not_added) {
3111                                 paramo = SMB_XMALLOC_P(param_opt_struct);
3112                                 paramo->key = SMB_STRDUP(param_key);
3113                                 paramo->value = SMB_STRDUP(pszParmValue);
3114                                 paramo->list = NULL;
3115                                 if (snum < 0) {
3116                                         DLIST_ADD(Globals.param_opt, paramo);
3117                                 } else {
3118                                         DLIST_ADD(ServicePtrs[snum]->param_opt, paramo);
3119                                 }
3120                         }
3121
3122                         *sep = ':';
3123                         return (True);
3124                 }
3125                 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
3126                 return (True);
3127         }
3128
3129         if (parm_table[parmnum].flags & FLAG_DEPRECATED) {
3130                 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
3131                           pszParmName));
3132         }
3133
3134         def_ptr = parm_table[parmnum].ptr;
3135
3136         /* we might point at a service, the default service or a global */
3137         if (snum < 0) {
3138                 parm_ptr = def_ptr;
3139         } else {
3140                 if (parm_table[parmnum].class == P_GLOBAL) {
3141                         DEBUG(0,
3142                               ("Global parameter %s found in service section!\n",
3143                                pszParmName));
3144                         return (True);
3145                 }
3146                 parm_ptr =
3147                         ((char *)ServicePtrs[snum]) + PTR_DIFF(def_ptr,
3148                                                             &sDefault);
3149         }
3150
3151         if (snum >= 0) {
3152                 if (!ServicePtrs[snum]->copymap)
3153                         init_copymap(ServicePtrs[snum]);
3154
3155                 /* this handles the aliases - set the copymap for other entries with
3156                    the same data pointer */
3157                 for (i = 0; parm_table[i].label; i++)
3158                         if (parm_table[i].ptr == parm_table[parmnum].ptr)
3159                                 ServicePtrs[snum]->copymap[i] = False;
3160         }
3161
3162         /* if it is a special case then go ahead */
3163         if (parm_table[parmnum].special) {
3164                 parm_table[parmnum].special(snum, pszParmValue, (char **)parm_ptr);
3165                 return (True);
3166         }
3167
3168         /* now switch on the type of variable it is */
3169         switch (parm_table[parmnum].type)
3170         {
3171                 case P_BOOL:
3172                         set_boolean(parm_ptr, pszParmValue);
3173                         break;
3174
3175                 case P_BOOLREV:
3176                         set_boolean(parm_ptr, pszParmValue);
3177                         *(BOOL *)parm_ptr = !*(BOOL *)parm_ptr;
3178                         break;
3179
3180                 case P_INTEGER:
3181                         *(int *)parm_ptr = atoi(pszParmValue);
3182                         break;
3183
3184                 case P_CHAR:
3185                         *(char *)parm_ptr = *pszParmValue;
3186                         break;
3187
3188                 case P_OCTAL:
3189                         sscanf(pszParmValue, "%o", (int *)parm_ptr);
3190                         break;
3191
3192                 case P_LIST:
3193                         str_list_free(parm_ptr);
3194                         *(char ***)parm_ptr = str_list_make(pszParmValue, NULL);
3195                         break;
3196
3197                 case P_STRING:
3198                         string_set(parm_ptr, pszParmValue);
3199                         break;
3200
3201                 case P_USTRING:
3202                         string_set(parm_ptr, pszParmValue);
3203                         strupper_m(*(char **)parm_ptr);
3204                         break;
3205
3206                 case P_GSTRING:
3207                         pstrcpy((char *)parm_ptr, pszParmValue);
3208                         break;
3209
3210                 case P_UGSTRING:
3211                         pstrcpy((char *)parm_ptr, pszParmValue);
3212                         strupper_m((char *)parm_ptr);
3213                         break;
3214
3215                 case P_ENUM:
3216                         lp_set_enum_parm( &parm_table[parmnum], pszParmValue, (int*)parm_ptr );
3217                         break;
3218                 case P_SEP:
3219                         break;
3220         }
3221
3222         return (True);
3223 }
3224
3225 /***************************************************************************
3226  Process a parameter.
3227 ***************************************************************************/
3228
3229 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue)
3230 {
3231         if (!bInGlobalSection && bGlobalOnly)
3232                 return (True);
3233
3234         DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
3235
3236         return (lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
3237                                 pszParmName, pszParmValue));
3238 }
3239
3240 /***************************************************************************
3241  Print a parameter of the specified type.
3242 ***************************************************************************/
3243
3244 static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
3245 {
3246         int i;
3247         switch (p->type)
3248         {
3249                 case P_ENUM:
3250                         for (i = 0; p->enum_list[i].name; i++) {
3251                                 if (*(int *)ptr == p->enum_list[i].value) {
3252                                         fprintf(f, "%s",
3253                                                 p->enum_list[i].name);
3254                                         break;
3255                                 }
3256                         }
3257                         break;
3258
3259                 case P_BOOL:
3260                         fprintf(f, "%s", BOOLSTR(*(BOOL *)ptr));
3261                         break;
3262
3263                 case P_BOOLREV:
3264                         fprintf(f, "%s", BOOLSTR(!*(BOOL *)ptr));
3265                         break;
3266
3267                 case P_INTEGER:
3268                         fprintf(f, "%d", *(int *)ptr);
3269                         break;
3270
3271                 case P_CHAR:
3272                         fprintf(f, "%c", *(char *)ptr);
3273                         break;
3274
3275                 case P_OCTAL:
3276                         fprintf(f, "%s", octal_string(*(int *)ptr));
3277                         break;
3278
3279                 case P_LIST:
3280                         if ((char ***)ptr && *(char ***)ptr) {
3281                                 char **list = *(char ***)ptr;
3282
3283                                 for (; *list; list++) {
3284                                         /* surround strings with whitespace in double quotes */
3285                                         if ( strchr_m( *list, ' ' ) )
3286                                                 fprintf(f, "\"%s\"%s", *list, ((*(list+1))?", ":""));
3287                                         else
3288                                                 fprintf(f, "%s%s", *list, ((*(list+1))?", ":""));
3289                                 }
3290                         }
3291                         break;
3292
3293                 case P_GSTRING:
3294                 case P_UGSTRING:
3295                         if ((char *)ptr) {
3296                                 fprintf(f, "%s", (char *)ptr);
3297                         }
3298                         break;
3299
3300                 case P_STRING:
3301                 case P_USTRING:
3302                         if (*(char **)ptr) {
3303                                 fprintf(f, "%s", *(char **)ptr);
3304                         }
3305                         break;
3306                 case P_SEP:
3307                         break;
3308         }
3309 }
3310
3311 /***************************************************************************
3312  Check if two parameters are equal.
3313 ***************************************************************************/
3314
3315 static BOOL equal_parameter(parm_type type, void *ptr1, void *ptr2)
3316 {
3317         switch (type) {
3318                 case P_BOOL:
3319                 case P_BOOLREV:
3320                         return (*((BOOL *)ptr1) == *((BOOL *)ptr2));
3321
3322                 case P_INTEGER:
3323                 case P_ENUM:
3324                 case P_OCTAL:
3325                         return (*((int *)ptr1) == *((int *)ptr2));
3326
3327                 case P_CHAR:
3328                         return (*((char *)ptr1) == *((char *)ptr2));
3329
3330                 case P_LIST:
3331                         return str_list_compare(*(char ***)ptr1, *(char ***)ptr2);
3332
3333                 case P_GSTRING:
3334                 case P_UGSTRING:
3335                 {
3336                         char *p1 = (char *)ptr1, *p2 = (char *)ptr2;
3337                         if (p1 && !*p1)
3338                                 p1 = NULL;
3339                         if (p2 && !*p2)
3340                                 p2 = NULL;
3341                         return (p1 == p2 || strequal(p1, p2));
3342                 }
3343                 case P_STRING:
3344                 case P_USTRING:
3345                 {
3346                         char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
3347                         if (p1 && !*p1)
3348                                 p1 = NULL;
3349                         if (p2 && !*p2)
3350                                 p2 = NULL;
3351                         return (p1 == p2 || strequal(p1, p2));
3352                 }
3353                 case P_SEP:
3354                         break;
3355         }
3356         return (False);
3357 }
3358
3359 /***************************************************************************
3360  Initialize any local varients in the sDefault table.
3361 ***************************************************************************/
3362
3363 void init_locals(void)
3364 {
3365         /* None as yet. */
3366 }
3367
3368 /***************************************************************************
3369  Process a new section (service). At this stage all sections are services.
3370  Later we'll have special sections that permit server parameters to be set.
3371  Returns True on success, False on failure.
3372 ***************************************************************************/
3373
3374 static BOOL do_section(const char *pszSectionName)
3375 {
3376         BOOL bRetval;
3377         BOOL isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
3378                          (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
3379         bRetval = False;
3380
3381         /* if we were in a global section then do the local inits */
3382         if (bInGlobalSection && !isglobal)
3383                 init_locals();
3384
3385         /* if we've just struck a global section, note the fact. */
3386         bInGlobalSection = isglobal;
3387
3388         /* check for multiple global sections */
3389         if (bInGlobalSection) {
3390                 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
3391                 return (True);
3392         }
3393
3394         if (!bInGlobalSection && bGlobalOnly)
3395                 return (True);
3396
3397         /* if we have a current service, tidy it up before moving on */
3398         bRetval = True;
3399
3400         if (iServiceIndex >= 0)
3401                 bRetval = service_ok(iServiceIndex);
3402
3403         /* if all is still well, move to the next record in the services array */
3404         if (bRetval) {
3405                 /* We put this here to avoid an odd message order if messages are */
3406                 /* issued by the post-processing of a previous section. */
3407                 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
3408
3409                 if ((iServiceIndex = add_a_service(&sDefault, pszSectionName))
3410                     < 0) {
3411                         DEBUG(0, ("Failed to add a new service\n"));
3412                         return (False);
3413                 }
3414         }
3415
3416         return (bRetval);
3417 }
3418
3419
3420 /***************************************************************************
3421  Determine if a partcular base parameter is currentl set to the default value.
3422 ***************************************************************************/
3423
3424 static BOOL is_default(int i)
3425 {
3426         if (!defaults_saved)
3427                 return False;
3428         switch (parm_table[i].type) {
3429                 case P_LIST:
3430                         return str_list_compare (parm_table[i].def.lvalue,
3431                                                 *(char ***)parm_table[i].ptr);
3432                 case P_STRING:
3433                 case P_USTRING:
3434                         return strequal(parm_table[i].def.svalue,
3435                                         *(char **)parm_table[i].ptr);
3436                 case P_GSTRING:
3437                 case P_UGSTRING:
3438                         return strequal(parm_table[i].def.svalue,
3439                                         (char *)parm_table[i].ptr);
3440                 case P_BOOL:
3441                 case P_BOOLREV:
3442                         return parm_table[i].def.bvalue ==
3443                                 *(BOOL *)parm_table[i].ptr;
3444                 case P_CHAR:
3445                         return parm_table[i].def.cvalue ==
3446                                 *(char *)parm_table[i].ptr;
3447                 case P_INTEGER:
3448                 case P_OCTAL:
3449                 case P_ENUM:
3450                         return parm_table[i].def.ivalue ==
3451                                 *(int *)parm_table[i].ptr;
3452                 case P_SEP:
3453                         break;
3454         }
3455         return False;
3456 }
3457
3458 /***************************************************************************
3459 Display the contents of the global structure.
3460 ***************************************************************************/
3461
3462 static void dump_globals(FILE *f)
3463 {
3464         int i;
3465         param_opt_struct *data;
3466
3467         fprintf(f, "# Global parameters\n[global]\n");
3468
3469         for (i = 0; parm_table[i].label; i++)
3470                 if (parm_table[i].class == P_GLOBAL &&
3471                     parm_table[i].ptr &&
3472                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
3473                         if (defaults_saved && is_default(i))
3474                                 continue;
3475                         fprintf(f, "\t%s = ", parm_table[i].label);
3476                         print_parameter(&parm_table[i], parm_table[i].ptr, f);
3477                         fprintf(f, "\n");
3478         }
3479         if (Globals.param_opt != NULL) {
3480                 data = Globals.param_opt;
3481                 while(data) {
3482                         fprintf(f, "\t%s = %s\n", data->key, data->value);
3483                         data = data->next;
3484                 }
3485         }
3486
3487 }
3488
3489 /***************************************************************************
3490  Return True if a local parameter is currently set to the global default.
3491 ***************************************************************************/
3492
3493 BOOL lp_is_default(int snum, struct parm_struct *parm)
3494 {
3495         int pdiff = PTR_DIFF(parm->ptr, &sDefault);
3496
3497         return equal_parameter(parm->type,
3498                                ((char *)ServicePtrs[snum]) + pdiff,
3499                                ((char *)&sDefault) + pdiff);
3500 }
3501
3502 /***************************************************************************
3503  Display the contents of a single services record.
3504 ***************************************************************************/
3505
3506 static void dump_a_service(service * pService, FILE * f)
3507 {
3508         int i;
3509         param_opt_struct *data;
3510
3511         if (pService != &sDefault)
3512                 fprintf(f, "\n[%s]\n", pService->szService);
3513
3514         for (i = 0; parm_table[i].label; i++) {
3515
3516                 if (parm_table[i].class == P_LOCAL &&
3517                     parm_table[i].ptr &&
3518                     (*parm_table[i].label != '-') &&
3519                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
3520                 {
3521
3522                         int pdiff = PTR_DIFF(parm_table[i].ptr, &sDefault);
3523
3524                         if (pService == &sDefault) {
3525                                 if (defaults_saved && is_default(i))
3526                                         continue;
3527                         } else {
3528                                 if (equal_parameter(parm_table[i].type,
3529                                                     ((char *)pService) +
3530                                                     pdiff,
3531                                                     ((char *)&sDefault) +
3532                                                     pdiff))
3533                                         continue;
3534                         }
3535
3536                         fprintf(f, "\t%s = ", parm_table[i].label);
3537                         print_parameter(&parm_table[i],
3538                                         ((char *)pService) + pdiff, f);
3539                         fprintf(f, "\n");
3540                 }
3541         }
3542
3543         if (pService->param_opt != NULL) {
3544                 data = pService->param_opt;
3545                 while(data) {
3546                         fprintf(f, "\t%s = %s\n", data->key, data->value);
3547                         data = data->next;
3548                 }
3549         }
3550 }
3551
3552
3553 /***************************************************************************
3554  Return info about the next service  in a service. snum==GLOBAL_SECTION_SNUM gives the globals.
3555  Return NULL when out of parameters.
3556 ***************************************************************************/
3557
3558 struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters)
3559 {
3560         if (snum < 0) {
3561                 /* do the globals */
3562                 for (; parm_table[*i].label; (*i)++) {
3563                         if (parm_table[*i].class == P_SEPARATOR)
3564                                 return &parm_table[(*i)++];
3565
3566                         if (!parm_table[*i].ptr
3567                             || (*parm_table[*i].label == '-'))
3568                                 continue;
3569
3570                         if ((*i) > 0
3571                             && (parm_table[*i].ptr ==
3572                                 parm_table[(*i) - 1].ptr))
3573                                 continue;
3574
3575                         return &parm_table[(*i)++];
3576                 }
3577         } else {
3578                 service *pService = ServicePtrs[snum];
3579
3580                 for (; parm_table[*i].label; (*i)++) {
3581                         if (parm_table[*i].class == P_SEPARATOR)
3582                                 return &parm_table[(*i)++];
3583
3584                         if (parm_table[*i].class == P_LOCAL &&
3585                             parm_table[*i].ptr &&
3586                             (*parm_table[*i].label != '-') &&
3587                             ((*i) == 0 ||
3588                              (parm_table[*i].ptr !=
3589                               parm_table[(*i) - 1].ptr)))
3590                         {
3591                                 int pdiff =
3592                                         PTR_DIFF(parm_table[*i].ptr,
3593                                                  &sDefault);
3594
3595                                 if (allparameters ||
3596                                     !equal_parameter(parm_table[*i].type,
3597                                                      ((char *)pService) +
3598                                                      pdiff,
3599                                                      ((char *)&sDefault) +
3600                                                      pdiff))
3601                                 {
3602                                         return &parm_table[(*i)++];
3603                                 }
3604                         }
3605                 }
3606         }
3607
3608         return NULL;
3609 }
3610
3611
3612 #if 0
3613 /***************************************************************************
3614  Display the contents of a single copy structure.
3615 ***************************************************************************/
3616 static void dump_copy_map(BOOL *pcopymap)
3617 {
3618         int i;
3619         if (!pcopymap)
3620                 return;
3621
3622         printf("\n\tNon-Copied parameters:\n");
3623
3624         for (i = 0; parm_table[i].label; i++)
3625                 if (parm_table[i].class == P_LOCAL &&
3626                     parm_table[i].ptr && !pcopymap[i] &&
3627                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
3628                 {
3629                         printf("\t\t%s\n", parm_table[i].label);
3630                 }
3631 }
3632 #endif
3633
3634 /***************************************************************************
3635  Return TRUE if the passed service number is within range.
3636 ***************************************************************************/
3637
3638 BOOL lp_snum_ok(int iService)
3639 {
3640         return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
3641 }
3642
3643 /***************************************************************************
3644  Auto-load some home services.
3645 ***************************************************************************/
3646
3647 static void lp_add_auto_services(char *str)
3648 {
3649         char *s;
3650         char *p;
3651         int homes;
3652
3653         if (!str)
3654                 return;
3655
3656         s = SMB_STRDUP(str);
3657         if (!s)
3658                 return;
3659
3660         homes = lp_servicenumber(HOMES_NAME);
3661
3662         for (p = strtok(s, LIST_SEP); p; p = strtok(NULL, LIST_SEP)) {
3663                 char *home = get_user_home_dir(p);
3664
3665                 if (lp_servicenumber(p) >= 0)
3666                         continue;
3667
3668                 if (home && homes >= 0)
3669                         lp_add_home(p, homes, p, home);
3670         }
3671         SAFE_FREE(s);
3672 }
3673
3674 /***************************************************************************
3675  Auto-load one printer.
3676 ***************************************************************************/
3677
3678 void lp_add_one_printer(char *name, char *comment)
3679 {
3680         int printers = lp_servicenumber(PRINTERS_NAME);
3681         int i;
3682
3683         if (lp_servicenumber(name) < 0) {
3684                 lp_add_printer(name, printers);
3685                 if ((i = lp_servicenumber(name)) >= 0) {
3686                         string_set(&ServicePtrs[i]->comment, comment);
3687                         ServicePtrs[i]->autoloaded = True;
3688                 }
3689         }
3690 }
3691
3692 /***************************************************************************
3693  Have we loaded a services file yet?
3694 ***************************************************************************/
3695
3696 BOOL lp_loaded(void)
3697 {
3698         return (bLoaded);
3699 }
3700
3701 /***************************************************************************
3702  Unload unused services.
3703 ***************************************************************************/
3704
3705 void lp_killunused(BOOL (*snumused) (int))
3706 {
3707         int i;
3708         for (i = 0; i < iNumServices; i++) {
3709                 if (!VALID(i))
3710                         continue;
3711
3712                 /* don't kill autoloaded services */
3713                 if ( ServicePtrs[i]->autoloaded )
3714                         continue;
3715
3716                 if (!snumused || !snumused(i)) {
3717                         ServicePtrs[i]->valid = False;
3718                         free_service(ServicePtrs[i]);
3719                 }
3720         }
3721 }
3722
3723 /***************************************************************************
3724  Unload a service.
3725 ***************************************************************************/
3726
3727 void lp_killservice(int iServiceIn)
3728 {
3729         if (VALID(iServiceIn)) {
3730                 ServicePtrs[iServiceIn]->valid = False;
3731                 free_service(ServicePtrs[iServiceIn]);
3732         }
3733 }
3734
3735 /***************************************************************************
3736  Save the curent values of all global and sDefault parameters into the
3737  defaults union. This allows swat and testparm to show only the
3738  changed (ie. non-default) parameters.
3739 ***************************************************************************/
3740
3741 static void lp_save_defaults(void)
3742 {
3743         int i;
3744         for (i = 0; parm_table[i].label; i++) {
3745                 if (i > 0 && parm_table[i].ptr == parm_table[i - 1].ptr)
3746                         continue;
3747                 switch (parm_table[i].type) {
3748                         case P_LIST:
3749                                 str_list_copy(&(parm_table[i].def.lvalue),
3750                                             *(const char ***)parm_table[i].ptr);
3751                                 break;
3752                         case P_STRING:
3753                         case P_USTRING:
3754                                 if (parm_table[i].ptr) {
3755                                         parm_table[i].def.svalue = SMB_STRDUP(*(char **)parm_table[i].ptr);
3756                                 } else {
3757                                         parm_table[i].def.svalue = NULL;
3758                                 }
3759                                 break;
3760                         case P_GSTRING:
3761                         case P_UGSTRING:
3762                                 if (parm_table[i].ptr) {
3763                                         parm_table[i].def.svalue = SMB_STRDUP((char *)parm_table[i].ptr);
3764                                 } else {
3765                                         parm_table[i].def.svalue = NULL;
3766                                 }
3767                                 break;
3768                         case P_BOOL:
3769                         case P_BOOLREV:
3770                                 parm_table[i].def.bvalue =
3771                                         *(BOOL *)parm_table[i].ptr;
3772                                 break;
3773                         case P_CHAR:
3774                                 parm_table[i].def.cvalue =
3775                                         *(char *)parm_table[i].ptr;
3776                                 break;
3777                         case P_INTEGER:
3778                         case P_OCTAL:
3779                         case P_ENUM:
3780                                 parm_table[i].def.ivalue =
3781                                         *(int *)parm_table[i].ptr;
3782                                 break;
3783                         case P_SEP:
3784                                 break;
3785                 }
3786         }
3787         defaults_saved = True;
3788 }
3789
3790 /*******************************************************************
3791  Set the server type we will announce as via nmbd.
3792 ********************************************************************/
3793
3794 static void set_server_role(void)
3795 {
3796         server_role = ROLE_STANDALONE;
3797
3798         switch (lp_security()) {
3799                 case SEC_SHARE:
3800                         if (lp_domain_logons())
3801                                 DEBUG(0, ("Server's Role (logon server) conflicts with share-level security\n"));
3802                         break;
3803                 case SEC_SERVER:
3804                         if (lp_domain_logons())
3805                                 DEBUG(0, ("Server's Role (logon server) conflicts with server-level security\n"));
3806                         server_role = ROLE_DOMAIN_MEMBER;
3807                         break;
3808                 case SEC_DOMAIN:
3809                         if (lp_domain_logons()) {
3810                                 DEBUG(1, ("Server's Role (logon server) NOT ADVISED with domain-level security\n"));
3811                                 server_role = ROLE_DOMAIN_BDC;
3812                                 break;
3813                         }
3814                         server_role = ROLE_DOMAIN_MEMBER;
3815                         break;
3816                 case SEC_ADS:
3817                         if (lp_domain_logons()) {
3818                                 server_role = ROLE_DOMAIN_PDC;
3819                                 break;
3820                         }
3821                         server_role = ROLE_DOMAIN_MEMBER;
3822                         break;
3823                 case SEC_USER:
3824                         if (lp_domain_logons()) {
3825
3826                                 if (Globals.bDomainMaster) /* auto or yes */
3827                                         server_role = ROLE_DOMAIN_PDC;
3828                                 else
3829                                         server_role = ROLE_DOMAIN_BDC;
3830                         }
3831                         break;
3832                 default:
3833                         DEBUG(0, ("Server's Role undefined due to unknown security mode\n"));
3834                         break;
3835         }
3836
3837         DEBUG(10, ("set_server_role: role = "));
3838
3839         switch(server_role) {
3840         case ROLE_STANDALONE:
3841                 DEBUGADD(10, ("ROLE_STANDALONE\n"));
3842                 break;
3843         case ROLE_DOMAIN_MEMBER:
3844                 DEBUGADD(10, ("ROLE_DOMAIN_MEMBER\n"));
3845                 break;
3846         case ROLE_DOMAIN_BDC:
3847                 DEBUGADD(10, ("ROLE_DOMAIN_BDC\n"));
3848                 break;
3849         case ROLE_DOMAIN_PDC:
3850                 DEBUGADD(10, ("ROLE_DOMAIN_PDC\n"));
3851                 break;
3852         }
3853 }
3854
3855 /***********************************************************
3856  If we should send plaintext/LANMAN passwords in the clinet
3857 ************************************************************/
3858 static void set_allowed_client_auth(void)
3859 {
3860         if (Globals.bClientNTLMv2Auth) {
3861                 Globals.bClientLanManAuth = False;
3862         }
3863         if (!Globals.bClientLanManAuth) {
3864                 Globals.bClientPlaintextAuth = False;
3865         }
3866 }
3867
3868 /***************************************************************************
3869  Load the services array from the services file. Return True on success,
3870  False on failure.
3871 ***************************************************************************/
3872
3873 BOOL lp_load(const char *pszFname, BOOL global_only, BOOL save_defaults,
3874              BOOL add_ipc)
3875 {
3876         pstring n2;
3877         BOOL bRetval;
3878         param_opt_struct *data, *pdata;
3879         char *username;
3880
3881         pstrcpy(n2, pszFname);
3882
3883         /* get the username for substituion -- preference to the current_user_info */
3884
3885         if ( strlen( current_user_info.smb_name ) != 0 ) {
3886                 username = current_user_info.smb_name;
3887         } else {
3888                 username = sub_get_smb_name();
3889         }
3890
3891         standard_sub_basic( username, n2,sizeof(n2) );
3892
3893         add_to_file_list(pszFname, n2);
3894
3895         bRetval = False;
3896
3897         DEBUG(3, ("lp_load: refreshing parameters\n"));
3898
3899         bInGlobalSection = True;
3900         bGlobalOnly = global_only;
3901
3902         init_globals();
3903         debug_init();
3904
3905         if (save_defaults) {
3906                 init_locals();
3907                 lp_save_defaults();
3908         }
3909
3910         if (Globals.param_opt != NULL) {
3911                 data = Globals.param_opt;
3912                 while (data) {
3913                         string_free(&data->key);
3914                         string_free(&data->value);
3915                         str_list_free(&data->list);
3916                         pdata = data->next;
3917                         SAFE_FREE(data);
3918                         data = pdata;
3919                 }
3920                 Globals.param_opt = NULL;
3921         }
3922
3923         /* We get sections first, so have to start 'behind' to make up */
3924         iServiceIndex = -1;
3925         bRetval = pm_process(n2, do_section, do_parameter);
3926
3927         /* finish up the last section */
3928         DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
3929         if (bRetval)
3930                 if (iServiceIndex >= 0)
3931                         bRetval = service_ok(iServiceIndex);
3932
3933         lp_add_auto_services(lp_auto_services());
3934
3935         if (add_ipc) {
3936                 /* When 'restrict anonymous = 2' guest connections to ipc$
3937                    are denied */
3938                 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
3939                 lp_add_ipc("ADMIN$", False);
3940         }
3941
3942         set_server_role();
3943         set_default_server_announce_type();
3944         set_allowed_client_auth();
3945
3946         bLoaded = True;
3947
3948         /* Now we check bWINSsupport and set szWINSserver to 127.0.0.1 */
3949         /* if bWINSsupport is true and we are in the client            */
3950         if (in_client && Globals.bWINSsupport) {
3951                 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
3952         }
3953
3954         init_iconv();
3955
3956         return (bRetval);
3957 }
3958
3959 /***************************************************************************
3960  Reset the max number of services.
3961 ***************************************************************************/
3962
3963 void lp_resetnumservices(void)
3964 {
3965         iNumServices = 0;
3966 }
3967
3968 /***************************************************************************
3969  Return the max number of services.
3970 ***************************************************************************/
3971
3972 int lp_numservices(void)
3973 {
3974         return (iNumServices);
3975 }
3976
3977 /***************************************************************************
3978 Display the contents of the services array in human-readable form.
3979 ***************************************************************************/
3980
3981 void lp_dump(FILE *f, BOOL show_defaults, int maxtoprint)
3982 {
3983         int iService;
3984
3985         if (show_defaults)
3986                 defaults_saved = False;
3987
3988         dump_globals(f);
3989
3990         dump_a_service(&sDefault, f);
3991
3992         for (iService = 0; iService < maxtoprint; iService++)
3993                 lp_dump_one(f, show_defaults, iService);
3994 }
3995
3996 /***************************************************************************
3997 Display the contents of one service in human-readable form.
3998 ***************************************************************************/
3999
4000 void lp_dump_one(FILE * f, BOOL show_defaults, int snum)
4001 {
4002         if (VALID(snum)) {
4003                 if (ServicePtrs[snum]->szService[0] == '\0')
4004                         return;
4005                 dump_a_service(ServicePtrs[snum], f);
4006         }
4007 }
4008
4009 /***************************************************************************
4010 Return the number of the service with the given name, or -1 if it doesn't
4011 exist. Note that this is a DIFFERENT ANIMAL from the internal function
4012 getservicebyname()! This works ONLY if all services have been loaded, and
4013 does not copy the found service.
4014 ***************************************************************************/
4015
4016 int lp_servicenumber(const char *pszServiceName)
4017 {
4018         int iService;
4019         fstring serviceName;
4020
4021         if (!pszServiceName)
4022                 return GLOBAL_SECTION_SNUM;
4023
4024         for (iService = iNumServices - 1; iService >= 0; iService--) {
4025                 if (VALID(iService) && ServicePtrs[iService]->szService) {
4026                         /*
4027                          * The substitution here is used to support %U is
4028                          * service names
4029                          */
4030                         fstrcpy(serviceName, ServicePtrs[iService]->szService);
4031                         standard_sub_basic(current_user_info.smb_name, serviceName,sizeof(serviceName));
4032                         if (strequal(serviceName, pszServiceName))
4033                                 break;
4034                 }
4035         }
4036
4037         if (iService < 0) {
4038                 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
4039                 return GLOBAL_SECTION_SNUM;
4040         }
4041
4042         return (iService);
4043 }
4044
4045 /*******************************************************************
4046  A useful volume label function.
4047 ********************************************************************/
4048
4049 char *volume_label(int snum)
4050 {
4051         char *ret = lp_volume(snum);
4052         if (!*ret)
4053                 return lp_servicename(snum);
4054         return (ret);
4055 }
4056
4057
4058 /*******************************************************************
4059  Set the server type we will announce as via nmbd.
4060 ********************************************************************/
4061
4062 static void set_default_server_announce_type(void)
4063 {
4064         default_server_announce = 0;
4065         default_server_announce |= SV_TYPE_WORKSTATION;
4066         default_server_announce |= SV_TYPE_SERVER;
4067         default_server_announce |= SV_TYPE_SERVER_UNIX;
4068
4069         /* note that the flag should be set only if we have a
4070            printer service but nmbd doesn't actually load the
4071            services so we can't tell   --jerry */
4072
4073         default_server_announce |= SV_TYPE_PRINTQ_SERVER;
4074
4075         switch (lp_announce_as()) {
4076                 case ANNOUNCE_AS_NT_SERVER:
4077                         default_server_announce |= SV_TYPE_SERVER_NT;
4078                         /* fall through... */
4079                 case ANNOUNCE_AS_NT_WORKSTATION:
4080                         default_server_announce |= SV_TYPE_NT;
4081                         break;
4082                 case ANNOUNCE_AS_WIN95:
4083                         default_server_announce |= SV_TYPE_WIN95_PLUS;
4084                         break;
4085                 case ANNOUNCE_AS_WFW:
4086                         default_server_announce |= SV_TYPE_WFW;
4087                         break;
4088                 default:
4089                         break;
4090         }
4091
4092         switch (lp_server_role()) {
4093                 case ROLE_DOMAIN_MEMBER:
4094                         default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
4095                         break;
4096                 case ROLE_DOMAIN_PDC:
4097                         default_server_announce |= SV_TYPE_DOMAIN_CTRL;
4098                         break;
4099                 case ROLE_DOMAIN_BDC:
4100                         default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
4101                         break;
4102                 case ROLE_STANDALONE:
4103                 default:
4104                         break;
4105         }
4106         if (lp_time_server())
4107                 default_server_announce |= SV_TYPE_TIME_SOURCE;
4108
4109         if (lp_host_msdfs())
4110                 default_server_announce |= SV_TYPE_DFS_SERVER;
4111 }
4112
4113 /***********************************************************
4114  returns role of Samba server
4115 ************************************************************/
4116
4117 int lp_server_role(void)
4118 {
4119         return server_role;
4120 }
4121
4122 /***********************************************************
4123  If we are PDC then prefer us as DMB
4124 ************************************************************/
4125
4126 BOOL lp_domain_master(void)
4127 {
4128         if (Globals.bDomainMaster == Auto)
4129                 return (lp_server_role() == ROLE_DOMAIN_PDC);
4130
4131         return Globals.bDomainMaster;
4132 }
4133
4134 /***********************************************************
4135  If we are DMB then prefer us as LMB
4136 ************************************************************/
4137
4138 BOOL lp_preferred_master(void)
4139 {
4140         if (Globals.bPreferredMaster == Auto)
4141                 return (lp_local_master() && lp_domain_master());
4142
4143         return Globals.bPreferredMaster;
4144 }
4145
4146 /*******************************************************************
4147  Remove a service.
4148 ********************************************************************/
4149
4150 void lp_remove_service(int snum)
4151 {
4152         ServicePtrs[snum]->valid = False;
4153 }
4154
4155 /*******************************************************************
4156  Copy a service.
4157 ********************************************************************/
4158
4159 void lp_copy_service(int snum, const char *new_name)
4160 {
4161         do_section(new_name);
4162         if (snum >= 0) {
4163                 snum = lp_servicenumber(new_name);
4164                 if (snum >= 0)
4165                         lp_do_parameter(snum, "copy", lp_servicename(snum));
4166         }
4167 }
4168
4169
4170 /*******************************************************************
4171  Get the default server type we will announce as via nmbd.
4172 ********************************************************************/
4173
4174 int lp_default_server_announce(void)
4175 {
4176         return default_server_announce;
4177 }
4178
4179 /*******************************************************************
4180  Split the announce version into major and minor numbers.
4181 ********************************************************************/
4182
4183 int lp_major_announce_version(void)
4184 {
4185         static BOOL got_major = False;
4186         static int major_version = DEFAULT_MAJOR_VERSION;
4187         char *vers;
4188         char *p;
4189
4190         if (got_major)
4191                 return major_version;
4192
4193         got_major = True;
4194         if ((vers = lp_announce_version()) == NULL)
4195                 return major_version;
4196
4197         if ((p = strchr_m(vers, '.')) == 0)
4198                 return major_version;
4199
4200         *p = '\0';
4201         major_version = atoi(vers);
4202         return major_version;
4203 }
4204
4205 int lp_minor_announce_version(void)
4206 {
4207         static BOOL got_minor = False;
4208         static int minor_version = DEFAULT_MINOR_VERSION;
4209         char *vers;
4210         char *p;
4211
4212         if (got_minor)
4213                 return minor_version;
4214
4215         got_minor = True;
4216         if ((vers = lp_announce_version()) == NULL)
4217                 return minor_version;
4218
4219         if ((p = strchr_m(vers, '.')) == 0)
4220                 return minor_version;
4221
4222         p++;
4223         minor_version = atoi(p);
4224         return minor_version;
4225 }
4226
4227 /***********************************************************
4228  Set the global name resolution order (used in smbclient).
4229 ************************************************************/
4230
4231 void lp_set_name_resolve_order(const char *new_order)
4232 {
4233         string_set(&Globals.szNameResolveOrder, new_order);
4234 }
4235
4236 const char *lp_printername(int snum)
4237 {
4238         const char *ret = _lp_printername(snum);
4239         if (ret == NULL || (ret != NULL && *ret == '\0'))
4240                 ret = lp_const_servicename(snum);
4241
4242         return ret;
4243 }
4244
4245
4246 /****************************************************************
4247  Compatibility fn. for 2.2.2 code.....
4248 *****************************************************************/
4249
4250 void get_private_directory(pstring privdir)
4251 {
4252         pstrcpy (privdir, lp_private_dir());
4253 }
4254
4255 /***********************************************************
4256  Allow daemons such as winbindd to fix their logfile name.
4257 ************************************************************/
4258
4259 void lp_set_logfile(const char *name)
4260 {
4261         string_set(&Globals.szLogFile, name);
4262         pstrcpy(debugf, name);
4263 }
4264
4265 /*******************************************************************
4266  Return the max print jobs per queue.
4267 ********************************************************************/
4268
4269 int lp_maxprintjobs(int snum)
4270 {
4271         int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
4272         if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
4273                 maxjobs = PRINT_MAX_JOBID - 1;
4274
4275         return maxjobs;
4276 }
4277
4278 const char *lp_printcapname(void)
4279 {
4280         if ((Globals.szPrintcapname != NULL) &&
4281             (Globals.szPrintcapname[0] != '\0'))
4282                 return Globals.szPrintcapname;
4283
4284         if (sDefault.iPrinting == PRINT_CUPS) {
4285 #ifdef HAVE_CUPS
4286                 return "cups";
4287 #else
4288                 return "lpstat";
4289 #endif
4290         }
4291
4292         if (sDefault.iPrinting == PRINT_BSD)
4293                 return "/etc/printcap";
4294
4295         return PRINTCAP_NAME;
4296 }
4297
4298 /*******************************************************************
4299  Ensure we don't use sendfile if server smb signing is active.
4300 ********************************************************************/
4301
4302 BOOL lp_use_sendfile(int snum)
4303 {
4304         extern enum protocol_types Protocol;
4305         /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
4306         if (Protocol < PROTOCOL_NT1) {
4307                 return False;
4308         }
4309         return (_lp_use_sendfile(snum) && (get_remote_arch() != RA_WIN95) && !srv_is_signing_active());
4310 }
4311
4312 /*******************************************************************
4313  Turn off sendfile if we find the underlying OS doesn't support it.
4314 ********************************************************************/
4315
4316 void set_use_sendfile(int snum, BOOL val)
4317 {
4318         if (LP_SNUM_OK(snum))
4319                 ServicePtrs[snum]->bUseSendfile = val;
4320         else
4321                 sDefault.bUseSendfile = val;
4322 }
4323
4324 /*******************************************************************
4325  Turn off storing DOS attributes if this share doesn't support it.
4326 ********************************************************************/
4327
4328 void set_store_dos_attributes(int snum, BOOL val)
4329 {
4330         if (!LP_SNUM_OK(snum))
4331                 return;
4332         ServicePtrs[(snum)]->bStoreDosAttributes = val;
4333 }