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 static bool handle_idmap_backend(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
2889 {
2890         lp_do_parameter(snum, "idmap config * : backend", pszParmValue);
2891
2892         return true;
2893 }
2894
2895 static bool handle_idmap_uid(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
2896 {
2897         lp_do_parameter(snum, "idmap config * : range", pszParmValue);
2898
2899         return true;
2900 }
2901
2902 static bool handle_idmap_gid(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
2903 {
2904         lp_do_parameter(snum, "idmap config * : range", pszParmValue);
2905
2906         return true;
2907 }
2908
2909 bool lp_idmap_range(const char *domain_name, uint32_t *low, uint32_t *high)
2910 {
2911         char *config_option = NULL;
2912         const char *range = NULL;
2913         bool ret = false;
2914
2915         SMB_ASSERT(low != NULL);
2916         SMB_ASSERT(high != NULL);
2917
2918         if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2919                 domain_name = "*";
2920         }
2921
2922         config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2923                                         domain_name);
2924         if (config_option == NULL) {
2925                 DEBUG(0, ("out of memory\n"));
2926                 return false;
2927         }
2928
2929         range = lp_parm_const_string(-1, config_option, "range", NULL);
2930         if (range == NULL) {
2931                 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name));
2932                 goto done;
2933         }
2934
2935         if (sscanf(range, "%u - %u", low, high) != 2) {
2936                 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2937                           range, domain_name));
2938                 goto done;
2939         }
2940
2941         ret = true;
2942
2943 done:
2944         talloc_free(config_option);
2945         return ret;
2946
2947 }
2948
2949 bool lp_idmap_default_range(uint32_t *low, uint32_t *high)
2950 {
2951         return lp_idmap_range("*", low, high);
2952 }
2953
2954 /***************************************************************************
2955  Handle the DEBUG level list.
2956 ***************************************************************************/
2957
2958 static bool handle_debug_list(struct loadparm_context *unused, int snum, const char *pszParmValueIn, char **ptr )
2959 {
2960         string_set(ptr, pszParmValueIn);
2961         return debug_parse_levels(pszParmValueIn);
2962 }
2963
2964 /***************************************************************************
2965  Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2966 ***************************************************************************/
2967
2968 static const char *append_ldap_suffix(TALLOC_CTX *ctx, const char *str )
2969 {
2970         const char *suffix_string;
2971
2972         suffix_string = talloc_asprintf(ctx, "%s,%s", str,
2973                                         Globals.szLdapSuffix );
2974         if ( !suffix_string ) {
2975                 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2976                 return "";
2977         }
2978
2979         return suffix_string;
2980 }
2981
2982 const char *lp_ldap_machine_suffix(TALLOC_CTX *ctx)
2983 {
2984         if (Globals.szLdapMachineSuffix[0])
2985                 return append_ldap_suffix(ctx, Globals.szLdapMachineSuffix);
2986
2987         return lp_string(ctx, Globals.szLdapSuffix);
2988 }
2989
2990 const char *lp_ldap_user_suffix(TALLOC_CTX *ctx)
2991 {
2992         if (Globals.szLdapUserSuffix[0])
2993                 return append_ldap_suffix(ctx, Globals.szLdapUserSuffix);
2994
2995         return lp_string(ctx, Globals.szLdapSuffix);
2996 }
2997
2998 const char *lp_ldap_group_suffix(TALLOC_CTX *ctx)
2999 {
3000         if (Globals.szLdapGroupSuffix[0])
3001                 return append_ldap_suffix(ctx, Globals.szLdapGroupSuffix);
3002
3003         return lp_string(ctx, Globals.szLdapSuffix);
3004 }
3005
3006 const char *lp_ldap_idmap_suffix(TALLOC_CTX *ctx)
3007 {
3008         if (Globals.szLdapIdmapSuffix[0])
3009                 return append_ldap_suffix(ctx, Globals.szLdapIdmapSuffix);
3010
3011         return lp_string(ctx, Globals.szLdapSuffix);
3012 }
3013
3014 /****************************************************************************
3015  set the value for a P_ENUM
3016  ***************************************************************************/
3017
3018 static void lp_set_enum_parm( struct parm_struct *parm, const char *pszParmValue,
3019                               int *ptr )
3020 {
3021         int i;
3022
3023         for (i = 0; parm->enum_list[i].name; i++) {
3024                 if ( strequal(pszParmValue, parm->enum_list[i].name)) {
3025                         *ptr = parm->enum_list[i].value;
3026                         return;
3027                 }
3028         }
3029         DEBUG(0, ("WARNING: Ignoring invalid value '%s' for parameter '%s'\n",
3030                   pszParmValue, parm->label));
3031 }
3032
3033 /***************************************************************************
3034 ***************************************************************************/
3035
3036 static bool handle_printing(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
3037 {
3038         static int parm_num = -1;
3039         struct loadparm_service *s;
3040
3041         if ( parm_num == -1 )
3042                 parm_num = map_parameter( "printing" );
3043
3044         lp_set_enum_parm( &parm_table[parm_num], pszParmValue, (int*)ptr );
3045
3046         if ( snum < 0 )
3047                 s = &sDefault;
3048         else
3049                 s = ServicePtrs[snum];
3050
3051         init_printer_values( s );
3052
3053         return true;
3054 }
3055
3056
3057 /***************************************************************************
3058  Initialise a copymap.
3059 ***************************************************************************/
3060
3061 static void init_copymap(struct loadparm_service *pservice)
3062 {
3063         int i;
3064
3065         TALLOC_FREE(pservice->copymap);
3066
3067         pservice->copymap = bitmap_talloc(NULL, NUMPARAMETERS);
3068         if (!pservice->copymap)
3069                 DEBUG(0,
3070                       ("Couldn't allocate copymap!! (size %d)\n",
3071                        (int)NUMPARAMETERS));
3072         else
3073                 for (i = 0; i < NUMPARAMETERS; i++)
3074                         bitmap_set(pservice->copymap, i);
3075 }
3076
3077 /**
3078   return the parameter pointer for a parameter
3079 */
3080 void *lp_parm_ptr(struct loadparm_service *service, struct parm_struct *parm)
3081 {
3082         if (service == NULL) {
3083                 if (parm->p_class == P_LOCAL)
3084                         return (void *)(((char *)&sDefault)+parm->offset);
3085                 else if (parm->p_class == P_GLOBAL)
3086                         return (void *)(((char *)&Globals)+parm->offset);
3087                 else return NULL;
3088         } else {
3089                 return (void *)(((char *)service) + parm->offset);
3090         }
3091 }
3092
3093 /***************************************************************************
3094  Return the local pointer to a parameter given the service number and parameter
3095 ***************************************************************************/
3096
3097 void *lp_local_ptr_by_snum(int snum, struct parm_struct *parm)
3098 {
3099         return lp_parm_ptr(ServicePtrs[snum], parm);
3100 }
3101
3102 /***************************************************************************
3103  Process a parameter for a particular service number. If snum < 0
3104  then assume we are in the globals.
3105 ***************************************************************************/
3106
3107 bool lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
3108 {
3109         int parmnum, i;
3110         void *parm_ptr = NULL;  /* where we are going to store the result */
3111         struct parmlist_entry **opt_list;
3112
3113         parmnum = map_parameter(pszParmName);
3114
3115         if (parmnum < 0) {
3116                 if (strchr(pszParmName, ':') == NULL) {
3117                         DEBUG(0, ("Ignoring unknown parameter \"%s\"\n",
3118                                   pszParmName));
3119                         return true;
3120                 }
3121
3122                 /*
3123                  * We've got a parametric option
3124                  */
3125
3126                 opt_list = (snum < 0)
3127                         ? &Globals.param_opt : &ServicePtrs[snum]->param_opt;
3128                 set_param_opt(opt_list, pszParmName, pszParmValue, 0);
3129
3130                 return true;
3131         }
3132
3133         /* if it's already been set by the command line, then we don't
3134            override here */
3135         if (parm_table[parmnum].flags & FLAG_CMDLINE) {
3136                 return true;
3137         }
3138
3139         if (parm_table[parmnum].flags & FLAG_DEPRECATED) {
3140                 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
3141                           pszParmName));
3142         }
3143
3144         /* we might point at a service, the default service or a global */
3145         if (snum < 0) {
3146                 parm_ptr = lp_parm_ptr(NULL, &parm_table[parmnum]);
3147         } else {
3148                 if (parm_table[parmnum].p_class == P_GLOBAL) {
3149                         DEBUG(0,
3150                               ("Global parameter %s found in service section!\n",
3151                                pszParmName));
3152                         return true;
3153                 }
3154                 parm_ptr = lp_local_ptr_by_snum(snum, &parm_table[parmnum]);
3155         }
3156
3157         if (snum >= 0) {
3158                 if (!ServicePtrs[snum]->copymap)
3159                         init_copymap(ServicePtrs[snum]);
3160
3161                 /* this handles the aliases - set the copymap for other entries with
3162                    the same data pointer */
3163                 for (i = 0; parm_table[i].label; i++) {
3164                         if ((parm_table[i].offset == parm_table[parmnum].offset)
3165                             && (parm_table[i].p_class == parm_table[parmnum].p_class)) {
3166                                 bitmap_clear(ServicePtrs[snum]->copymap, i);
3167                         }
3168                 }
3169         }
3170
3171         /* if it is a special case then go ahead */
3172         if (parm_table[parmnum].special) {
3173                 return parm_table[parmnum].special(NULL, snum, pszParmValue,
3174                                                    (char **)parm_ptr);
3175         }
3176
3177         /* now switch on the type of variable it is */
3178         switch (parm_table[parmnum].type)
3179         {
3180                 case P_BOOL:
3181                         *(bool *)parm_ptr = lp_bool(pszParmValue);
3182                         break;
3183
3184                 case P_BOOLREV:
3185                         *(bool *)parm_ptr = !lp_bool(pszParmValue);
3186                         break;
3187
3188                 case P_INTEGER:
3189                         *(int *)parm_ptr = lp_int(pszParmValue);
3190                         break;
3191
3192                 case P_CHAR:
3193                         *(char *)parm_ptr = *pszParmValue;
3194                         break;
3195
3196                 case P_OCTAL:
3197                         i = sscanf(pszParmValue, "%o", (int *)parm_ptr);
3198                         if ( i != 1 ) {
3199                             DEBUG ( 0, ("Invalid octal number %s\n", pszParmName ));
3200                         }
3201                         break;
3202
3203                 case P_BYTES:
3204                 {
3205                         uint64_t val;
3206                         if (conv_str_size_error(pszParmValue, &val)) {
3207                                 if (val <= INT_MAX) {
3208                                         *(int *)parm_ptr = (int)val;
3209                                         break;
3210                                 }
3211                         }
3212
3213                         DEBUG(0,("lp_do_parameter(%s): value is not "
3214                             "a valid size specifier!\n", pszParmValue));
3215                         return false;
3216                 }
3217
3218                 case P_LIST:
3219                 case P_CMDLIST:
3220                         TALLOC_FREE(*((char ***)parm_ptr));
3221                         *(char ***)parm_ptr = str_list_make_v3(
3222                                 NULL, pszParmValue, NULL);
3223                         break;
3224
3225                 case P_STRING:
3226                         string_set((char **)parm_ptr, pszParmValue);
3227                         break;
3228
3229                 case P_USTRING:
3230                 {
3231                         char *upper_string = strupper_talloc(talloc_tos(),
3232                                                              pszParmValue);
3233                         string_set((char **)parm_ptr, upper_string);
3234                         TALLOC_FREE(upper_string);
3235                         break;
3236                 }
3237                 case P_ENUM:
3238                         lp_set_enum_parm( &parm_table[parmnum], pszParmValue, (int*)parm_ptr );
3239                         break;
3240                 case P_SEP:
3241                         break;
3242         }
3243
3244         return true;
3245 }
3246
3247 /***************************************************************************
3248 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
3249 FLAG_CMDLINE won't be overridden by loads from smb.conf.
3250 ***************************************************************************/
3251
3252 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue, bool store_values)
3253 {
3254         int parmnum, i;
3255         parmnum = map_parameter(pszParmName);
3256         if (parmnum >= 0) {
3257                 parm_table[parmnum].flags &= ~FLAG_CMDLINE;
3258                 if (!lp_do_parameter(-1, pszParmName, pszParmValue)) {
3259                         return false;
3260                 }
3261                 parm_table[parmnum].flags |= FLAG_CMDLINE;
3262
3263                 /* we have to also set FLAG_CMDLINE on aliases.  Aliases must
3264                  * be grouped in the table, so we don't have to search the
3265                  * whole table */
3266                 for (i=parmnum-1;
3267                      i>=0 && parm_table[i].offset == parm_table[parmnum].offset
3268                              && parm_table[i].p_class == parm_table[parmnum].p_class;
3269                      i--) {
3270                         parm_table[i].flags |= FLAG_CMDLINE;
3271                 }
3272                 for (i=parmnum+1;i<NUMPARAMETERS && parm_table[i].offset == parm_table[parmnum].offset
3273                              && parm_table[i].p_class == parm_table[parmnum].p_class;i++) {
3274                         parm_table[i].flags |= FLAG_CMDLINE;
3275                 }
3276
3277                 if (store_values) {
3278                         store_lp_set_cmdline(pszParmName, pszParmValue);
3279                 }
3280                 return true;
3281         }
3282
3283         /* it might be parametric */
3284         if (strchr(pszParmName, ':') != NULL) {
3285                 set_param_opt(&Globals.param_opt, pszParmName, pszParmValue, FLAG_CMDLINE);
3286                 if (store_values) {
3287                         store_lp_set_cmdline(pszParmName, pszParmValue);
3288                 }
3289                 return true;
3290         }
3291
3292         DEBUG(0, ("Ignoring unknown parameter \"%s\"\n",  pszParmName));
3293         return true;
3294 }
3295
3296 bool lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
3297 {
3298         return lp_set_cmdline_helper(pszParmName, pszParmValue, true);
3299 }
3300
3301 /***************************************************************************
3302  Process a parameter.
3303 ***************************************************************************/
3304
3305 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
3306                          void *userdata)
3307 {
3308         if (!bInGlobalSection && bGlobalOnly)
3309                 return true;
3310
3311         DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
3312
3313         return (lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
3314                                 pszParmName, pszParmValue));
3315 }
3316
3317 /*
3318   set a option from the commandline in 'a=b' format. Use to support --option
3319 */
3320 bool lp_set_option(const char *option)
3321 {
3322         char *p, *s;
3323         bool ret;
3324
3325         s = talloc_strdup(NULL, option);
3326         if (!s) {
3327                 return false;
3328         }
3329
3330         p = strchr(s, '=');
3331         if (!p) {
3332                 talloc_free(s);
3333                 return false;
3334         }
3335
3336         *p = 0;
3337
3338         /* skip white spaces after the = sign */
3339         do {
3340                 p++;
3341         } while (*p == ' ');
3342
3343         ret = lp_set_cmdline(s, p);
3344         talloc_free(s);
3345         return ret;
3346 }
3347
3348 /**************************************************************************
3349  Print a parameter of the specified type.
3350 ***************************************************************************/
3351
3352 static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
3353 {
3354         /* For the seperation of lists values that we print below */
3355         const char *list_sep = ", ";
3356         int i;
3357         switch (p->type)
3358         {
3359                 case P_ENUM:
3360                         for (i = 0; p->enum_list[i].name; i++) {
3361                                 if (*(int *)ptr == p->enum_list[i].value) {
3362                                         fprintf(f, "%s",
3363                                                 p->enum_list[i].name);
3364                                         break;
3365                                 }
3366                         }
3367                         break;
3368
3369                 case P_BOOL:
3370                         fprintf(f, "%s", BOOLSTR(*(bool *)ptr));
3371                         break;
3372
3373                 case P_BOOLREV:
3374                         fprintf(f, "%s", BOOLSTR(!*(bool *)ptr));
3375                         break;
3376
3377                 case P_INTEGER:
3378                 case P_BYTES:
3379                         fprintf(f, "%d", *(int *)ptr);
3380                         break;
3381
3382                 case P_CHAR:
3383                         fprintf(f, "%c", *(char *)ptr);
3384                         break;
3385
3386                 case P_OCTAL: {
3387                         int val = *(int *)ptr;
3388                         if (val == -1) {
3389                                 fprintf(f, "-1");
3390                         } else {
3391                                 fprintf(f, "0%o", val);
3392                         }
3393                         break;
3394                 }
3395
3396                 case P_CMDLIST:
3397                         list_sep = " ";
3398                         /* fall through */
3399                 case P_LIST:
3400                         if ((char ***)ptr && *(char ***)ptr) {
3401                                 char **list = *(char ***)ptr;
3402                                 for (; *list; list++) {
3403                                         /* surround strings with whitespace in double quotes */
3404                                         if (*(list+1) == NULL) {
3405                                                 /* last item, no extra separator */
3406                                                 list_sep = "";
3407                                         }
3408                                         if ( strchr_m( *list, ' ' ) ) {
3409                                                 fprintf(f, "\"%s\"%s", *list, list_sep);
3410                                         } else {
3411                                                 fprintf(f, "%s%s", *list, list_sep);
3412                                         }
3413                                 }
3414                         }
3415                         break;
3416
3417                 case P_STRING:
3418                 case P_USTRING:
3419                         if (*(char **)ptr) {
3420                                 fprintf(f, "%s", *(char **)ptr);
3421                         }
3422                         break;
3423                 case P_SEP:
3424                         break;
3425         }
3426 }
3427
3428 /***************************************************************************
3429  Check if two parameters are equal.
3430 ***************************************************************************/
3431
3432 static bool equal_parameter(parm_type type, void *ptr1, void *ptr2)
3433 {
3434         switch (type) {
3435                 case P_BOOL:
3436                 case P_BOOLREV:
3437                         return (*((bool *)ptr1) == *((bool *)ptr2));
3438
3439                 case P_INTEGER:
3440                 case P_ENUM:
3441                 case P_OCTAL:
3442                 case P_BYTES:
3443                         return (*((int *)ptr1) == *((int *)ptr2));
3444
3445                 case P_CHAR:
3446                         return (*((char *)ptr1) == *((char *)ptr2));
3447
3448                 case P_LIST:
3449                 case P_CMDLIST:
3450                         return str_list_equal(*(const char ***)ptr1, *(const char ***)ptr2);
3451
3452                 case P_STRING:
3453                 case P_USTRING:
3454                 {
3455                         char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
3456                         if (p1 && !*p1)
3457                                 p1 = NULL;
3458                         if (p2 && !*p2)
3459                                 p2 = NULL;
3460                         return (p1 == p2 || strequal(p1, p2));
3461                 }
3462                 case P_SEP:
3463                         break;
3464         }
3465         return false;
3466 }
3467
3468 /***************************************************************************
3469  Initialize any local variables in the sDefault table, after parsing a
3470  [globals] section.
3471 ***************************************************************************/
3472
3473 static void init_locals(void)
3474 {
3475         /*
3476          * We run this check once the [globals] is parsed, to force
3477          * the VFS objects and other per-share settings we need for
3478          * the standard way a AD DC is operated.  We may change these
3479          * as our code evolves, which is why we force these settings.
3480          *
3481          * We can't do this at the end of lp_load_ex(), as by that
3482          * point the services have been loaded and they will already
3483          * have "" as their vfs objects.
3484          */
3485         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
3486                 const char **vfs_objects = lp_vfs_objects(-1);
3487                 if (!vfs_objects || !vfs_objects[0]) {
3488                         if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL)) {
3489                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
3490                         } else if (lp_parm_const_string(-1, "posix", "eadb", NULL)) {
3491                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
3492                         } else {
3493                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
3494                         }
3495                 }
3496
3497                 lp_do_parameter(-1, "map hidden", "no");
3498                 lp_do_parameter(-1, "map system", "no");
3499                 lp_do_parameter(-1, "map readonly", "no");
3500                 lp_do_parameter(-1, "map archive", "no");
3501                 lp_do_parameter(-1, "store dos attributes", "yes");
3502                 lp_do_parameter(-1, "create mask", "0777");
3503                 lp_do_parameter(-1, "directory mask", "0777");
3504         }
3505 }
3506
3507 /***************************************************************************
3508  Process a new section (service). At this stage all sections are services.
3509  Later we'll have special sections that permit server parameters to be set.
3510  Returns true on success, false on failure.
3511 ***************************************************************************/
3512
3513 static bool do_section(const char *pszSectionName, void *userdata)
3514 {
3515         bool bRetval;
3516         bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
3517                          (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
3518         bRetval = false;
3519
3520         /* if we were in a global section then do the local inits */
3521         if (bInGlobalSection && !isglobal)
3522                 init_locals();
3523
3524         /* if we've just struck a global section, note the fact. */
3525         bInGlobalSection = isglobal;
3526
3527         /* check for multiple global sections */
3528         if (bInGlobalSection) {
3529                 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
3530                 return true;
3531         }
3532
3533         if (!bInGlobalSection && bGlobalOnly)
3534                 return true;
3535
3536         /* if we have a current service, tidy it up before moving on */
3537         bRetval = true;
3538
3539         if (iServiceIndex >= 0)
3540                 bRetval = service_ok(iServiceIndex);
3541
3542         /* if all is still well, move to the next record in the services array */
3543         if (bRetval) {
3544                 /* We put this here to avoid an odd message order if messages are */
3545                 /* issued by the post-processing of a previous section. */
3546                 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
3547
3548                 iServiceIndex = add_a_service(&sDefault, pszSectionName);
3549                 if (iServiceIndex < 0) {
3550                         DEBUG(0, ("Failed to add a new service\n"));
3551                         return false;
3552                 }
3553                 /* Clean all parametric options for service */
3554                 /* They will be added during parsing again */
3555                 free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
3556         }
3557
3558         return bRetval;
3559 }
3560
3561
3562 /***************************************************************************
3563  Determine if a partcular base parameter is currentl set to the default value.
3564 ***************************************************************************/
3565
3566 static bool is_default(int i)
3567 {
3568         if (!defaults_saved)
3569                 return false;
3570         switch (parm_table[i].type) {
3571                 case P_LIST:
3572                 case P_CMDLIST:
3573                         return str_list_equal((const char **)parm_table[i].def.lvalue,
3574                                               *(const char ***)lp_parm_ptr(NULL,
3575                                                                            &parm_table[i]));
3576                 case P_STRING:
3577                 case P_USTRING:
3578                         return strequal(parm_table[i].def.svalue,
3579                                         *(char **)lp_parm_ptr(NULL,
3580                                                               &parm_table[i]));
3581                 case P_BOOL:
3582                 case P_BOOLREV:
3583                         return parm_table[i].def.bvalue ==
3584                                 *(bool *)lp_parm_ptr(NULL,
3585                                                      &parm_table[i]);
3586                 case P_CHAR:
3587                         return parm_table[i].def.cvalue ==
3588                                 *(char *)lp_parm_ptr(NULL,
3589                                                      &parm_table[i]);
3590                 case P_INTEGER:
3591                 case P_OCTAL:
3592                 case P_ENUM:
3593                 case P_BYTES:
3594                         return parm_table[i].def.ivalue ==
3595                                 *(int *)lp_parm_ptr(NULL,
3596                                                     &parm_table[i]);
3597                 case P_SEP:
3598                         break;
3599         }
3600         return false;
3601 }
3602
3603 /***************************************************************************
3604 Display the contents of the global structure.
3605 ***************************************************************************/
3606
3607 static void dump_globals(FILE *f)
3608 {
3609         int i;
3610         struct parmlist_entry *data;
3611
3612         fprintf(f, "[global]\n");
3613
3614         for (i = 0; parm_table[i].label; i++)
3615                 if (parm_table[i].p_class == P_GLOBAL &&
3616                     !(parm_table[i].flags & FLAG_META) &&
3617                     (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset))) {
3618                         if (defaults_saved && is_default(i))
3619                                 continue;
3620                         fprintf(f, "\t%s = ", parm_table[i].label);
3621                         print_parameter(&parm_table[i], lp_parm_ptr(NULL,
3622                                                                     &parm_table[i]),
3623                                         f);
3624                         fprintf(f, "\n");
3625         }
3626         if (Globals.param_opt != NULL) {
3627                 data = Globals.param_opt;
3628                 while(data) {
3629                         fprintf(f, "\t%s = %s\n", data->key, data->value);
3630                         data = data->next;
3631                 }
3632         }
3633
3634 }
3635
3636 /***************************************************************************
3637  Return true if a local parameter is currently set to the global default.
3638 ***************************************************************************/
3639
3640 bool lp_is_default(int snum, struct parm_struct *parm)
3641 {
3642         return equal_parameter(parm->type,
3643                                lp_parm_ptr(ServicePtrs[snum], parm),
3644                                lp_parm_ptr(NULL, parm));
3645 }
3646
3647 /***************************************************************************
3648  Display the contents of a single services record.
3649 ***************************************************************************/
3650
3651 static void dump_a_service(struct loadparm_service *pService, FILE * f)
3652 {
3653         int i;
3654         struct parmlist_entry *data;
3655
3656         if (pService != &sDefault)
3657                 fprintf(f, "[%s]\n", pService->szService);
3658
3659         for (i = 0; parm_table[i].label; i++) {
3660
3661                 if (parm_table[i].p_class == P_LOCAL &&
3662                     !(parm_table[i].flags & FLAG_META) &&
3663                     (*parm_table[i].label != '-') &&
3664                     (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset)))
3665                 {
3666                         if (pService == &sDefault) {
3667                                 if (defaults_saved && is_default(i))
3668                                         continue;
3669                         } else {
3670                                 if (equal_parameter(parm_table[i].type,
3671                                                     lp_parm_ptr(pService, &parm_table[i]),
3672                                                     lp_parm_ptr(NULL, &parm_table[i])))
3673                                         continue;
3674                         }
3675
3676                         fprintf(f, "\t%s = ", parm_table[i].label);
3677                         print_parameter(&parm_table[i],
3678                                         lp_parm_ptr(pService, &parm_table[i]),
3679                                         f);
3680                         fprintf(f, "\n");
3681                 }
3682         }
3683
3684                 if (pService->param_opt != NULL) {
3685                         data = pService->param_opt;
3686                         while(data) {
3687                                 fprintf(f, "\t%s = %s\n", data->key, data->value);
3688                                 data = data->next;
3689                         }
3690                 }
3691 }
3692
3693 /***************************************************************************
3694  Display the contents of a parameter of a single services record.
3695 ***************************************************************************/
3696
3697 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
3698 {
3699         int i;
3700         bool result = false;
3701         parm_class p_class;
3702         unsigned flag = 0;
3703         fstring local_parm_name;
3704         char *parm_opt;
3705         const char *parm_opt_value;
3706
3707         /* check for parametrical option */
3708         fstrcpy( local_parm_name, parm_name);
3709         parm_opt = strchr( local_parm_name, ':');
3710
3711         if (parm_opt) {
3712                 *parm_opt = '\0';
3713                 parm_opt++;
3714                 if (strlen(parm_opt)) {
3715                         parm_opt_value = lp_parm_const_string( snum,
3716                                 local_parm_name, parm_opt, NULL);
3717                         if (parm_opt_value) {
3718                                 printf( "%s\n", parm_opt_value);
3719                                 result = true;
3720                         }
3721                 }
3722                 return result;
3723         }
3724
3725         /* check for a key and print the value */
3726         if (isGlobal) {
3727                 p_class = P_GLOBAL;
3728                 flag = FLAG_GLOBAL;
3729         } else
3730                 p_class = P_LOCAL;
3731
3732         for (i = 0; parm_table[i].label; i++) {
3733                 if (strwicmp(parm_table[i].label, parm_name) == 0 &&
3734                     !(parm_table[i].flags & FLAG_META) &&
3735                     (parm_table[i].p_class == p_class || parm_table[i].flags & flag) &&
3736                     (*parm_table[i].label != '-') &&
3737                     (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset)))
3738                 {
3739                         void *ptr;
3740
3741                         if (isGlobal) {
3742                                 ptr = lp_parm_ptr(NULL,
3743                                                   &parm_table[i]);
3744                         } else {
3745                                 ptr = lp_parm_ptr(ServicePtrs[snum],
3746                                                   &parm_table[i]);
3747                         }
3748
3749                         print_parameter(&parm_table[i],
3750                                         ptr, f);
3751                         fprintf(f, "\n");
3752                         result = true;
3753                         break;
3754                 }
3755         }
3756
3757         return result;
3758 }
3759
3760 /***************************************************************************
3761  Return info about the requested parameter (given as a string).
3762  Return NULL when the string is not a valid parameter name.
3763 ***************************************************************************/
3764
3765 struct parm_struct *lp_get_parameter(const char *param_name)
3766 {
3767         int num = map_parameter(param_name);
3768
3769         if (num < 0) {
3770                 return NULL;
3771         }
3772
3773         return &parm_table[num];
3774 }
3775
3776 /***************************************************************************
3777  Return info about the next parameter in a service.
3778  snum==GLOBAL_SECTION_SNUM gives the globals.
3779  Return NULL when out of parameters.
3780 ***************************************************************************/
3781
3782 struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters)
3783 {
3784         if (snum < 0) {
3785                 /* do the globals */
3786                 for (; parm_table[*i].label; (*i)++) {
3787                         if (parm_table[*i].p_class == P_SEPARATOR)
3788                                 return &parm_table[(*i)++];
3789
3790                         if ((*parm_table[*i].label == '-'))
3791                                 continue;
3792
3793                         if ((*i) > 0
3794                             && (parm_table[*i].offset ==
3795                                 parm_table[(*i) - 1].offset)
3796                             && (parm_table[*i].p_class ==
3797                                 parm_table[(*i) - 1].p_class))
3798                                 continue;
3799
3800                         if (is_default(*i) && !allparameters)
3801                                 continue;
3802
3803                         return &parm_table[(*i)++];
3804                 }
3805         } else {
3806                 struct loadparm_service *pService = ServicePtrs[snum];
3807
3808                 for (; parm_table[*i].label; (*i)++) {
3809                         if (parm_table[*i].p_class == P_SEPARATOR)
3810                                 return &parm_table[(*i)++];
3811
3812                         if (parm_table[*i].p_class == P_LOCAL &&
3813                             (*parm_table[*i].label != '-') &&
3814                             ((*i) == 0 ||
3815                              (parm_table[*i].offset !=
3816                               parm_table[(*i) - 1].offset)))
3817                         {
3818                                 if (allparameters ||
3819                                     !equal_parameter(parm_table[*i].type,
3820                                                      lp_parm_ptr(pService,
3821                                                                  &parm_table[*i]),
3822                                                      lp_parm_ptr(NULL,
3823                                                                  &parm_table[*i])))
3824                                 {
3825                                         return &parm_table[(*i)++];
3826                                 }
3827                         }
3828                 }
3829         }
3830
3831         return NULL;
3832 }
3833
3834
3835 #if 0
3836 /***************************************************************************
3837  Display the contents of a single copy structure.
3838 ***************************************************************************/
3839 static void dump_copy_map(bool *pcopymap)
3840 {
3841         int i;
3842         if (!pcopymap)
3843                 return;
3844
3845         printf("\n\tNon-Copied parameters:\n");
3846
3847         for (i = 0; parm_table[i].label; i++)
3848                 if (parm_table[i].p_class == P_LOCAL &&
3849                     parm_table[i].ptr && !pcopymap[i] &&
3850                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
3851                 {
3852                         printf("\t\t%s\n", parm_table[i].label);
3853                 }
3854 }
3855 #endif
3856
3857 /***************************************************************************
3858  Return TRUE if the passed service number is within range.
3859 ***************************************************************************/
3860
3861 bool lp_snum_ok(int iService)
3862 {
3863         return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
3864 }
3865
3866 /***************************************************************************
3867  Auto-load some home services.
3868 ***************************************************************************/
3869
3870 static void lp_add_auto_services(char *str)
3871 {
3872         char *s;
3873         char *p;
3874         int homes;
3875         char *saveptr;
3876
3877         if (!str)
3878                 return;
3879
3880         s = SMB_STRDUP(str);
3881         if (!s)
3882                 return;
3883
3884         homes = lp_servicenumber(HOMES_NAME);
3885
3886         for (p = strtok_r(s, LIST_SEP, &saveptr); p;
3887              p = strtok_r(NULL, LIST_SEP, &saveptr)) {
3888                 char *home;
3889
3890                 if (lp_servicenumber(p) >= 0)
3891                         continue;
3892
3893                 home = get_user_home_dir(talloc_tos(), p);
3894
3895                 if (home && home[0] && homes >= 0)
3896                         lp_add_home(p, homes, p, home);
3897
3898                 TALLOC_FREE(home);
3899         }
3900         SAFE_FREE(s);
3901 }
3902
3903 /***************************************************************************
3904  Auto-load one printer.
3905 ***************************************************************************/
3906
3907 void lp_add_one_printer(const char *name, const char *comment,
3908                         const char *location, void *pdata)
3909 {
3910         int printers = lp_servicenumber(PRINTERS_NAME);
3911         int i;
3912
3913         if (lp_servicenumber(name) < 0) {
3914                 lp_add_printer(name, printers);
3915                 if ((i = lp_servicenumber(name)) >= 0) {
3916                         string_set(&ServicePtrs[i]->comment, comment);
3917                         ServicePtrs[i]->autoloaded = true;
3918                 }
3919         }
3920 }
3921
3922 /***************************************************************************
3923  Have we loaded a services file yet?
3924 ***************************************************************************/
3925
3926 bool lp_loaded(void)
3927 {
3928         return (bLoaded);
3929 }
3930
3931 /***************************************************************************
3932  Unload unused services.
3933 ***************************************************************************/
3934
3935 void lp_killunused(struct smbd_server_connection *sconn,
3936                    bool (*snumused) (struct smbd_server_connection *, int))
3937 {
3938         int i;
3939         for (i = 0; i < iNumServices; i++) {
3940                 if (!VALID(i))
3941                         continue;
3942
3943                 /* don't kill autoloaded or usershare services */
3944                 if ( ServicePtrs[i]->autoloaded ||
3945                                 ServicePtrs[i]->usershare == USERSHARE_VALID) {
3946                         continue;
3947                 }
3948
3949                 if (!snumused || !snumused(sconn, i)) {
3950                         free_service_byindex(i);
3951                 }
3952         }
3953 }
3954
3955 /**
3956  * Kill all except autoloaded and usershare services - convenience wrapper
3957  */
3958 void lp_kill_all_services(void)
3959 {
3960         lp_killunused(NULL, NULL);
3961 }
3962
3963 /***************************************************************************
3964  Unload a service.
3965 ***************************************************************************/
3966
3967 void lp_killservice(int iServiceIn)
3968 {
3969         if (VALID(iServiceIn)) {
3970                 free_service_byindex(iServiceIn);
3971         }
3972 }
3973
3974 /***************************************************************************
3975  Save the curent values of all global and sDefault parameters into the
3976  defaults union. This allows swat and testparm to show only the
3977  changed (ie. non-default) parameters.
3978 ***************************************************************************/
3979
3980 static void lp_save_defaults(void)
3981 {
3982         int i;
3983         for (i = 0; parm_table[i].label; i++) {
3984                 if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
3985                     && parm_table[i].p_class == parm_table[i - 1].p_class)
3986                         continue;
3987                 switch (parm_table[i].type) {
3988                         case P_LIST:
3989                         case P_CMDLIST:
3990                                 parm_table[i].def.lvalue = str_list_copy(
3991                                         NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
3992                                 break;
3993                         case P_STRING:
3994                         case P_USTRING:
3995                                 parm_table[i].def.svalue = SMB_STRDUP(*(char **)lp_parm_ptr(NULL, &parm_table[i]));
3996                                 break;
3997                         case P_BOOL:
3998                         case P_BOOLREV:
3999                                 parm_table[i].def.bvalue =
4000                                         *(bool *)lp_parm_ptr(NULL, &parm_table[i]);
4001                                 break;
4002                         case P_CHAR:
4003                                 parm_table[i].def.cvalue =
4004                                         *(char *)lp_parm_ptr(NULL, &parm_table[i]);
4005                                 break;
4006                         case P_INTEGER:
4007                         case P_OCTAL:
4008                         case P_ENUM:
4009                         case P_BYTES:
4010                                 parm_table[i].def.ivalue =
4011                                         *(int *)lp_parm_ptr(NULL, &parm_table[i]);
4012                                 break;
4013                         case P_SEP:
4014                                 break;
4015                 }
4016         }
4017         defaults_saved = true;
4018 }
4019
4020 /***********************************************************
4021  If we should send plaintext/LANMAN passwords in the clinet
4022 ************************************************************/
4023
4024 static void set_allowed_client_auth(void)
4025 {
4026         if (Globals.bClientNTLMv2Auth) {
4027                 Globals.bClientLanManAuth = false;
4028         }
4029         if (!Globals.bClientLanManAuth) {
4030                 Globals.bClientPlaintextAuth = false;
4031         }
4032 }
4033
4034 /***************************************************************************
4035  JRA.
4036  The following code allows smbd to read a user defined share file.
4037  Yes, this is my intent. Yes, I'm comfortable with that...
4038
4039  THE FOLLOWING IS SECURITY CRITICAL CODE.
4040
4041  It washes your clothes, it cleans your house, it guards you while you sleep...
4042  Do not f%^k with it....
4043 ***************************************************************************/
4044
4045 #define MAX_USERSHARE_FILE_SIZE (10*1024)
4046
4047 /***************************************************************************
4048  Check allowed stat state of a usershare file.
4049  Ensure we print out who is dicking with us so the admin can
4050  get their sorry ass fired.
4051 ***************************************************************************/
4052
4053 static bool check_usershare_stat(const char *fname,
4054                                  const SMB_STRUCT_STAT *psbuf)
4055 {
4056         if (!S_ISREG(psbuf->st_ex_mode)) {
4057                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
4058                         "not a regular file\n",
4059                         fname, (unsigned int)psbuf->st_ex_uid ));
4060                 return false;
4061         }
4062
4063         /* Ensure this doesn't have the other write bit set. */
4064         if (psbuf->st_ex_mode & S_IWOTH) {
4065                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
4066                         "public write. Refusing to allow as a usershare file.\n",
4067                         fname, (unsigned int)psbuf->st_ex_uid ));
4068                 return false;
4069         }
4070
4071         /* Should be 10k or less. */
4072         if (psbuf->st_ex_size > MAX_USERSHARE_FILE_SIZE) {
4073                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
4074                         "too large (%u) to be a user share file.\n",
4075                         fname, (unsigned int)psbuf->st_ex_uid,
4076                         (unsigned int)psbuf->st_ex_size ));
4077                 return false;
4078         }
4079
4080         return true;
4081 }
4082
4083 /***************************************************************************
4084  Parse the contents of a usershare file.
4085 ***************************************************************************/
4086
4087 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
4088                         SMB_STRUCT_STAT *psbuf,
4089                         const char *servicename,
4090                         int snum,
4091                         char **lines,
4092                         int numlines,
4093                         char **pp_sharepath,
4094                         char **pp_comment,
4095                         char **pp_cp_servicename,
4096                         struct security_descriptor **ppsd,
4097                         bool *pallow_guest)
4098 {
4099         const char **prefixallowlist = lp_usershare_prefix_allow_list();
4100         const char **prefixdenylist = lp_usershare_prefix_deny_list();
4101         int us_vers;
4102         DIR *dp;
4103         SMB_STRUCT_STAT sbuf;
4104         char *sharepath = NULL;
4105         char *comment = NULL;
4106
4107         *pp_sharepath = NULL;
4108         *pp_comment = NULL;
4109
4110         *pallow_guest = false;
4111
4112         if (numlines < 4) {
4113                 return USERSHARE_MALFORMED_FILE;
4114         }
4115
4116         if (strcmp(lines[0], "#VERSION 1") == 0) {
4117                 us_vers = 1;
4118         } else if (strcmp(lines[0], "#VERSION 2") == 0) {
4119                 us_vers = 2;
4120                 if (numlines < 5) {
4121                         return USERSHARE_MALFORMED_FILE;
4122                 }
4123         } else {
4124                 return USERSHARE_BAD_VERSION;
4125         }
4126
4127         if (strncmp(lines[1], "path=", 5) != 0) {
4128                 return USERSHARE_MALFORMED_PATH;
4129         }
4130
4131         sharepath = talloc_strdup(ctx, &lines[1][5]);
4132         if (!sharepath) {
4133                 return USERSHARE_POSIX_ERR;
4134         }
4135         trim_string(sharepath, " ", " ");
4136
4137         if (strncmp(lines[2], "comment=", 8) != 0) {
4138                 return USERSHARE_MALFORMED_COMMENT_DEF;
4139         }
4140
4141         comment = talloc_strdup(ctx, &lines[2][8]);
4142         if (!comment) {
4143                 return USERSHARE_POSIX_ERR;
4144         }
4145         trim_string(comment, " ", " ");
4146         trim_char(comment, '"', '"');
4147
4148         if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
4149                 return USERSHARE_MALFORMED_ACL_DEF;
4150         }
4151
4152         if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
4153                 return USERSHARE_ACL_ERR;
4154         }
4155
4156         if (us_vers == 2) {
4157                 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
4158                         return USERSHARE_MALFORMED_ACL_DEF;
4159                 }
4160                 if (lines[4][9] == 'y') {
4161                         *pallow_guest = true;
4162                 }
4163
4164                 /* Backwards compatible extension to file version #2. */
4165                 if (numlines > 5) {
4166                         if (strncmp(lines[5], "sharename=", 10) != 0) {
4167                                 return USERSHARE_MALFORMED_SHARENAME_DEF;
4168                         }
4169                         if (!strequal(&lines[5][10], servicename)) {
4170                                 return USERSHARE_BAD_SHARENAME;
4171                         }
4172                         *pp_cp_servicename = talloc_strdup(ctx, &lines[5][10]);
4173                         if (!*pp_cp_servicename) {
4174                                 return USERSHARE_POSIX_ERR;
4175                         }
4176                 }
4177         }
4178
4179         if (*pp_cp_servicename == NULL) {
4180                 *pp_cp_servicename = talloc_strdup(ctx, servicename);
4181                 if (!*pp_cp_servicename) {
4182                         return USERSHARE_POSIX_ERR;
4183                 }
4184         }
4185
4186         if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->szPath) == 0)) {
4187                 /* Path didn't change, no checks needed. */
4188                 *pp_sharepath = sharepath;
4189                 *pp_comment = comment;
4190                 return USERSHARE_OK;
4191         }
4192
4193         /* The path *must* be absolute. */
4194         if (sharepath[0] != '/') {
4195                 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
4196                         servicename, sharepath));
4197                 return USERSHARE_PATH_NOT_ABSOLUTE;
4198         }
4199
4200         /* If there is a usershare prefix deny list ensure one of these paths
4201            doesn't match the start of the user given path. */
4202         if (prefixdenylist) {
4203                 int i;
4204                 for ( i=0; prefixdenylist[i]; i++ ) {
4205                         DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
4206                                 servicename, i, prefixdenylist[i], sharepath ));
4207                         if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
4208                                 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
4209                                         "usershare prefix deny list entries.\n",
4210                                         servicename, sharepath));
4211                                 return USERSHARE_PATH_IS_DENIED;
4212                         }
4213                 }
4214         }
4215
4216         /* If there is a usershare prefix allow list ensure one of these paths
4217            does match the start of the user given path. */
4218
4219         if (prefixallowlist) {
4220                 int i;
4221                 for ( i=0; prefixallowlist[i]; i++ ) {
4222                         DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
4223                                 servicename, i, prefixallowlist[i], sharepath ));
4224                         if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
4225                                 break;
4226                         }
4227                 }
4228                 if (prefixallowlist[i] == NULL) {
4229                         DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
4230                                 "usershare prefix allow list entries.\n",
4231                                 servicename, sharepath));
4232                         return USERSHARE_PATH_NOT_ALLOWED;
4233                 }
4234         }
4235
4236         /* Ensure this is pointing to a directory. */
4237         dp = opendir(sharepath);
4238
4239         if (!dp) {
4240                 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
4241                         servicename, sharepath));
4242                 return USERSHARE_PATH_NOT_DIRECTORY;
4243         }
4244
4245         /* Ensure the owner of the usershare file has permission to share
4246            this directory. */
4247
4248         if (sys_stat(sharepath, &sbuf, false) == -1) {
4249                 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
4250                         servicename, sharepath, strerror(errno) ));
4251                 closedir(dp);
4252                 return USERSHARE_POSIX_ERR;
4253         }
4254
4255         closedir(dp);
4256
4257         if (!S_ISDIR(sbuf.st_ex_mode)) {
4258                 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
4259                         servicename, sharepath ));
4260                 return USERSHARE_PATH_NOT_DIRECTORY;
4261         }
4262
4263         /* Check if sharing is restricted to owner-only. */
4264         /* psbuf is the stat of the usershare definition file,
4265            sbuf is the stat of the target directory to be shared. */
4266
4267         if (lp_usershare_owner_only()) {
4268                 /* root can share anything. */
4269                 if ((psbuf->st_ex_uid != 0) && (sbuf.st_ex_uid != psbuf->st_ex_uid)) {
4270                         return USERSHARE_PATH_NOT_ALLOWED;
4271                 }
4272         }
4273
4274         *pp_sharepath = sharepath;
4275         *pp_comment = comment;
4276         return USERSHARE_OK;
4277 }
4278
4279 /***************************************************************************
4280  Deal with a usershare file.
4281  Returns:
4282         >= 0 - snum
4283         -1 - Bad name, invalid contents.
4284            - service name already existed and not a usershare, problem
4285             with permissions to share directory etc.
4286 ***************************************************************************/
4287
4288 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
4289 {
4290         SMB_STRUCT_STAT sbuf;
4291         SMB_STRUCT_STAT lsbuf;
4292         char *fname = NULL;
4293         char *sharepath = NULL;
4294         char *comment = NULL;
4295         char *cp_service_name = NULL;
4296         char **lines = NULL;
4297         int numlines = 0;
4298         int fd = -1;
4299         int iService = -1;
4300         TALLOC_CTX *ctx = talloc_stackframe();
4301         struct security_descriptor *psd = NULL;
4302         bool guest_ok = false;
4303         char *canon_name = NULL;
4304         bool added_service = false;
4305         int ret = -1;
4306
4307         /* Ensure share name doesn't contain invalid characters. */
4308         if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
4309                 DEBUG(0,("process_usershare_file: share name %s contains "
4310                         "invalid characters (any of %s)\n",
4311                         file_name, INVALID_SHARENAME_CHARS ));
4312                 goto out;
4313         }
4314
4315         canon_name = canonicalize_servicename(ctx, file_name);
4316         if (!canon_name) {
4317                 goto out;
4318         }
4319
4320         fname = talloc_asprintf(ctx, "%s/%s", dir_name, file_name);
4321         if (!fname) {
4322                 goto out;
4323         }
4324
4325         /* Minimize the race condition by doing an lstat before we
4326            open and fstat. Ensure this isn't a symlink link. */
4327
4328         if (sys_lstat(fname, &lsbuf, false) != 0) {
4329                 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
4330                         fname, strerror(errno) ));
4331                 goto out;
4332         }
4333
4334         /* This must be a regular file, not a symlink, directory or
4335            other strange filetype. */
4336         if (!check_usershare_stat(fname, &lsbuf)) {
4337                 goto out;
4338         }
4339
4340         {
4341                 TDB_DATA data;
4342                 NTSTATUS status;
4343
4344                 status = dbwrap_fetch_bystring(ServiceHash, canon_name,
4345                                                canon_name, &data);
4346
4347                 iService = -1;
4348
4349                 if (NT_STATUS_IS_OK(status) &&
4350                     (data.dptr != NULL) &&
4351                     (data.dsize == sizeof(iService))) {
4352                         memcpy(&iService, data.dptr, sizeof(iService));
4353                 }
4354         }
4355
4356         if (iService != -1 &&
4357             timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
4358                              &lsbuf.st_ex_mtime) == 0) {
4359                 /* Nothing changed - Mark valid and return. */
4360                 DEBUG(10,("process_usershare_file: service %s not changed.\n",
4361                         canon_name ));
4362                 ServicePtrs[iService]->usershare = USERSHARE_VALID;
4363                 ret = iService;
4364                 goto out;
4365         }
4366
4367         /* Try and open the file read only - no symlinks allowed. */
4368 #ifdef O_NOFOLLOW
4369         fd = open(fname, O_RDONLY|O_NOFOLLOW, 0);
4370 #else
4371         fd = open(fname, O_RDONLY, 0);
4372 #endif
4373
4374         if (fd == -1) {
4375                 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
4376                         fname, strerror(errno) ));
4377                 goto out;
4378         }
4379
4380         /* Now fstat to be *SURE* it's a regular file. */
4381         if (sys_fstat(fd, &sbuf, false) != 0) {
4382                 close(fd);
4383                 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
4384                         fname, strerror(errno) ));
4385                 goto out;
4386         }
4387
4388         /* Is it the same dev/inode as was lstated ? */
4389         if (!check_same_stat(&lsbuf, &sbuf)) {
4390                 close(fd);
4391                 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
4392                         "Symlink spoofing going on ?\n", fname ));
4393                 goto out;
4394         }
4395
4396         /* This must be a regular file, not a symlink, directory or
4397            other strange filetype. */
4398         if (!check_usershare_stat(fname, &sbuf)) {
4399                 goto out;
4400         }
4401
4402         lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE, NULL);
4403
4404         close(fd);
4405         if (lines == NULL) {
4406                 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
4407                         fname, (unsigned int)sbuf.st_ex_uid ));
4408                 goto out;
4409         }
4410
4411         if (parse_usershare_file(ctx, &sbuf, file_name,
4412                         iService, lines, numlines, &sharepath,
4413                         &comment, &cp_service_name,
4414                         &psd, &guest_ok) != USERSHARE_OK) {
4415                 goto out;
4416         }
4417
4418         /* Everything ok - add the service possibly using a template. */
4419         if (iService < 0) {
4420                 const struct loadparm_service *sp = &sDefault;
4421                 if (snum_template != -1) {
4422                         sp = ServicePtrs[snum_template];
4423                 }
4424
4425                 if ((iService = add_a_service(sp, cp_service_name)) < 0) {
4426                         DEBUG(0, ("process_usershare_file: Failed to add "
4427                                 "new service %s\n", cp_service_name));
4428                         goto out;
4429                 }
4430
4431                 added_service = true;
4432
4433                 /* Read only is controlled by usershare ACL below. */
4434                 ServicePtrs[iService]->bRead_only = false;
4435         }
4436
4437         /* Write the ACL of the new/modified share. */
4438         if (!set_share_security(canon_name, psd)) {
4439                  DEBUG(0, ("process_usershare_file: Failed to set share "
4440                         "security for user share %s\n",
4441                         canon_name ));
4442                 goto out;
4443         }
4444
4445         /* If from a template it may be marked invalid. */
4446         ServicePtrs[iService]->valid = true;
4447
4448         /* Set the service as a valid usershare. */
4449         ServicePtrs[iService]->usershare = USERSHARE_VALID;
4450
4451         /* Set guest access. */
4452         if (lp_usershare_allow_guests()) {
4453                 ServicePtrs[iService]->bGuest_ok = guest_ok;
4454         }
4455
4456         /* And note when it was loaded. */
4457         ServicePtrs[iService]->usershare_last_mod = sbuf.st_ex_mtime;
4458         string_set(&ServicePtrs[iService]->szPath, sharepath);
4459         string_set(&ServicePtrs[iService]->comment, comment);
4460
4461         ret = iService;
4462
4463   out:
4464
4465         if (ret == -1 && iService != -1 && added_service) {
4466                 lp_remove_service(iService);
4467         }
4468
4469         TALLOC_FREE(lines);
4470         TALLOC_FREE(ctx);
4471         return ret;
4472 }
4473
4474 /***************************************************************************
4475  Checks if a usershare entry has been modified since last load.
4476 ***************************************************************************/
4477
4478 static bool usershare_exists(int iService, struct timespec *last_mod)
4479 {
4480         SMB_STRUCT_STAT lsbuf;
4481         const char *usersharepath = Globals.szUsersharePath;
4482         char *fname;
4483
4484         if (asprintf(&fname, "%s/%s",
4485                                 usersharepath,
4486                                 ServicePtrs[iService]->szService) < 0) {
4487                 return false;
4488         }
4489
4490         if (sys_lstat(fname, &lsbuf, false) != 0) {
4491                 SAFE_FREE(fname);
4492                 return false;
4493         }
4494
4495         if (!S_ISREG(lsbuf.st_ex_mode)) {
4496                 SAFE_FREE(fname);
4497                 return false;
4498         }
4499
4500         SAFE_FREE(fname);
4501         *last_mod = lsbuf.st_ex_mtime;
4502         return true;
4503 }
4504
4505 /***************************************************************************
4506  Load a usershare service by name. Returns a valid servicenumber or -1.
4507 ***************************************************************************/
4508
4509 int load_usershare_service(const char *servicename)
4510 {
4511         SMB_STRUCT_STAT sbuf;
4512         const char *usersharepath = Globals.szUsersharePath;
4513         int max_user_shares = Globals.iUsershareMaxShares;
4514         int snum_template = -1;
4515
4516         if (*usersharepath == 0 ||  max_user_shares == 0) {
4517                 return -1;
4518         }
4519
4520         if (sys_stat(usersharepath, &sbuf, false) != 0) {
4521                 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
4522                         usersharepath, strerror(errno) ));
4523                 return -1;
4524         }
4525
4526         if (!S_ISDIR(sbuf.st_ex_mode)) {
4527                 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
4528                         usersharepath ));
4529                 return -1;
4530         }
4531
4532         /*
4533          * This directory must be owned by root, and have the 't' bit set.
4534          * It also must not be writable by "other".
4535          */
4536
4537 #ifdef S_ISVTX
4538         if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
4539 #else
4540         if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
4541 #endif
4542                 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
4543                         "or does not have the sticky bit 't' set or is writable by anyone.\n",
4544                         usersharepath ));
4545                 return -1;
4546         }
4547
4548         /* Ensure the template share exists if it's set. */
4549         if (Globals.szUsershareTemplateShare[0]) {
4550                 /* We can't use lp_servicenumber here as we are recommending that
4551                    template shares have -valid=false set. */
4552                 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
4553                         if (ServicePtrs[snum_template]->szService &&
4554                                         strequal(ServicePtrs[snum_template]->szService,
4555                                                 Globals.szUsershareTemplateShare)) {
4556                                 break;
4557                         }
4558                 }
4559
4560                 if (snum_template == -1) {
4561                         DEBUG(0,("load_usershare_service: usershare template share %s "
4562                                 "does not exist.\n",
4563                                 Globals.szUsershareTemplateShare ));
4564                         return -1;
4565                 }
4566         }
4567
4568         return process_usershare_file(usersharepath, servicename, snum_template);
4569 }
4570
4571 /***************************************************************************
4572  Load all user defined shares from the user share directory.
4573  We only do this if we're enumerating the share list.
4574  This is the function that can delete usershares that have
4575  been removed.
4576 ***************************************************************************/
4577
4578 int load_usershare_shares(struct smbd_server_connection *sconn,
4579                           bool (*snumused) (struct smbd_server_connection *, int))
4580 {
4581         DIR *dp;
4582         SMB_STRUCT_STAT sbuf;
4583         struct dirent *de;
4584         int num_usershares = 0;
4585         int max_user_shares = Globals.iUsershareMaxShares;
4586         unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
4587         unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
4588         unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
4589         int iService;
4590         int snum_template = -1;
4591         const char *usersharepath = Globals.szUsersharePath;
4592         int ret = lp_numservices();
4593         TALLOC_CTX *tmp_ctx;
4594
4595         if (max_user_shares == 0 || *usersharepath == '\0') {
4596                 return lp_numservices();
4597         }
4598
4599         if (sys_stat(usersharepath, &sbuf, false) != 0) {
4600                 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
4601                         usersharepath, strerror(errno) ));
4602                 return ret;
4603         }
4604
4605         /*
4606          * This directory must be owned by root, and have the 't' bit set.
4607          * It also must not be writable by "other".
4608          */
4609
4610 #ifdef S_ISVTX
4611         if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
4612 #else
4613         if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
4614 #endif
4615                 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
4616                         "or does not have the sticky bit 't' set or is writable by anyone.\n",
4617                         usersharepath ));
4618                 return ret;
4619         }
4620
4621         /* Ensure the template share exists if it's set. */
4622         if (Globals.szUsershareTemplateShare[0]) {
4623                 /* We can't use lp_servicenumber here as we are recommending that
4624                    template shares have -valid=false set. */
4625                 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
4626                         if (ServicePtrs[snum_template]->szService &&
4627                                         strequal(ServicePtrs[snum_template]->szService,
4628                                                 Globals.szUsershareTemplateShare)) {
4629                                 break;
4630                         }
4631                 }
4632
4633                 if (snum_template == -1) {
4634                         DEBUG(0,("load_usershare_shares: usershare template share %s "
4635                                 "does not exist.\n",
4636                                 Globals.szUsershareTemplateShare ));
4637                         return ret;
4638                 }
4639         }
4640
4641         /* Mark all existing usershares as pending delete. */
4642         for (iService = iNumServices - 1; iService >= 0; iService--) {
4643                 if (VALID(iService) && ServicePtrs[iService]->usershare) {
4644                         ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
4645                 }
4646         }
4647
4648         dp = opendir(usersharepath);
4649         if (!dp) {
4650                 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
4651                         usersharepath, strerror(errno) ));
4652                 return ret;
4653         }
4654
4655         for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
4656                         (de = readdir(dp));
4657                         num_dir_entries++ ) {
4658                 int r;
4659                 const char *n = de->d_name;
4660
4661                 /* Ignore . and .. */
4662                 if (*n == '.') {
4663                         if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
4664                                 continue;
4665                         }
4666                 }
4667
4668                 if (n[0] == ':') {
4669                         /* Temporary file used when creating a share. */
4670                         num_tmp_dir_entries++;
4671                 }
4672
4673                 /* Allow 20% tmp entries. */
4674                 if (num_tmp_dir_entries > allowed_tmp_entries) {
4675                         DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
4676                                 "in directory %s\n",
4677                                 num_tmp_dir_entries, usersharepath));
4678                         break;
4679                 }
4680
4681                 r = process_usershare_file(usersharepath, n, snum_template);
4682                 if (r == 0) {
4683                         /* Update the services count. */
4684                         num_usershares++;
4685                         if (num_usershares >= max_user_shares) {
4686                                 DEBUG(0,("load_usershare_shares: max user shares reached "
4687                                         "on file %s in directory %s\n",
4688                                         n, usersharepath ));
4689                                 break;
4690                         }
4691                 } else if (r == -1) {
4692                         num_bad_dir_entries++;
4693                 }
4694
4695                 /* Allow 20% bad entries. */
4696                 if (num_bad_dir_entries > allowed_bad_entries) {
4697                         DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
4698                                 "in directory %s\n",
4699                                 num_bad_dir_entries, usersharepath));
4700                         break;
4701                 }
4702
4703                 /* Allow 20% bad entries. */
4704                 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
4705                         DEBUG(0,("load_usershare_shares: too many total entries (%u) "
4706                         "in directory %s\n",
4707                         num_dir_entries, usersharepath));
4708                         break;
4709                 }
4710         }
4711
4712         closedir(dp);
4713
4714         /* Sweep through and delete any non-refreshed usershares that are
4715            not currently in use. */
4716         tmp_ctx = talloc_stackframe();
4717         for (iService = iNumServices - 1; iService >= 0; iService--) {
4718                 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
4719                         char *servname;
4720
4721                         if (snumused && snumused(sconn, iService)) {
4722                                 continue;
4723                         }
4724
4725                         servname = lp_servicename(tmp_ctx, iService);
4726
4727                         /* Remove from the share ACL db. */
4728                         DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
4729                                   servname ));
4730                         delete_share_security(servname);
4731                         free_service_byindex(iService);
4732                 }
4733         }
4734         talloc_free(tmp_ctx);
4735
4736         return lp_numservices();
4737 }
4738
4739 /********************************************************
4740  Destroy global resources allocated in this file
4741 ********************************************************/
4742
4743 void gfree_loadparm(void)
4744 {
4745         int i;
4746
4747         free_file_list();
4748
4749         /* Free resources allocated to services */
4750
4751         for ( i = 0; i < iNumServices; i++ ) {
4752                 if ( VALID(i) ) {
4753                         free_service_byindex(i);
4754                 }
4755         }
4756
4757         SAFE_FREE( ServicePtrs );
4758         iNumServices = 0;
4759
4760         /* Now release all resources allocated to global
4761            parameters and the default service */
4762
4763         free_global_parameters();
4764 }
4765
4766
4767 /***************************************************************************
4768  Allow client apps to specify that they are a client
4769 ***************************************************************************/
4770 static void lp_set_in_client(bool b)
4771 {
4772     in_client = b;
4773 }
4774
4775
4776 /***************************************************************************
4777  Determine if we're running in a client app
4778 ***************************************************************************/
4779 static bool lp_is_in_client(void)
4780 {
4781     return in_client;
4782 }
4783
4784 /***************************************************************************
4785  Load the services array from the services file. Return true on success,
4786  false on failure.
4787 ***************************************************************************/
4788
4789 static bool lp_load_ex(const char *pszFname,
4790                        bool global_only,
4791                        bool save_defaults,
4792                        bool add_ipc,
4793                        bool initialize_globals,
4794                        bool allow_include_registry,
4795                        bool load_all_shares)
4796 {
4797         char *n2 = NULL;
4798         bool bRetval;
4799
4800         bRetval = false;
4801
4802         DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
4803
4804         bInGlobalSection = true;
4805         bGlobalOnly = global_only;
4806         bAllowIncludeRegistry = allow_include_registry;
4807
4808         init_globals(initialize_globals);
4809
4810         free_file_list();
4811
4812         if (save_defaults) {
4813                 init_locals();
4814                 lp_save_defaults();
4815         }
4816
4817         if (!initialize_globals) {
4818                 free_param_opts(&Globals.param_opt);
4819                 apply_lp_set_cmdline();
4820         }
4821
4822         lp_do_parameter(-1, "idmap config * : backend", Globals.szIdmapBackend);
4823
4824         /* We get sections first, so have to start 'behind' to make up */
4825         iServiceIndex = -1;
4826
4827         if (lp_config_backend_is_file()) {
4828                 n2 = talloc_sub_basic(talloc_tos(), get_current_username(),
4829                                         current_user_info.domain,
4830                                         pszFname);
4831                 if (!n2) {
4832                         smb_panic("lp_load_ex: out of memory");
4833                 }
4834
4835                 add_to_file_list(pszFname, n2);
4836
4837                 bRetval = pm_process(n2, do_section, do_parameter, NULL);
4838                 TALLOC_FREE(n2);
4839
4840                 /* finish up the last section */
4841                 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
4842                 if (bRetval) {
4843                         if (iServiceIndex >= 0) {
4844                                 bRetval = service_ok(iServiceIndex);
4845                         }
4846                 }
4847
4848                 if (lp_config_backend_is_registry()) {
4849                         /* config backend changed to registry in config file */
4850                         /*
4851                          * We need to use this extra global variable here to
4852                          * survive restart: init_globals uses this as a default
4853                          * for ConfigBackend. Otherwise, init_globals would
4854                          *  send us into an endless loop here.
4855                          */
4856                         config_backend = CONFIG_BACKEND_REGISTRY;
4857                         /* start over */
4858                         DEBUG(1, ("lp_load_ex: changing to config backend "
4859                                   "registry\n"));
4860                         init_globals(true);
4861                         lp_kill_all_services();
4862                         return lp_load_ex(pszFname, global_only, save_defaults,
4863                                           add_ipc, initialize_globals,
4864                                           allow_include_registry,
4865                                           load_all_shares);
4866                 }
4867         } else if (lp_config_backend_is_registry()) {
4868                 bRetval = process_registry_globals();
4869         } else {
4870                 DEBUG(0, ("Illegal config  backend given: %d\n",
4871                           lp_config_backend()));
4872                 bRetval = false;
4873         }
4874
4875         if (bRetval && lp_registry_shares()) {
4876                 if (load_all_shares) {
4877                         bRetval = process_registry_shares();
4878                 } else {
4879                         bRetval = reload_registry_shares();
4880                 }
4881         }
4882
4883         {
4884                 char *serv = lp_auto_services(talloc_tos());
4885                 lp_add_auto_services(serv);
4886                 TALLOC_FREE(serv);
4887         }
4888
4889         if (add_ipc) {
4890                 /* When 'restrict anonymous = 2' guest connections to ipc$
4891                    are denied */
4892                 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
4893                 if ( lp_enable_asu_support() ) {
4894                         lp_add_ipc("ADMIN$", false);
4895                 }
4896         }
4897
4898         set_allowed_client_auth();
4899
4900         if (lp_security() == SEC_ADS && strchr(lp_passwordserver(), ':')) {
4901                 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
4902                           lp_passwordserver()));
4903         }
4904
4905         bLoaded = true;
4906
4907         /* Now we check bWINSsupport and set szWINSserver to 127.0.0.1 */
4908         /* if bWINSsupport is true and we are in the client            */
4909         if (lp_is_in_client() && Globals.bWINSsupport) {
4910                 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
4911         }
4912
4913         init_iconv();
4914
4915         fault_configure(smb_panic_s3);
4916
4917         /*
4918          * We run this check once the whole smb.conf is parsed, to
4919          * force some settings for the standard way a AD DC is
4920          * operated.  We may changed these as our code evolves, which
4921          * is why we force these settings.
4922          */
4923         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
4924                 lp_do_parameter(-1, "passdb backend", "samba_dsdb");
4925
4926                 lp_do_parameter(-1, "rpc_server:default", "external");
4927                 lp_do_parameter(-1, "rpc_server:svcctl", "embedded");
4928                 lp_do_parameter(-1, "rpc_server:srvsvc", "embedded");
4929                 lp_do_parameter(-1, "rpc_server:eventlog", "embedded");
4930                 lp_do_parameter(-1, "rpc_server:ntsvcs", "embedded");
4931                 lp_do_parameter(-1, "rpc_server:winreg", "embedded");
4932                 lp_do_parameter(-1, "rpc_server:spoolss", "embedded");
4933                 lp_do_parameter(-1, "rpc_daemon:spoolssd", "embedded");
4934                 lp_do_parameter(-1, "rpc_server:tcpip", "no");
4935         }
4936
4937         bAllowIncludeRegistry = true;
4938
4939         return (bRetval);
4940 }
4941
4942 bool lp_load(const char *pszFname,
4943              bool global_only,
4944              bool save_defaults,
4945              bool add_ipc,
4946              bool initialize_globals)
4947 {
4948         return lp_load_ex(pszFname,
4949                           global_only,
4950                           save_defaults,
4951                           add_ipc,
4952                           initialize_globals,
4953                           true,   /* allow_include_registry */
4954                           false); /* load_all_shares*/
4955 }
4956
4957 bool lp_load_initial_only(const char *pszFname)
4958 {
4959         return lp_load_ex(pszFname,
4960                           true,   /* global only */
4961                           false,  /* save_defaults */
4962                           false,  /* add_ipc */
4963                           true,   /* initialize_globals */
4964                           false,  /* allow_include_registry */
4965                           false); /* load_all_shares*/
4966 }
4967
4968 /**
4969  * most common lp_load wrapper, loading only the globals
4970  */
4971 bool lp_load_global(const char *file_name)
4972 {
4973         return lp_load_ex(file_name,
4974                           true,   /* global_only */
4975                           false,  /* save_defaults */
4976                           false,  /* add_ipc */
4977                           true,   /* initialize_globals */
4978                           true,   /* allow_include_registry */
4979                           false); /* load_all_shares*/
4980 }
4981
4982 /**
4983  * lp_load wrapper, especially for clients
4984  */
4985 bool lp_load_client(const char *file_name)
4986 {
4987         lp_set_in_client(true);
4988
4989         return lp_load_global(file_name);
4990 }
4991
4992 /**
4993  * lp_load wrapper, loading only globals, but intended
4994  * for subsequent calls, not reinitializing the globals
4995  * to default values
4996  */
4997 bool lp_load_global_no_reinit(const char *file_name)
4998 {
4999         return lp_load_ex(file_name,
5000                           true,   /* global_only */
5001                           false,  /* save_defaults */
5002                           false,  /* add_ipc */
5003                           false,  /* initialize_globals */
5004                           true,   /* allow_include_registry */
5005                           false); /* load_all_shares*/
5006 }
5007
5008 /**
5009  * lp_load wrapper, especially for clients, no reinitialization
5010  */
5011 bool lp_load_client_no_reinit(const char *file_name)
5012 {
5013         lp_set_in_client(true);
5014
5015         return lp_load_global_no_reinit(file_name);
5016 }
5017
5018 bool lp_load_with_registry_shares(const char *pszFname,
5019                                   bool global_only,
5020                                   bool save_defaults,
5021                                   bool add_ipc,
5022                                   bool initialize_globals)
5023 {
5024         return lp_load_ex(pszFname,
5025                           global_only,
5026                           save_defaults,
5027                           add_ipc,
5028                           initialize_globals,
5029                           true,  /* allow_include_registry */
5030                           true); /* load_all_shares*/
5031 }
5032
5033 /***************************************************************************
5034  Return the max number of services.
5035 ***************************************************************************/
5036
5037 int lp_numservices(void)
5038 {
5039         return (iNumServices);
5040 }
5041
5042 /***************************************************************************
5043 Display the contents of the services array in human-readable form.
5044 ***************************************************************************/
5045
5046 void lp_dump(FILE *f, bool show_defaults, int maxtoprint)
5047 {
5048         int iService;
5049
5050         if (show_defaults)
5051                 defaults_saved = false;
5052
5053         dump_globals(f);
5054
5055         dump_a_service(&sDefault, f);
5056
5057         for (iService = 0; iService < maxtoprint; iService++) {
5058                 fprintf(f,"\n");
5059                 lp_dump_one(f, show_defaults, iService);
5060         }
5061 }
5062
5063 /***************************************************************************
5064 Display the contents of one service in human-readable form.
5065 ***************************************************************************/
5066
5067 void lp_dump_one(FILE * f, bool show_defaults, int snum)
5068 {
5069         if (VALID(snum)) {
5070                 if (ServicePtrs[snum]->szService[0] == '\0')
5071                         return;
5072                 dump_a_service(ServicePtrs[snum], f);
5073         }
5074 }
5075
5076 /***************************************************************************
5077 Return the number of the service with the given name, or -1 if it doesn't
5078 exist. Note that this is a DIFFERENT ANIMAL from the internal function
5079 getservicebyname()! This works ONLY if all services have been loaded, and
5080 does not copy the found service.
5081 ***************************************************************************/
5082
5083 int lp_servicenumber(const char *pszServiceName)
5084 {
5085         int iService;
5086         fstring serviceName;
5087
5088         if (!pszServiceName) {
5089                 return GLOBAL_SECTION_SNUM;
5090         }
5091
5092         for (iService = iNumServices - 1; iService >= 0; iService--) {
5093                 if (VALID(iService) && ServicePtrs[iService]->szService) {
5094                         /*
5095                          * The substitution here is used to support %U is
5096                          * service names
5097                          */
5098                         fstrcpy(serviceName, ServicePtrs[iService]->szService);
5099                         standard_sub_basic(get_current_username(),
5100                                            current_user_info.domain,
5101                                            serviceName,sizeof(serviceName));
5102                         if (strequal(serviceName, pszServiceName)) {
5103                                 break;
5104                         }
5105                 }
5106         }
5107
5108         if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
5109                 struct timespec last_mod;
5110
5111                 if (!usershare_exists(iService, &last_mod)) {
5112                         /* Remove the share security tdb entry for it. */
5113                         delete_share_security(lp_servicename(talloc_tos(), iService));
5114                         /* Remove it from the array. */
5115                         free_service_byindex(iService);
5116                         /* Doesn't exist anymore. */
5117                         return GLOBAL_SECTION_SNUM;
5118                 }
5119
5120                 /* Has it been modified ? If so delete and reload. */
5121                 if (timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
5122                                      &last_mod) < 0) {
5123                         /* Remove it from the array. */
5124                         free_service_byindex(iService);
5125                         /* and now reload it. */
5126                         iService = load_usershare_service(pszServiceName);
5127                 }
5128         }
5129
5130         if (iService < 0) {
5131                 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
5132                 return GLOBAL_SECTION_SNUM;
5133         }
5134
5135         return (iService);
5136 }
5137
5138 /*******************************************************************
5139  A useful volume label function.
5140 ********************************************************************/
5141
5142 const char *volume_label(TALLOC_CTX *ctx, int snum)
5143 {
5144         char *ret;
5145         const char *label = lp_volume(ctx, snum);
5146         if (!*label) {
5147                 label = lp_servicename(ctx, snum);
5148         }
5149
5150         /* This returns a 33 byte guarenteed null terminated string. */
5151         ret = talloc_strndup(ctx, label, 32);
5152         if (!ret) {
5153                 return "";
5154         }
5155         return ret;
5156 }
5157
5158 /*******************************************************************
5159  Get the default server type we will announce as via nmbd.
5160 ********************************************************************/
5161
5162 int lp_default_server_announce(void)
5163 {
5164         int default_server_announce = 0;
5165         default_server_announce |= SV_TYPE_WORKSTATION;
5166         default_server_announce |= SV_TYPE_SERVER;
5167         default_server_announce |= SV_TYPE_SERVER_UNIX;
5168
5169         /* note that the flag should be set only if we have a
5170            printer service but nmbd doesn't actually load the
5171            services so we can't tell   --jerry */
5172
5173         default_server_announce |= SV_TYPE_PRINTQ_SERVER;
5174
5175         default_server_announce |= SV_TYPE_SERVER_NT;
5176         default_server_announce |= SV_TYPE_NT;
5177
5178         switch (lp_server_role()) {
5179                 case ROLE_DOMAIN_MEMBER:
5180                         default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
5181                         break;
5182                 case ROLE_DOMAIN_PDC:
5183                         default_server_announce |= SV_TYPE_DOMAIN_CTRL;
5184                         break;
5185                 case ROLE_DOMAIN_BDC:
5186                         default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
5187                         break;
5188                 case ROLE_STANDALONE:
5189                 default:
5190                         break;
5191         }
5192         if (lp_time_server())
5193                 default_server_announce |= SV_TYPE_TIME_SOURCE;
5194
5195         if (lp_host_msdfs())
5196                 default_server_announce |= SV_TYPE_DFS_SERVER;
5197
5198         return default_server_announce;
5199 }
5200
5201 /***********************************************************
5202  If we are PDC then prefer us as DMB
5203 ************************************************************/
5204
5205 bool lp_domain_master(void)
5206 {
5207         if (Globals.domain_master == Auto)
5208                 return (lp_server_role() == ROLE_DOMAIN_PDC);
5209
5210         return (bool)Globals.domain_master;
5211 }
5212
5213 /***********************************************************
5214  If we are PDC then prefer us as DMB
5215 ************************************************************/
5216
5217 static bool lp_domain_master_true_or_auto(void)
5218 {
5219         if (Globals.domain_master) /* auto or yes */
5220                 return true;
5221
5222         return false;
5223 }
5224
5225 /***********************************************************
5226  If we are DMB then prefer us as LMB
5227 ************************************************************/
5228
5229 bool lp_preferred_master(void)
5230 {
5231         if (Globals.iPreferredMaster == Auto)
5232                 return (lp_local_master() && lp_domain_master());
5233
5234         return (bool)Globals.iPreferredMaster;
5235 }
5236
5237 /*******************************************************************
5238  Remove a service.
5239 ********************************************************************/
5240
5241 void lp_remove_service(int snum)
5242 {
5243         ServicePtrs[snum]->valid = false;
5244         invalid_services[num_invalid_services++] = snum;
5245 }
5246
5247 /*******************************************************************
5248  Copy a service.
5249 ********************************************************************/
5250
5251 void lp_copy_service(int snum, const char *new_name)
5252 {
5253         do_section(new_name, NULL);
5254         if (snum >= 0) {
5255                 snum = lp_servicenumber(new_name);
5256                 if (snum >= 0) {
5257                         char *name = lp_servicename(talloc_tos(), snum);
5258                         lp_do_parameter(snum, "copy", name);
5259                 }
5260         }
5261 }
5262
5263 const char *lp_printername(TALLOC_CTX *ctx, int snum)
5264 {
5265         const char *ret = lp__printername(talloc_tos(), snum);
5266         if (ret == NULL || *ret == '\0') {
5267                 ret = lp_const_servicename(snum);
5268         }
5269
5270         return ret;
5271 }
5272
5273
5274 /***********************************************************
5275  Allow daemons such as winbindd to fix their logfile name.
5276 ************************************************************/
5277
5278 void lp_set_logfile(const char *name)
5279 {
5280         string_set(&Globals.logfile, name);
5281         debug_set_logfile(name);
5282 }
5283
5284 /*******************************************************************
5285  Return the max print jobs per queue.
5286 ********************************************************************/
5287
5288 int lp_maxprintjobs(int snum)
5289 {
5290         int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
5291         if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
5292                 maxjobs = PRINT_MAX_JOBID - 1;
5293
5294         return maxjobs;
5295 }
5296
5297 const char *lp_printcapname(void)
5298 {
5299         if ((Globals.szPrintcapname != NULL) &&
5300             (Globals.szPrintcapname[0] != '\0'))
5301                 return Globals.szPrintcapname;
5302
5303         if (sDefault.iPrinting == PRINT_CUPS) {
5304                 return "cups";
5305         }
5306
5307         if (sDefault.iPrinting == PRINT_BSD)
5308                 return "/etc/printcap";
5309
5310         return PRINTCAP_NAME;
5311 }
5312
5313 static uint32 spoolss_state;
5314
5315 bool lp_disable_spoolss( void )
5316 {
5317         if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
5318                 spoolss_state = lp__disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
5319
5320         return spoolss_state == SVCCTL_STOPPED ? true : false;
5321 }
5322
5323 void lp_set_spoolss_state( uint32 state )
5324 {
5325         SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
5326
5327         spoolss_state = state;
5328 }
5329
5330 uint32 lp_get_spoolss_state( void )
5331 {
5332         return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
5333 }
5334
5335 /*******************************************************************
5336  Ensure we don't use sendfile if server smb signing is active.
5337 ********************************************************************/
5338
5339 bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state)
5340 {
5341         bool sign_active = false;
5342
5343         /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
5344         if (get_Protocol() < PROTOCOL_NT1) {
5345                 return false;
5346         }
5347         if (signing_state) {
5348                 sign_active = smb_signing_is_active(signing_state);
5349         }
5350         return (lp__use_sendfile(snum) &&
5351                         (get_remote_arch() != RA_WIN95) &&
5352                         !sign_active);
5353 }
5354
5355 /*******************************************************************
5356  Turn off sendfile if we find the underlying OS doesn't support it.
5357 ********************************************************************/
5358
5359 void set_use_sendfile(int snum, bool val)
5360 {
5361         if (LP_SNUM_OK(snum))
5362                 ServicePtrs[snum]->bUseSendfile = val;
5363         else
5364                 sDefault.bUseSendfile = val;
5365 }
5366
5367 /*******************************************************************
5368  Turn off storing DOS attributes if this share doesn't support it.
5369 ********************************************************************/
5370
5371 void set_store_dos_attributes(int snum, bool val)
5372 {
5373         if (!LP_SNUM_OK(snum))
5374                 return;
5375         ServicePtrs[(snum)]->bStoreDosAttributes = val;
5376 }
5377
5378 void lp_set_mangling_method(const char *new_method)
5379 {
5380         string_set(&Globals.szManglingMethod, new_method);
5381 }
5382
5383 /*******************************************************************
5384  Global state for POSIX pathname processing.
5385 ********************************************************************/
5386
5387 static bool posix_pathnames;
5388
5389 bool lp_posix_pathnames(void)
5390 {
5391         return posix_pathnames;
5392 }
5393
5394 /*******************************************************************
5395  Change everything needed to ensure POSIX pathname processing (currently
5396  not much).
5397 ********************************************************************/
5398
5399 void lp_set_posix_pathnames(void)
5400 {
5401         posix_pathnames = true;
5402 }
5403
5404 /*******************************************************************
5405  Global state for POSIX lock processing - CIFS unix extensions.
5406 ********************************************************************/
5407
5408 bool posix_default_lock_was_set;
5409 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
5410
5411 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
5412 {
5413         if (posix_default_lock_was_set) {
5414                 return posix_cifsx_locktype;
5415         } else {
5416                 return fsp->posix_open ? POSIX_LOCK : WINDOWS_LOCK;
5417         }
5418 }
5419
5420 /*******************************************************************
5421 ********************************************************************/
5422
5423 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
5424 {
5425         posix_default_lock_was_set = true;
5426         posix_cifsx_locktype = val;
5427 }
5428
5429 int lp_min_receive_file_size(void)
5430 {
5431         if (Globals.iminreceivefile < 0) {
5432                 return 0;
5433         }
5434         return MIN(Globals.iminreceivefile, BUFFER_SIZE);
5435 }
5436
5437 /*******************************************************************
5438  Safe wide links checks.
5439  This helper function always verify the validity of wide links,
5440  even after a configuration file reload.
5441 ********************************************************************/
5442
5443 static bool lp_widelinks_internal(int snum)
5444 {
5445         return (bool)(LP_SNUM_OK(snum)? ServicePtrs[(snum)]->bWidelinks :
5446                         sDefault.bWidelinks);
5447 }
5448
5449 void widelinks_warning(int snum)
5450 {
5451         if (lp_allow_insecure_widelinks()) {
5452                 return;
5453         }
5454
5455         if (lp_unix_extensions() && lp_widelinks_internal(snum)) {
5456                 DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
5457                         "These parameters are incompatible. "
5458                         "Wide links will be disabled for this share.\n",
5459                          lp_servicename(talloc_tos(), snum) ));
5460         }
5461 }
5462
5463 bool lp_widelinks(int snum)
5464 {
5465         /* wide links is always incompatible with unix extensions */
5466         if (lp_unix_extensions()) {
5467                 /*
5468                  * Unless we have "allow insecure widelinks"
5469                  * turned on.
5470                  */
5471                 if (!lp_allow_insecure_widelinks()) {
5472                         return false;
5473                 }
5474         }
5475
5476         return lp_widelinks_internal(snum);
5477 }
5478
5479 bool lp_writeraw(void)
5480 {
5481         if (lp_async_smb_echo_handler()) {
5482                 return false;
5483         }
5484         return lp__writeraw();
5485 }
5486
5487 bool lp_readraw(void)
5488 {
5489         if (lp_async_smb_echo_handler()) {
5490                 return false;
5491         }
5492         return lp__readraw();
5493 }
5494
5495 int lp_server_role(void)
5496 {
5497         return lp_find_server_role(lp__server_role(),
5498                                    lp__security(),
5499                                    lp__domain_logons(),
5500                                    lp_domain_master_true_or_auto());
5501 }
5502
5503 int lp_security(void)
5504 {
5505         return lp_find_security(lp__server_role(),
5506                                 lp__security());
5507 }