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