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