source3/param/loadparm.c

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