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