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