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