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