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