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