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_SUBSTITUTED_STRING(fn_name,ptr) \
1051 char *lp_ ## fn_name(TALLOC_CTX *ctx, const struct loadparm_substitution *lp_sub) \
1052  {return lpcfg_substituted_string(ctx, lp_sub, *(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : "");}
1053 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1054  const char *lp_ ## fn_name(void) {return(*(const char * const *)(&Globals.ptr) ? *(const char * const *)(&Globals.ptr) : "");}
1055 #define FN_GLOBAL_LIST(fn_name,ptr) \
1056  const char **lp_ ## fn_name(void) {return(*(const char ***)(&Globals.ptr));}
1057 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1058  bool lp_ ## fn_name(void) {return(*(bool *)(&Globals.ptr));}
1059 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1060  char lp_ ## fn_name(void) {return(*(char *)(&Globals.ptr));}
1061 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1062  int lp_ ## fn_name(void) {return(*(int *)(&Globals.ptr));}
1063
1064 #define FN_LOCAL_SUBSTITUTED_STRING(fn_name,val) \
1065 char *lp_ ## fn_name(TALLOC_CTX *ctx, const struct loadparm_substitution *lp_sub, int i) \
1066  {return lpcfg_substituted_string((ctx), lp_sub, (LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1067 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1068  const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1069 #define FN_LOCAL_LIST(fn_name,val) \
1070  const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1071 #define FN_LOCAL_BOOL(fn_name,val) \
1072  bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1073 #define FN_LOCAL_INTEGER(fn_name,val) \
1074  int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1075
1076 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1077  bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1078 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1079  int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1080 #define FN_LOCAL_PARM_CHAR(fn_name,val) \
1081  char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1082
1083 int lp_winbind_max_domain_connections(void)
1084 {
1085         if (lp_winbind_offline_logon() &&
1086             lp__winbind_max_domain_connections() > 1) {
1087                 DEBUG(1, ("offline logons active, restricting max domain "
1088                           "connections to 1\n"));
1089                 return 1;
1090         }
1091         return MAX(1, lp__winbind_max_domain_connections());
1092 }
1093
1094 /* These functions remain in source3/param for now */
1095
1096 #include "lib/param/param_functions.c"
1097
1098 FN_LOCAL_SUBSTITUTED_STRING(servicename, szService)
1099 FN_LOCAL_CONST_STRING(const_servicename, szService)
1100
1101 /* These functions cannot be auto-generated */
1102 FN_LOCAL_BOOL(autoloaded, autoloaded)
1103 FN_GLOBAL_CONST_STRING(dnsdomain, dnsdomain)
1104
1105 /* local prototypes */
1106
1107 static int map_parameter_canonical(const char *pszParmName, bool *inverse);
1108 static const char *get_boolean(bool bool_value);
1109 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
1110                          void *userdata);
1111 static bool hash_a_service(const char *name, int number);
1112 static void free_service_byindex(int iService);
1113 static void show_parameter(int parmIndex);
1114 static bool is_synonym_of(int parm1, int parm2, bool *inverse);
1115 static bool lp_parameter_value_is_valid(const char *parm_name, const char *val);
1116
1117 /*
1118  * This is a helper function for parametrical options support.  It returns a
1119  * pointer to parametrical option value if it exists or NULL otherwise. Actual
1120  * parametrical functions are quite simple
1121  */
1122 static struct parmlist_entry *get_parametrics(int snum, const char *type,
1123                                                 const char *option)
1124 {
1125         if (snum >= iNumServices) return NULL;
1126
1127         if (snum < 0) {
1128                 return get_parametric_helper(NULL, type, option, Globals.param_opt);
1129         } else {
1130                 return get_parametric_helper(ServicePtrs[snum],
1131                                              type, option, Globals.param_opt);
1132         }
1133 }
1134
1135 static void discard_whitespace(char *str)
1136 {
1137         size_t len = strlen(str);
1138         size_t i = 0;
1139
1140         while (i < len) {
1141                 if (isspace(str[i])) {
1142                         memmove(&str[i], &str[i+1], len-i);
1143                         len -= 1;
1144                         continue;
1145                 }
1146                 i += 1;
1147         }
1148 }
1149
1150 /**
1151  * @brief Go through all global parametric parameters
1152  *
1153  * @param regex_str     A regular expression to scan param for
1154  * @param max_matches   Max number of submatches the regexp expects
1155  * @param cb            Function to call on match. Should return true
1156  *                      when it wants wi_scan_global_parametrics to stop
1157  *                      scanning
1158  * @param private_data  Anonymous pointer passed to cb
1159  *
1160  * @return              0: success, regcomp/regexec return value on error.
1161  *                      See "man regexec" for possible errors
1162  */
1163
1164 int lp_wi_scan_global_parametrics(
1165         const char *regex_str, size_t max_matches,
1166         bool (*cb)(const char *string, regmatch_t matches[],
1167                    void *private_data),
1168         void *private_data)
1169 {
1170         struct parmlist_entry *data;
1171         regex_t regex;
1172         int ret;
1173
1174         ret = regcomp(&regex, regex_str, REG_ICASE);
1175         if (ret != 0) {
1176                 return ret;
1177         }
1178
1179         for (data = Globals.param_opt; data != NULL; data = data->next) {
1180                 size_t keylen = strlen(data->key);
1181                 char key[keylen+1];
1182                 regmatch_t matches[max_matches];
1183                 bool stop;
1184
1185                 memcpy(key, data->key, sizeof(key));
1186                 discard_whitespace(key);
1187
1188                 ret = regexec(&regex, key, max_matches, matches, 0);
1189                 if (ret == REG_NOMATCH) {
1190                         continue;
1191                 }
1192                 if (ret != 0) {
1193                         goto fail;
1194                 }
1195
1196                 stop = cb(key, matches, private_data);
1197                 if (stop) {
1198                         break;
1199                 }
1200         }
1201
1202         ret = 0;
1203 fail:
1204         regfree(&regex);
1205         return ret;
1206 }
1207
1208
1209 #define MISSING_PARAMETER(name) \
1210     DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
1211
1212 /*******************************************************************
1213 convenience routine to return enum parameters.
1214 ********************************************************************/
1215 static int lp_enum(const char *s,const struct enum_list *_enum)
1216 {
1217         int i;
1218
1219         if (!s || !*s || !_enum) {
1220                 MISSING_PARAMETER(lp_enum);
1221                 return (-1);
1222         }
1223
1224         for (i=0; _enum[i].name; i++) {
1225                 if (strequal(_enum[i].name,s))
1226                         return _enum[i].value;
1227         }
1228
1229         DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
1230         return (-1);
1231 }
1232
1233 #undef MISSING_PARAMETER
1234
1235 /* Return parametric option from a given service. Type is a part of option before ':' */
1236 /* Parametric option has following syntax: 'Type: option = value' */
1237 char *lp_parm_substituted_string(TALLOC_CTX *mem_ctx,
1238                                  const struct loadparm_substitution *lp_sub,
1239                                  int snum,
1240                                  const char *type,
1241                                  const char *option,
1242                                  const char *def)
1243 {
1244         struct parmlist_entry *data = get_parametrics(snum, type, option);
1245
1246         SMB_ASSERT(lp_sub != NULL);
1247
1248         if (data == NULL||data->value==NULL) {
1249                 if (def) {
1250                         return lpcfg_substituted_string(mem_ctx, lp_sub, def);
1251                 } else {
1252                         return NULL;
1253                 }
1254         }
1255
1256         return lpcfg_substituted_string(mem_ctx, lp_sub, data->value);
1257 }
1258
1259 /* Return parametric option from a given service. Type is a part of option before ':' */
1260 /* Parametric option has following syntax: 'Type: option = value' */
1261 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
1262 {
1263         struct parmlist_entry *data = get_parametrics(snum, type, option);
1264
1265         if (data == NULL||data->value==NULL)
1266                 return def;
1267
1268         return data->value;
1269 }
1270
1271
1272 /* Return parametric option from a given service. Type is a part of option before ':' */
1273 /* Parametric option has following syntax: 'Type: option = value' */
1274
1275 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
1276 {
1277         struct parmlist_entry *data = get_parametrics(snum, type, option);
1278
1279         if (data == NULL||data->value==NULL)
1280                 return (const char **)def;
1281
1282         if (data->list==NULL) {
1283                 data->list = str_list_make_v3(NULL, data->value, NULL);
1284         }
1285
1286         return discard_const_p(const char *, data->list);
1287 }
1288
1289 /* Return parametric option from a given service. Type is a part of option before ':' */
1290 /* Parametric option has following syntax: 'Type: option = value' */
1291
1292 int lp_parm_int(int snum, const char *type, const char *option, int def)
1293 {
1294         struct parmlist_entry *data = get_parametrics(snum, type, option);
1295
1296         if (data && data->value && *data->value)
1297                 return lp_int(data->value);
1298
1299         return def;
1300 }
1301
1302 /* Return parametric option from a given service. Type is a part of option before ':' */
1303 /* Parametric option has following syntax: 'Type: option = value' */
1304
1305 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
1306 {
1307         struct parmlist_entry *data = get_parametrics(snum, type, option);
1308
1309         if (data && data->value && *data->value)
1310                 return lp_ulong(data->value);
1311
1312         return def;
1313 }
1314
1315 /* Return parametric option from a given service. Type is a part of option before ':' */
1316 /* Parametric option has following syntax: 'Type: option = value' */
1317
1318 unsigned long long lp_parm_ulonglong(int snum, const char *type,
1319                                      const char *option, unsigned long long def)
1320 {
1321         struct parmlist_entry *data = get_parametrics(snum, type, option);
1322
1323         if (data && data->value && *data->value) {
1324                 return lp_ulonglong(data->value);
1325         }
1326
1327         return def;
1328 }
1329
1330 /* Return parametric option from a given service. Type is a part of option
1331  * before ':' */
1332 /* Parametric option has following syntax: 'Type: option = value' */
1333
1334 bool lp_parm_bool(int snum, const char *type, const char *option, bool def)
1335 {
1336         struct parmlist_entry *data = get_parametrics(snum, type, option);
1337
1338         if (data && data->value && *data->value)
1339                 return lp_bool(data->value);
1340
1341         return def;
1342 }
1343
1344 /* Return parametric option from a given service. Type is a part of option before ':' */
1345 /* Parametric option has following syntax: 'Type: option = value' */
1346
1347 int lp_parm_enum(int snum, const char *type, const char *option,
1348                  const struct enum_list *_enum, int def)
1349 {
1350         struct parmlist_entry *data = get_parametrics(snum, type, option);
1351
1352         if (data && data->value && *data->value && _enum)
1353                 return lp_enum(data->value, _enum);
1354
1355         return def;
1356 }
1357
1358 /**
1359  * free a param_opts structure.
1360  * param_opts handling should be moved to talloc;
1361  * then this whole functions reduces to a TALLOC_FREE().
1362  */
1363
1364 static void free_param_opts(struct parmlist_entry **popts)
1365 {
1366         struct parmlist_entry *opt, *next_opt;
1367
1368         if (*popts != NULL) {
1369                 DEBUG(5, ("Freeing parametrics:\n"));
1370         }
1371         opt = *popts;
1372         while (opt != NULL) {
1373                 lpcfg_string_free(&opt->key);
1374                 lpcfg_string_free(&opt->value);
1375                 TALLOC_FREE(opt->list);
1376                 next_opt = opt->next;
1377                 TALLOC_FREE(opt);
1378                 opt = next_opt;
1379         }
1380         *popts = NULL;
1381 }
1382
1383 /***************************************************************************
1384  Free the dynamically allocated parts of a service struct.
1385 ***************************************************************************/
1386
1387 static void free_service(struct loadparm_service *pservice)
1388 {
1389         if (!pservice)
1390                 return;
1391
1392         if (pservice->szService)
1393                 DEBUG(5, ("free_service: Freeing service %s\n",
1394                        pservice->szService));
1395
1396         free_parameters(pservice);
1397
1398         lpcfg_string_free(&pservice->szService);
1399         TALLOC_FREE(pservice->copymap);
1400
1401         free_param_opts(&pservice->param_opt);
1402
1403         ZERO_STRUCTP(pservice);
1404 }
1405
1406
1407 /***************************************************************************
1408  remove a service indexed in the ServicePtrs array from the ServiceHash
1409  and free the dynamically allocated parts
1410 ***************************************************************************/
1411
1412 static void free_service_byindex(int idx)
1413 {
1414         if ( !LP_SNUM_OK(idx) )
1415                 return;
1416
1417         ServicePtrs[idx]->valid = false;
1418
1419         /* we have to cleanup the hash record */
1420
1421         if (ServicePtrs[idx]->szService) {
1422                 char *canon_name = canonicalize_servicename(
1423                         talloc_tos(),
1424                         ServicePtrs[idx]->szService );
1425
1426                 dbwrap_delete_bystring(ServiceHash, canon_name );
1427                 TALLOC_FREE(canon_name);
1428         }
1429
1430         free_service(ServicePtrs[idx]);
1431         TALLOC_FREE(ServicePtrs[idx]);
1432 }
1433
1434 /***************************************************************************
1435  Add a new service to the services array initialising it with the given
1436  service.
1437 ***************************************************************************/
1438
1439 static int add_a_service(const struct loadparm_service *pservice, const char *name)
1440 {
1441         int i;
1442         struct loadparm_service **tsp = NULL;
1443
1444         /* it might already exist */
1445         if (name) {
1446                 i = getservicebyname(name, NULL);
1447                 if (i >= 0) {
1448                         return (i);
1449                 }
1450         }
1451
1452         /* Re use empty slots if any before allocating new one.*/
1453         for (i=0; i < iNumServices; i++) {
1454                 if (ServicePtrs[i] == NULL) {
1455                         break;
1456                 }
1457         }
1458         if (i == iNumServices) {
1459                 /* if not, then create one */
1460                 tsp = talloc_realloc(NULL, ServicePtrs,
1461                                      struct loadparm_service *,
1462                                      iNumServices + 1);
1463                 if (tsp == NULL) {
1464                         DEBUG(0, ("add_a_service: failed to enlarge "
1465                                   "ServicePtrs!\n"));
1466                         return (-1);
1467                 }
1468                 ServicePtrs = tsp;
1469                 iNumServices++;
1470         }
1471         ServicePtrs[i] = talloc_zero(ServicePtrs, struct loadparm_service);
1472         if (!ServicePtrs[i]) {
1473                 DEBUG(0,("add_a_service: out of memory!\n"));
1474                 return (-1);
1475         }
1476
1477         ServicePtrs[i]->valid = true;
1478
1479         copy_service(ServicePtrs[i], pservice, NULL);
1480         if (name)
1481                 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->szService,
1482                                  name);
1483
1484         DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
1485                 i, ServicePtrs[i]->szService));
1486
1487         if (!hash_a_service(ServicePtrs[i]->szService, i)) {
1488                 return (-1);
1489         }
1490
1491         return (i);
1492 }
1493
1494 /***************************************************************************
1495   Convert a string to uppercase and remove whitespaces.
1496 ***************************************************************************/
1497
1498 char *canonicalize_servicename(TALLOC_CTX *ctx, const char *src)
1499 {
1500         char *result;
1501
1502         if ( !src ) {
1503                 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
1504                 return NULL;
1505         }
1506
1507         result = talloc_strdup(ctx, src);
1508         SMB_ASSERT(result != NULL);
1509
1510         if (!strlower_m(result)) {
1511                 TALLOC_FREE(result);
1512                 return NULL;
1513         }
1514         return result;
1515 }
1516
1517 /***************************************************************************
1518   Add a name/index pair for the services array to the hash table.
1519 ***************************************************************************/
1520
1521 static bool hash_a_service(const char *name, int idx)
1522 {
1523         char *canon_name;
1524
1525         if ( !ServiceHash ) {
1526                 DEBUG(10,("hash_a_service: creating servicehash\n"));
1527                 ServiceHash = db_open_rbt(NULL);
1528                 if ( !ServiceHash ) {
1529                         DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
1530                         return false;
1531                 }
1532         }
1533
1534         DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
1535                 idx, name));
1536
1537         canon_name = canonicalize_servicename(talloc_tos(), name );
1538
1539         dbwrap_store_bystring(ServiceHash, canon_name,
1540                               make_tdb_data((uint8_t *)&idx, sizeof(idx)),
1541                               TDB_REPLACE);
1542
1543         TALLOC_FREE(canon_name);
1544
1545         return true;
1546 }
1547
1548 /***************************************************************************
1549  Add a new home service, with the specified home directory, defaults coming
1550  from service ifrom.
1551 ***************************************************************************/
1552
1553 bool lp_add_home(const char *pszHomename, int iDefaultService,
1554                  const char *user, const char *pszHomedir)
1555 {
1556         const struct loadparm_substitution *lp_sub =
1557                 loadparm_s3_global_substitution();
1558         int i;
1559         char *global_path;
1560
1561         if (pszHomename == NULL || user == NULL || pszHomedir == NULL ||
1562                         pszHomedir[0] == '\0') {
1563                 return false;
1564         }
1565
1566         i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
1567
1568         if (i < 0)
1569                 return false;
1570
1571         global_path = lp_path(talloc_tos(), lp_sub, GLOBAL_SECTION_SNUM);
1572         if (!(*(ServicePtrs[iDefaultService]->path))
1573             || strequal(ServicePtrs[iDefaultService]->path, global_path)) {
1574                 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path,
1575                                  pszHomedir);
1576         }
1577         TALLOC_FREE(global_path);
1578
1579         if (!(*(ServicePtrs[i]->comment))) {
1580                 char *comment = talloc_asprintf(talloc_tos(), "Home directory of %s", user);
1581                 if (comment == NULL) {
1582                         return false;
1583                 }
1584                 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment,
1585                                  comment);
1586                 TALLOC_FREE(comment);
1587         }
1588
1589         /* set the browseable flag from the global default */
1590
1591         ServicePtrs[i]->browseable = sDefault.browseable;
1592         ServicePtrs[i]->access_based_share_enum = sDefault.access_based_share_enum;
1593
1594         ServicePtrs[i]->autoloaded = true;
1595
1596         DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
1597                user, ServicePtrs[i]->path ));
1598
1599         return true;
1600 }
1601
1602 /***************************************************************************
1603  Add a new service, based on an old one.
1604 ***************************************************************************/
1605
1606 int lp_add_service(const char *pszService, int iDefaultService)
1607 {
1608         if (iDefaultService < 0) {
1609                 return add_a_service(&sDefault, pszService);
1610         }
1611
1612         return (add_a_service(ServicePtrs[iDefaultService], pszService));
1613 }
1614
1615 /***************************************************************************
1616  Add the IPC service.
1617 ***************************************************************************/
1618
1619 static bool lp_add_ipc(const char *ipc_name, bool guest_ok)
1620 {
1621         char *comment = NULL;
1622         int i = add_a_service(&sDefault, ipc_name);
1623
1624         if (i < 0)
1625                 return false;
1626
1627         comment = talloc_asprintf(talloc_tos(), "IPC Service (%s)",
1628                                   Globals.server_string);
1629         if (comment == NULL) {
1630                 return false;
1631         }
1632
1633         lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path, tmpdir());
1634         lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1635         lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->fstype, "IPC");
1636         ServicePtrs[i]->max_connections = 0;
1637         ServicePtrs[i]->available = true;
1638         ServicePtrs[i]->read_only = true;
1639         ServicePtrs[i]->guest_only = false;
1640         ServicePtrs[i]->administrative_share = true;
1641         ServicePtrs[i]->guest_ok = guest_ok;
1642         ServicePtrs[i]->printable = false;
1643         ServicePtrs[i]->browseable = sDefault.browseable;
1644         ServicePtrs[i]->autoloaded = false;
1645
1646         DEBUG(3, ("adding IPC service\n"));
1647
1648         TALLOC_FREE(comment);
1649         return true;
1650 }
1651
1652 /***************************************************************************
1653  Add a new printer service, with defaults coming from service iFrom.
1654 ***************************************************************************/
1655
1656 bool lp_add_printer(const char *pszPrintername, int iDefaultService)
1657 {
1658         const char *comment = "From Printcap";
1659         int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
1660
1661         if (i < 0)
1662                 return false;
1663
1664         /* note that we do NOT default the availability flag to true - */
1665         /* we take it from the default service passed. This allows all */
1666         /* dynamic printers to be disabled by disabling the [printers] */
1667         /* entry (if/when the 'available' keyword is implemented!).    */
1668
1669         /* the printer name is set to the service name. */
1670         lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->_printername,
1671                          pszPrintername);
1672         lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1673
1674         /* set the browseable flag from the gloabl default */
1675         ServicePtrs[i]->browseable = sDefault.browseable;
1676
1677         /* Printers cannot be read_only. */
1678         ServicePtrs[i]->read_only = false;
1679         /* No oplocks on printer services. */
1680         ServicePtrs[i]->oplocks = false;
1681         /* Printer services must be printable. */
1682         ServicePtrs[i]->printable = true;
1683
1684         DEBUG(3, ("adding printer service %s\n", pszPrintername));
1685
1686         return true;
1687 }
1688
1689
1690 /***************************************************************************
1691  Check whether the given parameter name is valid.
1692  Parametric options (names containing a colon) are considered valid.
1693 ***************************************************************************/
1694
1695 bool lp_parameter_is_valid(const char *pszParmName)
1696 {
1697         return ((lpcfg_map_parameter(pszParmName) != -1) ||
1698                 (strchr(pszParmName, ':') != NULL));
1699 }
1700
1701 /***************************************************************************
1702  Check whether the given name is the name of a global parameter.
1703  Returns true for strings belonging to parameters of class
1704  P_GLOBAL, false for all other strings, also for parametric options
1705  and strings not belonging to any option.
1706 ***************************************************************************/
1707
1708 bool lp_parameter_is_global(const char *pszParmName)
1709 {
1710         int num = lpcfg_map_parameter(pszParmName);
1711
1712         if (num >= 0) {
1713                 return (parm_table[num].p_class == P_GLOBAL);
1714         }
1715
1716         return false;
1717 }
1718
1719 /**************************************************************************
1720  Determine the canonical name for a parameter.
1721  Indicate when it is an inverse (boolean) synonym instead of a
1722  "usual" synonym.
1723 **************************************************************************/
1724
1725 bool lp_canonicalize_parameter(const char *parm_name, const char **canon_parm,
1726                                bool *inverse)
1727 {
1728         int num;
1729
1730         if (!lp_parameter_is_valid(parm_name)) {
1731                 *canon_parm = NULL;
1732                 return false;
1733         }
1734
1735         num = map_parameter_canonical(parm_name, inverse);
1736         if (num < 0) {
1737                 /* parametric option */
1738                 *canon_parm = parm_name;
1739         } else {
1740                 *canon_parm = parm_table[num].label;
1741         }
1742
1743         return true;
1744
1745 }
1746
1747 /**************************************************************************
1748  Determine the canonical name for a parameter.
1749  Turn the value given into the inverse boolean expression when
1750  the synonym is an invers boolean synonym.
1751
1752  Return true if
1753  - parm_name is a valid parameter name and
1754  - val is a valid value for this parameter and
1755  - in case the parameter is an inverse boolean synonym, if the val
1756    string could successfully be converted to the reverse bool.
1757  Return false in all other cases.
1758 **************************************************************************/
1759
1760 bool lp_canonicalize_parameter_with_value(const char *parm_name,
1761                                           const char *val,
1762                                           const char **canon_parm,
1763                                           const char **canon_val)
1764 {
1765         int num;
1766         bool inverse;
1767         bool ret;
1768
1769         if (!lp_parameter_is_valid(parm_name)) {
1770                 *canon_parm = NULL;
1771                 *canon_val = NULL;
1772                 return false;
1773         }
1774
1775         num = map_parameter_canonical(parm_name, &inverse);
1776         if (num < 0) {
1777                 /* parametric option */
1778                 *canon_parm = parm_name;
1779                 *canon_val = val;
1780                 return true;
1781         }
1782
1783         *canon_parm = parm_table[num].label;
1784         if (inverse) {
1785                 if (!lp_invert_boolean(val, canon_val)) {
1786                         *canon_val = NULL;
1787                         return false;
1788                 }
1789         } else {
1790                 *canon_val = val;
1791         }
1792
1793         ret = lp_parameter_value_is_valid(*canon_parm, *canon_val);
1794
1795         return ret;
1796 }
1797
1798 /***************************************************************************
1799  Map a parameter's string representation to the index of the canonical
1800  form of the parameter (it might be a synonym).
1801  Returns -1 if the parameter string is not recognised.
1802 ***************************************************************************/
1803
1804 static int map_parameter_canonical(const char *pszParmName, bool *inverse)
1805 {
1806         int parm_num, canon_num;
1807         bool loc_inverse = false;
1808
1809         parm_num = lpcfg_map_parameter(pszParmName);
1810         if ((parm_num < 0) || !(parm_table[parm_num].flags & FLAG_SYNONYM)) {
1811                 /* invalid, parametric or no canidate for synonyms ... */
1812                 goto done;
1813         }
1814
1815         for (canon_num = 0; parm_table[canon_num].label; canon_num++) {
1816                 if (is_synonym_of(parm_num, canon_num, &loc_inverse)) {
1817                         parm_num = canon_num;
1818                         goto done;
1819                 }
1820         }
1821
1822 done:
1823         if (inverse != NULL) {
1824                 *inverse = loc_inverse;
1825         }
1826         return parm_num;
1827 }
1828
1829 /***************************************************************************
1830  return true if parameter number parm1 is a synonym of parameter
1831  number parm2 (parm2 being the principal name).
1832  set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
1833  false otherwise.
1834 ***************************************************************************/
1835
1836 static bool is_synonym_of(int parm1, int parm2, bool *inverse)
1837 {
1838         if ((parm_table[parm1].offset == parm_table[parm2].offset) &&
1839             (parm_table[parm1].p_class == parm_table[parm2].p_class) &&
1840             (parm_table[parm1].flags & FLAG_SYNONYM) &&
1841             !(parm_table[parm2].flags & FLAG_SYNONYM))
1842         {
1843                 if (inverse != NULL) {
1844                         if ((parm_table[parm1].type == P_BOOLREV) &&
1845                             (parm_table[parm2].type == P_BOOL))
1846                         {
1847                                 *inverse = true;
1848                         } else {
1849                                 *inverse = false;
1850                         }
1851                 }
1852                 return true;
1853         }
1854         return false;
1855 }
1856
1857 /***************************************************************************
1858  Show one parameter's name, type, [values,] and flags.
1859  (helper functions for show_parameter_list)
1860 ***************************************************************************/
1861
1862 static void show_parameter(int parmIndex)
1863 {
1864         size_t enumIndex, flagIndex;
1865         size_t parmIndex2;
1866         bool hadFlag;
1867         bool hadSyn;
1868         bool inverse;
1869         const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
1870                 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
1871                 "P_ENUM", "P_BYTES", "P_CMDLIST" };
1872         unsigned flags[] = { FLAG_DEPRECATED, FLAG_SYNONYM };
1873         const char *flag_names[] = { "FLAG_DEPRECATED", "FLAG_SYNONYM", NULL};
1874
1875         printf("%s=%s", parm_table[parmIndex].label,
1876                type[parm_table[parmIndex].type]);
1877         if (parm_table[parmIndex].type == P_ENUM) {
1878                 printf(",");
1879                 for (enumIndex=0;
1880                      parm_table[parmIndex].enum_list[enumIndex].name;
1881                      enumIndex++)
1882                 {
1883                         printf("%s%s",
1884                                enumIndex ? "|" : "",
1885                                parm_table[parmIndex].enum_list[enumIndex].name);
1886                 }
1887         }
1888         printf(",");
1889         hadFlag = false;
1890         for (flagIndex=0; flag_names[flagIndex]; flagIndex++) {
1891                 if (parm_table[parmIndex].flags & flags[flagIndex]) {
1892                         printf("%s%s",
1893                                 hadFlag ? "|" : "",
1894                                 flag_names[flagIndex]);
1895                         hadFlag = true;
1896                 }
1897         }
1898
1899         /* output synonyms */
1900         hadSyn = false;
1901         for (parmIndex2=0; parm_table[parmIndex2].label; parmIndex2++) {
1902                 if (is_synonym_of(parmIndex, parmIndex2, &inverse)) {
1903                         printf(" (%ssynonym of %s)", inverse ? "inverse " : "",
1904                                parm_table[parmIndex2].label);
1905                 } else if (is_synonym_of(parmIndex2, parmIndex, &inverse)) {
1906                         if (!hadSyn) {
1907                                 printf(" (synonyms: ");
1908                                 hadSyn = true;
1909                         } else {
1910                                 printf(", ");
1911                         }
1912                         printf("%s%s", parm_table[parmIndex2].label,
1913                                inverse ? "[i]" : "");
1914                 }
1915         }
1916         if (hadSyn) {
1917                 printf(")");
1918         }
1919
1920         printf("\n");
1921 }
1922
1923 /*
1924  * Check the value for a P_ENUM
1925  */
1926 static bool check_enum_parameter(struct parm_struct *parm, const char *value)
1927 {
1928         int i;
1929
1930         for (i = 0; parm->enum_list[i].name; i++) {
1931                 if (strwicmp(value, parm->enum_list[i].name) == 0) {
1932                         return true;
1933                 }
1934         }
1935         return false;
1936 }
1937
1938 /**************************************************************************
1939  Check whether the given value is valid for the given parameter name.
1940 **************************************************************************/
1941
1942 static bool lp_parameter_value_is_valid(const char *parm_name, const char *val)
1943 {
1944         bool ret = false, tmp_bool;
1945         int num = lpcfg_map_parameter(parm_name), tmp_int;
1946         uint64_t tmp_int64 = 0;
1947         struct parm_struct *parm;
1948
1949         /* parametric options (parameter names containing a colon) cannot
1950            be checked and are therefore considered valid. */
1951         if (strchr(parm_name, ':') != NULL) {
1952                 return true;
1953         }
1954
1955         if (num >= 0) {
1956                 parm = &parm_table[num];
1957                 switch (parm->type) {
1958                         case P_BOOL:
1959                         case P_BOOLREV:
1960                                 ret = set_boolean(val, &tmp_bool);
1961                                 break;
1962
1963                         case P_INTEGER:
1964                                 ret = (sscanf(val, "%d", &tmp_int) == 1);
1965                                 break;
1966
1967                         case P_OCTAL:
1968                                 ret = (sscanf(val, "%o", &tmp_int) == 1);
1969                                 break;
1970
1971                         case P_ENUM:
1972                                 ret = check_enum_parameter(parm, val);
1973                                 break;
1974
1975                         case P_BYTES:
1976                                 if (conv_str_size_error(val, &tmp_int64) &&
1977                                     tmp_int64 <= INT_MAX) {
1978                                         ret = true;
1979                                 }
1980                                 break;
1981
1982                         case P_CHAR:
1983                         case P_LIST:
1984                         case P_STRING:
1985                         case P_USTRING:
1986                         case P_CMDLIST:
1987                                 ret = true;
1988                                 break;
1989                 }
1990         }
1991         return ret;
1992 }
1993
1994 /***************************************************************************
1995  Show all parameter's name, type, [values,] and flags.
1996 ***************************************************************************/
1997
1998 void show_parameter_list(void)
1999 {
2000         int classIndex, parmIndex;
2001         const char *section_names[] = { "local", "global", NULL};
2002
2003         for (classIndex=0; section_names[classIndex]; classIndex++) {
2004                 printf("[%s]\n", section_names[classIndex]);
2005                 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
2006                         if (parm_table[parmIndex].p_class == classIndex) {
2007                                 show_parameter(parmIndex);
2008                         }
2009                 }
2010         }
2011 }
2012
2013 /***************************************************************************
2014  Get the standard string representation of a boolean value ("yes" or "no")
2015 ***************************************************************************/
2016
2017 static const char *get_boolean(bool bool_value)
2018 {
2019         static const char *yes_str = "yes";
2020         static const char *no_str = "no";
2021
2022         return (bool_value ? yes_str : no_str);
2023 }
2024
2025 /***************************************************************************
2026  Provide the string of the negated boolean value associated to the boolean
2027  given as a string. Returns false if the passed string does not correctly
2028  represent a boolean.
2029 ***************************************************************************/
2030
2031 bool lp_invert_boolean(const char *str, const char **inverse_str)
2032 {
2033         bool val;
2034
2035         if (!set_boolean(str, &val)) {
2036                 return false;
2037         }
2038
2039         *inverse_str = get_boolean(!val);
2040         return true;
2041 }
2042
2043 /***************************************************************************
2044  Provide the canonical string representation of a boolean value given
2045  as a string. Return true on success, false if the string given does
2046  not correctly represent a boolean.
2047 ***************************************************************************/
2048
2049 bool lp_canonicalize_boolean(const char *str, const char**canon_str)
2050 {
2051         bool val;
2052
2053         if (!set_boolean(str, &val)) {
2054                 return false;
2055         }
2056
2057         *canon_str = get_boolean(val);
2058         return true;
2059 }
2060
2061 /***************************************************************************
2062 Find a service by name. Otherwise works like get_service.
2063 ***************************************************************************/
2064
2065 int getservicebyname(const char *pszServiceName, struct loadparm_service *pserviceDest)
2066 {
2067         int iService = -1;
2068         char *canon_name;
2069         TDB_DATA data;
2070         NTSTATUS status;
2071
2072         if (ServiceHash == NULL) {
2073                 return -1;
2074         }
2075
2076         canon_name = canonicalize_servicename(talloc_tos(), pszServiceName);
2077
2078         status = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name,
2079                                        &data);
2080
2081         if (NT_STATUS_IS_OK(status) &&
2082             (data.dptr != NULL) &&
2083             (data.dsize == sizeof(iService)))
2084         {
2085                 memcpy(&iService, data.dptr, sizeof(iService));
2086         }
2087
2088         TALLOC_FREE(canon_name);
2089
2090         if ((iService != -1) && (LP_SNUM_OK(iService))
2091             && (pserviceDest != NULL)) {
2092                 copy_service(pserviceDest, ServicePtrs[iService], NULL);
2093         }
2094
2095         return (iService);
2096 }
2097
2098 /* Return a pointer to a service by name.  Unlike getservicebyname, it does not copy the service */
2099 struct loadparm_service *lp_service(const char *pszServiceName)
2100 {
2101         int iService = getservicebyname(pszServiceName, NULL);
2102         if (iService == -1 || !LP_SNUM_OK(iService)) {
2103                 return NULL;
2104         }
2105         return ServicePtrs[iService];
2106 }
2107
2108 struct loadparm_service *lp_servicebynum(int snum)
2109 {
2110         if ((snum == -1) || !LP_SNUM_OK(snum)) {
2111                 return NULL;
2112         }
2113         return ServicePtrs[snum];
2114 }
2115
2116 struct loadparm_service *lp_default_loadparm_service()
2117 {
2118         return &sDefault;
2119 }
2120
2121 static struct smbconf_ctx *lp_smbconf_ctx(void)
2122 {
2123         sbcErr err;
2124         static struct smbconf_ctx *conf_ctx = NULL;
2125
2126         if (conf_ctx == NULL) {
2127                 err = smbconf_init(NULL, &conf_ctx, "registry:");
2128                 if (!SBC_ERROR_IS_OK(err)) {
2129                         DEBUG(1, ("error initializing registry configuration: "
2130                                   "%s\n", sbcErrorString(err)));
2131                         conf_ctx = NULL;
2132                 }
2133         }
2134
2135         return conf_ctx;
2136 }
2137
2138 static bool process_smbconf_service(struct smbconf_service *service)
2139 {
2140         uint32_t count;
2141         bool ret;
2142
2143         if (service == NULL) {
2144                 return false;
2145         }
2146
2147         ret = lp_do_section(service->name, NULL);
2148         if (ret != true) {
2149                 return false;
2150         }
2151         for (count = 0; count < service->num_params; count++) {
2152
2153                 if (!bInGlobalSection && bGlobalOnly) {
2154                         ret = true;
2155                 } else {
2156                         const char *pszParmName = service->param_names[count];
2157                         const char *pszParmValue = service->param_values[count];
2158
2159                         DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2160
2161                         ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2162                                               pszParmName, pszParmValue);
2163                 }
2164
2165                 if (ret != true) {
2166                         return false;
2167                 }
2168         }
2169         if (iServiceIndex >= 0) {
2170                 return lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2171         }
2172         return true;
2173 }
2174
2175 /**
2176  * load a service from registry and activate it
2177  */
2178 bool process_registry_service(const char *service_name)
2179 {
2180         sbcErr err;
2181         struct smbconf_service *service = NULL;
2182         TALLOC_CTX *mem_ctx = talloc_stackframe();
2183         struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2184         bool ret = false;
2185
2186         if (conf_ctx == NULL) {
2187                 goto done;
2188         }
2189
2190         DEBUG(5, ("process_registry_service: service name %s\n", service_name));
2191
2192         if (!smbconf_share_exists(conf_ctx, service_name)) {
2193                 /*
2194                  * Registry does not contain data for this service (yet),
2195                  * but make sure lp_load doesn't return false.
2196                  */
2197                 ret = true;
2198                 goto done;
2199         }
2200
2201         err = smbconf_get_share(conf_ctx, mem_ctx, service_name, &service);
2202         if (!SBC_ERROR_IS_OK(err)) {
2203                 goto done;
2204         }
2205
2206         ret = process_smbconf_service(service);
2207         if (!ret) {
2208                 goto done;
2209         }
2210
2211         /* store the csn */
2212         smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2213
2214 done:
2215         TALLOC_FREE(mem_ctx);
2216         return ret;
2217 }
2218
2219 /*
2220  * process_registry_globals
2221  */
2222 static bool process_registry_globals(void)
2223 {
2224         bool ret;
2225
2226         add_to_file_list(NULL, &file_lists, INCLUDE_REGISTRY_NAME, INCLUDE_REGISTRY_NAME);
2227
2228         if (!bInGlobalSection && bGlobalOnly) {
2229                 ret = true;
2230         } else {
2231                 const char *pszParmName = "registry shares";
2232                 const char *pszParmValue = "yes";
2233
2234                 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2235
2236                 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2237                                       pszParmName, pszParmValue);
2238         }
2239
2240         if (!ret) {
2241                 return ret;
2242         }
2243
2244         return process_registry_service(GLOBAL_NAME);
2245 }
2246
2247 bool process_registry_shares(void)
2248 {
2249         sbcErr err;
2250         uint32_t count;
2251         struct smbconf_service **service = NULL;
2252         uint32_t num_shares = 0;
2253         TALLOC_CTX *mem_ctx = talloc_stackframe();
2254         struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2255         bool ret = false;
2256
2257         if (conf_ctx == NULL) {
2258                 goto done;
2259         }
2260
2261         err = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &service);
2262         if (!SBC_ERROR_IS_OK(err)) {
2263                 goto done;
2264         }
2265
2266         ret = true;
2267
2268         for (count = 0; count < num_shares; count++) {
2269                 if (strequal(service[count]->name, GLOBAL_NAME)) {
2270                         continue;
2271                 }
2272                 ret = process_smbconf_service(service[count]);
2273                 if (!ret) {
2274                         goto done;
2275                 }
2276         }
2277
2278         /* store the csn */
2279         smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2280
2281 done:
2282         TALLOC_FREE(mem_ctx);
2283         return ret;
2284 }
2285
2286 /**
2287  * reload those shares from registry that are already
2288  * activated in the services array.
2289  */
2290 static bool reload_registry_shares(void)
2291 {
2292         int i;
2293         bool ret = true;
2294
2295         for (i = 0; i < iNumServices; i++) {
2296                 if (!VALID(i)) {
2297                         continue;
2298                 }
2299
2300                 if (ServicePtrs[i]->usershare == USERSHARE_VALID) {
2301                         continue;
2302                 }
2303
2304                 ret = process_registry_service(ServicePtrs[i]->szService);
2305                 if (!ret) {
2306                         goto done;
2307                 }
2308         }
2309
2310 done:
2311         return ret;
2312 }
2313
2314
2315 #define MAX_INCLUDE_DEPTH 100
2316
2317 static uint8_t include_depth;
2318
2319 /**
2320  * Free the file lists
2321  */
2322 static void free_file_list(void)
2323 {
2324         struct file_lists *f;
2325         struct file_lists *next;
2326
2327         f = file_lists;
2328         while( f ) {
2329                 next = f->next;
2330                 TALLOC_FREE( f );
2331                 f = next;
2332         }
2333         file_lists = NULL;
2334 }
2335
2336
2337 /**
2338  * Utility function for outsiders to check if we're running on registry.
2339  */
2340 bool lp_config_backend_is_registry(void)
2341 {
2342         return (lp_config_backend() == CONFIG_BACKEND_REGISTRY);
2343 }
2344
2345 /**
2346  * Utility function to check if the config backend is FILE.
2347  */
2348 bool lp_config_backend_is_file(void)
2349 {
2350         return (lp_config_backend() == CONFIG_BACKEND_FILE);
2351 }
2352
2353 /*******************************************************************
2354  Check if a config file has changed date.
2355 ********************************************************************/
2356
2357 bool lp_file_list_changed(void)
2358 {
2359         struct file_lists *f = file_lists;
2360
2361         DEBUG(6, ("lp_file_list_changed()\n"));
2362
2363         while (f) {
2364                 if (strequal(f->name, INCLUDE_REGISTRY_NAME)) {
2365                         struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2366
2367                         if (conf_ctx == NULL) {
2368                                 return false;
2369                         }
2370                         if (smbconf_changed(conf_ctx, &conf_last_csn, NULL,
2371                                             NULL))
2372                         {
2373                                 DEBUGADD(6, ("registry config changed\n"));
2374                                 return true;
2375                         }
2376                 } else {
2377                         time_t mod_time;
2378                         char *n2 = NULL;
2379
2380                         n2 = talloc_sub_basic(talloc_tos(),
2381                                               get_current_username(),
2382                                               current_user_info.domain,
2383                                               f->name);
2384                         if (!n2) {
2385                                 return false;
2386                         }
2387                         DEBUGADD(6, ("file %s -> %s  last mod_time: %s\n",
2388                                      f->name, n2, ctime(&f->modtime)));
2389
2390                         mod_time = file_modtime(n2);
2391
2392                         if (mod_time &&
2393                             ((f->modtime != mod_time) ||
2394                              (f->subfname == NULL) ||
2395                              (strcmp(n2, f->subfname) != 0)))
2396                         {
2397                                 DEBUGADD(6,
2398                                          ("file %s modified: %s\n", n2,
2399                                           ctime(&mod_time)));
2400                                 f->modtime = mod_time;
2401                                 TALLOC_FREE(f->subfname);
2402                                 f->subfname = talloc_strdup(f, n2);
2403                                 if (f->subfname == NULL) {
2404                                         smb_panic("talloc_strdup failed");
2405                                 }
2406                                 TALLOC_FREE(n2);
2407                                 return true;
2408                         }
2409                         TALLOC_FREE(n2);
2410                 }
2411                 f = f->next;
2412         }
2413         return false;
2414 }
2415
2416
2417 /**
2418  * Initialize iconv conversion descriptors.
2419  *
2420  * This is called the first time it is needed, and also called again
2421  * every time the configuration is reloaded, because the charset or
2422  * codepage might have changed.
2423  **/
2424 static void init_iconv(void)
2425 {
2426         struct smb_iconv_handle *ret = NULL;
2427
2428         ret = reinit_iconv_handle(NULL,
2429                                   lp_dos_charset(),
2430                                   lp_unix_charset());
2431         if (ret == NULL) {
2432                 smb_panic("reinit_iconv_handle failed");
2433         }
2434 }
2435
2436 /***************************************************************************
2437  Handle the include operation.
2438 ***************************************************************************/
2439 static bool bAllowIncludeRegistry = true;
2440
2441 bool lp_include(struct loadparm_context *lp_ctx, struct loadparm_service *service,
2442                 const char *pszParmValue, char **ptr)
2443 {
2444         char *fname;
2445
2446         if (include_depth >= MAX_INCLUDE_DEPTH) {
2447                 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
2448                           include_depth));
2449                 return false;
2450         }
2451
2452         if (strequal(pszParmValue, INCLUDE_REGISTRY_NAME)) {
2453                 if (!bAllowIncludeRegistry) {
2454                         return true;
2455                 }
2456                 if (lp_ctx->bInGlobalSection) {
2457                         bool ret;
2458                         include_depth++;
2459                         ret = process_registry_globals();
2460                         include_depth--;
2461                         return ret;
2462                 } else {
2463                         DEBUG(1, ("\"include = registry\" only effective "
2464                                   "in %s section\n", GLOBAL_NAME));
2465                         return false;
2466                 }
2467         }
2468
2469         fname = talloc_sub_basic(talloc_tos(), get_current_username(),
2470                                  current_user_info.domain,
2471                                  pszParmValue);
2472
2473         add_to_file_list(NULL, &file_lists, pszParmValue, fname);
2474
2475         if (service == NULL) {
2476                 lpcfg_string_set(Globals.ctx, ptr, fname);
2477         } else {
2478                 lpcfg_string_set(service, ptr, fname);
2479         }
2480
2481         if (file_exist(fname)) {
2482                 bool ret;
2483                 include_depth++;
2484                 ret = pm_process(fname, lp_do_section, do_parameter, lp_ctx);
2485                 include_depth--;
2486                 TALLOC_FREE(fname);
2487                 return ret;
2488         }
2489
2490         DEBUG(2, ("Can't find include file %s\n", fname));
2491         TALLOC_FREE(fname);
2492         return true;
2493 }
2494
2495 bool lp_idmap_range(const char *domain_name, uint32_t *low, uint32_t *high)
2496 {
2497         char *config_option = NULL;
2498         const char *range = NULL;
2499         bool ret = false;
2500
2501         SMB_ASSERT(low != NULL);
2502         SMB_ASSERT(high != NULL);
2503
2504         if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2505                 domain_name = "*";
2506         }
2507
2508         config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2509                                         domain_name);
2510         if (config_option == NULL) {
2511                 DEBUG(0, ("out of memory\n"));
2512                 return false;
2513         }
2514
2515         range = lp_parm_const_string(-1, config_option, "range", NULL);
2516         if (range == NULL) {
2517                 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name));
2518                 goto done;
2519         }
2520
2521         if (sscanf(range, "%u - %u", low, high) != 2) {
2522                 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2523                           range, domain_name));
2524                 goto done;
2525         }
2526
2527         ret = true;
2528
2529 done:
2530         talloc_free(config_option);
2531         return ret;
2532
2533 }
2534
2535 bool lp_idmap_default_range(uint32_t *low, uint32_t *high)
2536 {
2537         return lp_idmap_range("*", low, high);
2538 }
2539
2540 const char *lp_idmap_backend(const char *domain_name)
2541 {
2542         char *config_option = NULL;
2543         const char *backend = NULL;
2544
2545         if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2546                 domain_name = "*";
2547         }
2548
2549         config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2550                                         domain_name);
2551         if (config_option == NULL) {
2552                 DEBUG(0, ("out of memory\n"));
2553                 return false;
2554         }
2555
2556         backend = lp_parm_const_string(-1, config_option, "backend", NULL);
2557         if (backend == NULL) {
2558                 DEBUG(1, ("idmap backend not specified for domain '%s'\n", domain_name));
2559                 goto done;
2560         }
2561
2562 done:
2563         talloc_free(config_option);
2564         return backend;
2565 }
2566
2567 const char *lp_idmap_default_backend(void)
2568 {
2569         return lp_idmap_backend("*");
2570 }
2571
2572 /***************************************************************************
2573  Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2574 ***************************************************************************/
2575
2576 static const char *append_ldap_suffix(TALLOC_CTX *ctx, const char *str )
2577 {
2578         const char *suffix_string;
2579
2580         suffix_string = talloc_asprintf(ctx, "%s,%s", str,
2581                                         Globals.ldap_suffix );
2582         if ( !suffix_string ) {
2583                 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2584                 return "";
2585         }
2586
2587         return suffix_string;
2588 }
2589
2590 const char *lp_ldap_machine_suffix(TALLOC_CTX *ctx)
2591 {
2592         if (Globals._ldap_machine_suffix[0])
2593                 return append_ldap_suffix(ctx, Globals._ldap_machine_suffix);
2594
2595         return talloc_strdup(ctx, Globals.ldap_suffix);
2596 }
2597
2598 const char *lp_ldap_user_suffix(TALLOC_CTX *ctx)
2599 {
2600         if (Globals._ldap_user_suffix[0])
2601                 return append_ldap_suffix(ctx, Globals._ldap_user_suffix);
2602
2603         return talloc_strdup(ctx, Globals.ldap_suffix);
2604 }
2605
2606 const char *lp_ldap_group_suffix(TALLOC_CTX *ctx)
2607 {
2608         if (Globals._ldap_group_suffix[0])
2609                 return append_ldap_suffix(ctx, Globals._ldap_group_suffix);
2610
2611         return talloc_strdup(ctx, Globals.ldap_suffix);
2612 }
2613
2614 const char *lp_ldap_idmap_suffix(TALLOC_CTX *ctx)
2615 {
2616         if (Globals._ldap_idmap_suffix[0])
2617                 return append_ldap_suffix(ctx, Globals._ldap_idmap_suffix);
2618
2619         return talloc_strdup(ctx, Globals.ldap_suffix);
2620 }
2621
2622 /**
2623   return the parameter pointer for a parameter
2624 */
2625 void *lp_parm_ptr(struct loadparm_service *service, struct parm_struct *parm)
2626 {
2627         if (service == NULL) {
2628                 if (parm->p_class == P_LOCAL)
2629                         return (void *)(((char *)&sDefault)+parm->offset);
2630                 else if (parm->p_class == P_GLOBAL)
2631                         return (void *)(((char *)&Globals)+parm->offset);
2632                 else return NULL;
2633         } else {
2634                 return (void *)(((char *)service) + parm->offset);
2635         }
2636 }
2637
2638 /***************************************************************************
2639  Process a parameter for a particular service number. If snum < 0
2640  then assume we are in the globals.
2641 ***************************************************************************/
2642
2643 bool lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
2644 {
2645         TALLOC_CTX *frame = talloc_stackframe();
2646         struct loadparm_context *lp_ctx;
2647         bool ok;
2648
2649         lp_ctx = setup_lp_context(frame);
2650         if (lp_ctx == NULL) {
2651                 TALLOC_FREE(frame);
2652                 return false;
2653         }
2654
2655         if (snum < 0) {
2656                 ok = lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue);
2657         } else {
2658                 ok = lpcfg_do_service_parameter(lp_ctx, ServicePtrs[snum],
2659                                                 pszParmName, pszParmValue);
2660         }
2661
2662         TALLOC_FREE(frame);
2663
2664         return ok;
2665 }
2666
2667 /***************************************************************************
2668 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
2669 FLAG_CMDLINE won't be overridden by loads from smb.conf.
2670 ***************************************************************************/
2671
2672 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue)
2673 {
2674         int parmnum, i;
2675         parmnum = lpcfg_map_parameter(pszParmName);
2676         if (parmnum >= 0) {
2677                 flags_list[parmnum] &= ~FLAG_CMDLINE;
2678                 if (!lp_do_parameter(-1, pszParmName, pszParmValue)) {
2679                         return false;
2680                 }
2681                 flags_list[parmnum] |= FLAG_CMDLINE;
2682
2683                 /* we have to also set FLAG_CMDLINE on aliases.  Aliases must
2684                  * be grouped in the table, so we don't have to search the
2685                  * whole table */
2686                 for (i=parmnum-1;
2687                      i>=0 && parm_table[i].offset == parm_table[parmnum].offset
2688                              && parm_table[i].p_class == parm_table[parmnum].p_class;
2689                      i--) {
2690                         flags_list[i] |= FLAG_CMDLINE;
2691                 }
2692                 for (i=parmnum+1;i<num_parameters() && parm_table[i].offset == parm_table[parmnum].offset
2693                              && parm_table[i].p_class == parm_table[parmnum].p_class;i++) {
2694                         flags_list[i] |= FLAG_CMDLINE;
2695                 }
2696
2697                 return true;
2698         }
2699
2700         /* it might be parametric */
2701         if (strchr(pszParmName, ':') != NULL) {
2702                 set_param_opt(NULL, &Globals.param_opt, pszParmName, pszParmValue, FLAG_CMDLINE);
2703                 return true;
2704         }
2705
2706         DEBUG(0, ("Ignoring unknown parameter \"%s\"\n",  pszParmName));
2707         return false;
2708 }
2709
2710 bool lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
2711 {
2712         bool ret;
2713         TALLOC_CTX *frame = talloc_stackframe();
2714         struct loadparm_context *lp_ctx;
2715
2716         lp_ctx = setup_lp_context(frame);
2717         if (lp_ctx == NULL) {
2718                 TALLOC_FREE(frame);
2719                 return false;
2720         }
2721
2722         ret = lpcfg_set_cmdline(lp_ctx, pszParmName, pszParmValue);
2723
2724         TALLOC_FREE(frame);
2725         return ret;
2726 }
2727
2728 /***************************************************************************
2729  Process a parameter.
2730 ***************************************************************************/
2731
2732 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
2733                          void *userdata)
2734 {
2735         if (!bInGlobalSection && bGlobalOnly)
2736                 return true;
2737
2738         DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2739
2740         if (bInGlobalSection) {
2741                 return lpcfg_do_global_parameter(userdata, pszParmName, pszParmValue);
2742         } else {
2743                 return lpcfg_do_service_parameter(userdata, ServicePtrs[iServiceIndex],
2744                                                   pszParmName, pszParmValue);
2745         }
2746 }
2747
2748 /***************************************************************************
2749  Initialize any local variables in the sDefault table, after parsing a
2750  [globals] section.
2751 ***************************************************************************/
2752
2753 static void init_locals(void)
2754 {
2755         /*
2756          * We run this check once the [globals] is parsed, to force
2757          * the VFS objects and other per-share settings we need for
2758          * the standard way a AD DC is operated.  We may change these
2759          * as our code evolves, which is why we force these settings.
2760          *
2761          * We can't do this at the end of lp_load_ex(), as by that
2762          * point the services have been loaded and they will already
2763          * have "" as their vfs objects.
2764          */
2765         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
2766                 const char **vfs_objects = lp_vfs_objects(-1);
2767                 if (!vfs_objects || !vfs_objects[0]) {
2768                         if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL)) {
2769                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
2770                         } else if (lp_parm_const_string(-1, "posix", "eadb", NULL)) {
2771                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
2772                         } else {
2773                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
2774                         }
2775                 }
2776
2777                 lp_do_parameter(-1, "map hidden", "no");
2778                 lp_do_parameter(-1, "map system", "no");
2779                 lp_do_parameter(-1, "map readonly", "no");
2780                 lp_do_parameter(-1, "map archive", "no");
2781                 lp_do_parameter(-1, "store dos attributes", "yes");
2782         }
2783 }
2784
2785 /***************************************************************************
2786  Process a new section (service). At this stage all sections are services.
2787  Later we'll have special sections that permit server parameters to be set.
2788  Returns true on success, false on failure.
2789 ***************************************************************************/
2790
2791 bool lp_do_section(const char *pszSectionName, void *userdata)
2792 {
2793         struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
2794         bool bRetval;
2795         bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
2796                          (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
2797
2798         /* if we were in a global section then do the local inits */
2799         if (bInGlobalSection && !isglobal)
2800                 init_locals();
2801
2802         /* if we've just struck a global section, note the fact. */
2803         bInGlobalSection = isglobal;
2804         if (lp_ctx != NULL) {
2805                 lp_ctx->bInGlobalSection = isglobal;
2806         }
2807
2808         /* check for multiple global sections */
2809         if (bInGlobalSection) {
2810                 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
2811                 return true;
2812         }
2813
2814         if (!bInGlobalSection && bGlobalOnly)
2815                 return true;
2816
2817         /* if we have a current service, tidy it up before moving on */
2818         bRetval = true;
2819
2820         if (iServiceIndex >= 0)
2821                 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2822
2823         /* if all is still well, move to the next record in the services array */
2824         if (bRetval) {
2825                 /* We put this here to avoid an odd message order if messages are */
2826                 /* issued by the post-processing of a previous section. */
2827                 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
2828
2829                 iServiceIndex = add_a_service(&sDefault, pszSectionName);
2830                 if (iServiceIndex < 0) {
2831                         DEBUG(0, ("Failed to add a new service\n"));
2832                         return false;
2833                 }
2834                 /* Clean all parametric options for service */
2835                 /* They will be added during parsing again */
2836                 free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
2837         }
2838
2839         return bRetval;
2840 }
2841
2842 /***************************************************************************
2843  Display the contents of a parameter of a single services record.
2844 ***************************************************************************/
2845
2846 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
2847 {
2848         bool result = false;
2849         struct loadparm_context *lp_ctx;
2850
2851         lp_ctx = setup_lp_context(talloc_tos());
2852         if (lp_ctx == NULL) {
2853                 return false;
2854         }
2855
2856         if (isGlobal) {
2857                 result = lpcfg_dump_a_parameter(lp_ctx, NULL, parm_name, f);
2858         } else {
2859                 result = lpcfg_dump_a_parameter(lp_ctx, ServicePtrs[snum], parm_name, f);
2860         }
2861         TALLOC_FREE(lp_ctx);
2862         return result;
2863 }
2864
2865 #if 0
2866 /***************************************************************************
2867  Display the contents of a single copy structure.
2868 ***************************************************************************/
2869 static void dump_copy_map(bool *pcopymap)
2870 {
2871         int i;
2872         if (!pcopymap)
2873                 return;
2874
2875         printf("\n\tNon-Copied parameters:\n");
2876
2877         for (i = 0; parm_table[i].label; i++)
2878                 if (parm_table[i].p_class == P_LOCAL &&
2879                     parm_table[i].ptr && !pcopymap[i] &&
2880                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
2881                 {
2882                         printf("\t\t%s\n", parm_table[i].label);
2883                 }
2884 }
2885 #endif
2886
2887 /***************************************************************************
2888  Return TRUE if the passed service number is within range.
2889 ***************************************************************************/
2890
2891 bool lp_snum_ok(int iService)
2892 {
2893         return (LP_SNUM_OK(iService) && ServicePtrs[iService]->available);
2894 }
2895
2896 /***************************************************************************
2897  Auto-load some home services.
2898 ***************************************************************************/
2899
2900 static void lp_add_auto_services(const char *str)
2901 {
2902         char *s;
2903         char *p;
2904         int homes;
2905         char *saveptr;
2906
2907         if (!str)
2908                 return;
2909
2910         s = talloc_strdup(talloc_tos(), str);
2911         if (!s) {
2912                 smb_panic("talloc_strdup failed");
2913                 return;
2914         }
2915
2916         homes = lp_servicenumber(HOMES_NAME);
2917
2918         for (p = strtok_r(s, LIST_SEP, &saveptr); p;
2919              p = strtok_r(NULL, LIST_SEP, &saveptr)) {
2920                 char *home;
2921
2922                 if (lp_servicenumber(p) >= 0)
2923                         continue;
2924
2925                 home = get_user_home_dir(talloc_tos(), p);
2926
2927                 if (home && home[0] && homes >= 0)
2928                         lp_add_home(p, homes, p, home);
2929
2930                 TALLOC_FREE(home);
2931         }
2932         TALLOC_FREE(s);
2933 }
2934
2935 /***************************************************************************
2936  Auto-load one printer.
2937 ***************************************************************************/
2938
2939 void lp_add_one_printer(const char *name, const char *comment,
2940                         const char *location, void *pdata)
2941 {
2942         int printers = lp_servicenumber(PRINTERS_NAME);
2943         int i;
2944
2945         if (lp_servicenumber(name) < 0) {
2946                 lp_add_printer(name, printers);
2947                 if ((i = lp_servicenumber(name)) >= 0) {
2948                         lpcfg_string_set(ServicePtrs[i],
2949                                          &ServicePtrs[i]->comment, comment);
2950                         ServicePtrs[i]->autoloaded = true;
2951                 }
2952         }
2953 }
2954
2955 /***************************************************************************
2956  Have we loaded a services file yet?
2957 ***************************************************************************/
2958
2959 bool lp_loaded(void)
2960 {
2961         return (bLoaded);
2962 }
2963
2964 /***************************************************************************
2965  Unload unused services.
2966 ***************************************************************************/
2967
2968 void lp_killunused(struct smbd_server_connection *sconn,
2969                    bool (*snumused) (struct smbd_server_connection *, int))
2970 {
2971         int i;
2972         for (i = 0; i < iNumServices; i++) {
2973                 if (!VALID(i))
2974                         continue;
2975
2976                 /* don't kill autoloaded or usershare services */
2977                 if ( ServicePtrs[i]->autoloaded ||
2978                                 ServicePtrs[i]->usershare == USERSHARE_VALID) {
2979                         continue;
2980                 }
2981
2982                 if (!snumused || !snumused(sconn, i)) {
2983                         free_service_byindex(i);
2984                 }
2985         }
2986 }
2987
2988 /**
2989  * Kill all except autoloaded and usershare services - convenience wrapper
2990  */
2991 void lp_kill_all_services(void)
2992 {
2993         lp_killunused(NULL, NULL);
2994 }
2995
2996 /***************************************************************************
2997  Unload a service.
2998 ***************************************************************************/
2999
3000 void lp_killservice(int iServiceIn)
3001 {
3002         if (VALID(iServiceIn)) {
3003                 free_service_byindex(iServiceIn);
3004         }
3005 }
3006
3007 /***************************************************************************
3008  Save the curent values of all global and sDefault parameters into the
3009  defaults union. This allows testparm to show only the
3010  changed (ie. non-default) parameters.
3011 ***************************************************************************/
3012
3013 static void lp_save_defaults(void)
3014 {
3015         int i;
3016         struct parmlist_entry * parm;
3017         for (i = 0; parm_table[i].label; i++) {
3018                 if (!(flags_list[i] & FLAG_CMDLINE)) {
3019                         flags_list[i] |= FLAG_DEFAULT;
3020                 }
3021
3022                 if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
3023                     && parm_table[i].p_class == parm_table[i - 1].p_class)
3024                         continue;
3025                 switch (parm_table[i].type) {
3026                         case P_LIST:
3027                         case P_CMDLIST:
3028                                 parm_table[i].def.lvalue = str_list_copy(
3029                                         NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
3030                                 break;
3031                         case P_STRING:
3032                         case P_USTRING:
3033                                 lpcfg_string_set(
3034                                         Globals.ctx,
3035                                         &parm_table[i].def.svalue,
3036                                         *(char **)lp_parm_ptr(
3037                                                 NULL, &parm_table[i]));
3038                                 if (parm_table[i].def.svalue == NULL) {
3039                                         smb_panic("lpcfg_string_set() failed");
3040                                 }
3041                                 break;
3042                         case P_BOOL:
3043                         case P_BOOLREV:
3044                                 parm_table[i].def.bvalue =
3045                                         *(bool *)lp_parm_ptr(NULL, &parm_table[i]);
3046                                 break;
3047                         case P_CHAR:
3048                                 parm_table[i].def.cvalue =
3049                                         *(char *)lp_parm_ptr(NULL, &parm_table[i]);
3050                                 break;
3051                         case P_INTEGER:
3052                         case P_OCTAL:
3053                         case P_ENUM:
3054                         case P_BYTES:
3055                                 parm_table[i].def.ivalue =
3056                                         *(int *)lp_parm_ptr(NULL, &parm_table[i]);
3057                                 break;
3058                 }
3059         }
3060
3061         for (parm=Globals.param_opt; parm; parm=parm->next) {
3062                 if (!(parm->priority & FLAG_CMDLINE)) {
3063                         parm->priority |= FLAG_DEFAULT;
3064                 }
3065         }
3066
3067         for (parm=sDefault.param_opt; parm; parm=parm->next) {
3068                 if (!(parm->priority & FLAG_CMDLINE)) {
3069                         parm->priority |= FLAG_DEFAULT;
3070                 }
3071         }
3072
3073         defaults_saved = true;
3074 }
3075
3076 /***********************************************************
3077  If we should send plaintext/LANMAN passwords in the clinet
3078 ************************************************************/
3079
3080 static void set_allowed_client_auth(void)
3081 {
3082         if (Globals.client_ntlmv2_auth) {
3083                 Globals.client_lanman_auth = false;
3084         }
3085         if (!Globals.client_lanman_auth) {
3086                 Globals.client_plaintext_auth = false;
3087         }
3088 }
3089
3090 /***************************************************************************
3091  JRA.
3092  The following code allows smbd to read a user defined share file.
3093  Yes, this is my intent. Yes, I'm comfortable with that...
3094
3095  THE FOLLOWING IS SECURITY CRITICAL CODE.
3096
3097  It washes your clothes, it cleans your house, it guards you while you sleep...
3098  Do not f%^k with it....
3099 ***************************************************************************/
3100
3101 #define MAX_USERSHARE_FILE_SIZE (10*1024)
3102
3103 /***************************************************************************
3104  Check allowed stat state of a usershare file.
3105  Ensure we print out who is dicking with us so the admin can
3106  get their sorry ass fired.
3107 ***************************************************************************/
3108
3109 static bool check_usershare_stat(const char *fname,
3110                                  const SMB_STRUCT_STAT *psbuf)
3111 {
3112         if (!S_ISREG(psbuf->st_ex_mode)) {
3113                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3114                         "not a regular file\n",
3115                         fname, (unsigned int)psbuf->st_ex_uid ));
3116                 return false;
3117         }
3118
3119         /* Ensure this doesn't have the other write bit set. */
3120         if (psbuf->st_ex_mode & S_IWOTH) {
3121                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
3122                         "public write. Refusing to allow as a usershare file.\n",
3123                         fname, (unsigned int)psbuf->st_ex_uid ));
3124                 return false;
3125         }
3126
3127         /* Should be 10k or less. */
3128         if (psbuf->st_ex_size > MAX_USERSHARE_FILE_SIZE) {
3129                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3130                         "too large (%u) to be a user share file.\n",
3131                         fname, (unsigned int)psbuf->st_ex_uid,
3132                         (unsigned int)psbuf->st_ex_size ));
3133                 return false;
3134         }
3135
3136         return true;
3137 }
3138
3139 /***************************************************************************
3140  Parse the contents of a usershare file.
3141 ***************************************************************************/
3142
3143 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
3144                         SMB_STRUCT_STAT *psbuf,
3145                         const char *servicename,
3146                         int snum,
3147                         char **lines,
3148                         int numlines,
3149                         char **pp_sharepath,
3150                         char **pp_comment,
3151                         char **pp_cp_servicename,
3152                         struct security_descriptor **ppsd,
3153                         bool *pallow_guest)
3154 {
3155         const char **prefixallowlist = lp_usershare_prefix_allow_list();
3156         const char **prefixdenylist = lp_usershare_prefix_deny_list();
3157         int us_vers;
3158         DIR *dp;
3159         SMB_STRUCT_STAT sbuf;
3160         char *sharepath = NULL;
3161         char *comment = NULL;
3162
3163         *pp_sharepath = NULL;
3164         *pp_comment = NULL;
3165
3166         *pallow_guest = false;
3167
3168         if (numlines < 4) {
3169                 return USERSHARE_MALFORMED_FILE;
3170         }
3171
3172         if (strcmp(lines[0], "#VERSION 1") == 0) {
3173                 us_vers = 1;
3174         } else if (strcmp(lines[0], "#VERSION 2") == 0) {
3175                 us_vers = 2;
3176                 if (numlines < 5) {
3177                         return USERSHARE_MALFORMED_FILE;
3178                 }
3179         } else {
3180                 return USERSHARE_BAD_VERSION;
3181         }
3182
3183         if (strncmp(lines[1], "path=", 5) != 0) {
3184                 return USERSHARE_MALFORMED_PATH;
3185         }
3186
3187         sharepath = talloc_strdup(ctx, &lines[1][5]);
3188         if (!sharepath) {
3189                 return USERSHARE_POSIX_ERR;
3190         }
3191         trim_string(sharepath, " ", " ");
3192
3193         if (strncmp(lines[2], "comment=", 8) != 0) {
3194                 return USERSHARE_MALFORMED_COMMENT_DEF;
3195         }
3196
3197         comment = talloc_strdup(ctx, &lines[2][8]);
3198         if (!comment) {
3199                 return USERSHARE_POSIX_ERR;
3200         }
3201         trim_string(comment, " ", " ");
3202         trim_char(comment, '"', '"');
3203
3204         if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
3205                 return USERSHARE_MALFORMED_ACL_DEF;
3206         }
3207
3208         if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
3209                 return USERSHARE_ACL_ERR;
3210         }
3211
3212         if (us_vers == 2) {
3213                 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
3214                         return USERSHARE_MALFORMED_ACL_DEF;
3215                 }
3216                 if (lines[4][9] == 'y') {
3217                         *pallow_guest = true;
3218                 }
3219
3220                 /* Backwards compatible extension to file version #2. */
3221                 if (numlines > 5) {
3222                         if (strncmp(lines[5], "sharename=", 10) != 0) {
3223                                 return USERSHARE_MALFORMED_SHARENAME_DEF;
3224                         }
3225                         if (!strequal(&lines[5][10], servicename)) {
3226                                 return USERSHARE_BAD_SHARENAME;
3227                         }
3228                         *pp_cp_servicename = talloc_strdup(ctx, &lines[5][10]);
3229                         if (!*pp_cp_servicename) {
3230                                 return USERSHARE_POSIX_ERR;
3231                         }
3232                 }
3233         }
3234
3235         if (*pp_cp_servicename == NULL) {
3236                 *pp_cp_servicename = talloc_strdup(ctx, servicename);
3237                 if (!*pp_cp_servicename) {
3238                         return USERSHARE_POSIX_ERR;
3239                 }
3240         }
3241
3242         if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->path) == 0)) {
3243                 /* Path didn't change, no checks needed. */
3244                 *pp_sharepath = sharepath;
3245                 *pp_comment = comment;
3246                 return USERSHARE_OK;
3247         }
3248
3249         /* The path *must* be absolute. */
3250         if (sharepath[0] != '/') {
3251                 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
3252                         servicename, sharepath));
3253                 return USERSHARE_PATH_NOT_ABSOLUTE;
3254         }
3255
3256         /* If there is a usershare prefix deny list ensure one of these paths
3257            doesn't match the start of the user given path. */
3258         if (prefixdenylist) {
3259                 int i;
3260                 for ( i=0; prefixdenylist[i]; i++ ) {
3261                         DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
3262                                 servicename, i, prefixdenylist[i], sharepath ));
3263                         if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
3264                                 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
3265                                         "usershare prefix deny list entries.\n",
3266                                         servicename, sharepath));
3267                                 return USERSHARE_PATH_IS_DENIED;
3268                         }
3269                 }
3270         }
3271
3272         /* If there is a usershare prefix allow list ensure one of these paths
3273            does match the start of the user given path. */
3274
3275         if (prefixallowlist) {
3276                 int i;
3277                 for ( i=0; prefixallowlist[i]; i++ ) {
3278                         DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
3279                                 servicename, i, prefixallowlist[i], sharepath ));
3280                         if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
3281                                 break;
3282                         }
3283                 }
3284                 if (prefixallowlist[i] == NULL) {
3285                         DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
3286                                 "usershare prefix allow list entries.\n",
3287                                 servicename, sharepath));
3288                         return USERSHARE_PATH_NOT_ALLOWED;
3289                 }
3290         }
3291
3292         /* Ensure this is pointing to a directory. */
3293         dp = opendir(sharepath);
3294
3295         if (!dp) {
3296                 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3297                         servicename, sharepath));
3298                 return USERSHARE_PATH_NOT_DIRECTORY;
3299         }
3300
3301         /* Ensure the owner of the usershare file has permission to share
3302            this directory. */
3303
3304         if (sys_stat(sharepath, &sbuf, false) == -1) {
3305                 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
3306                         servicename, sharepath, strerror(errno) ));
3307                 closedir(dp);
3308                 return USERSHARE_POSIX_ERR;
3309         }
3310
3311         closedir(dp);
3312
3313         if (!S_ISDIR(sbuf.st_ex_mode)) {
3314                 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3315                         servicename, sharepath ));
3316                 return USERSHARE_PATH_NOT_DIRECTORY;
3317         }
3318
3319         /* Check if sharing is restricted to owner-only. */
3320         /* psbuf is the stat of the usershare definition file,
3321            sbuf is the stat of the target directory to be shared. */
3322
3323         if (lp_usershare_owner_only()) {
3324                 /* root can share anything. */
3325                 if ((psbuf->st_ex_uid != 0) && (sbuf.st_ex_uid != psbuf->st_ex_uid)) {
3326                         return USERSHARE_PATH_NOT_ALLOWED;
3327                 }
3328         }
3329
3330         *pp_sharepath = sharepath;
3331         *pp_comment = comment;
3332         return USERSHARE_OK;
3333 }
3334
3335 /***************************************************************************
3336  Deal with a usershare file.
3337  Returns:
3338         >= 0 - snum
3339         -1 - Bad name, invalid contents.
3340            - service name already existed and not a usershare, problem
3341             with permissions to share directory etc.
3342 ***************************************************************************/
3343
3344 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
3345 {
3346         SMB_STRUCT_STAT sbuf;
3347         SMB_STRUCT_STAT lsbuf;
3348         char *fname = NULL;
3349         char *sharepath = NULL;
3350         char *comment = NULL;
3351         char *cp_service_name = NULL;
3352         char **lines = NULL;
3353         int numlines = 0;
3354         int fd = -1;
3355         int iService = -1;
3356         TALLOC_CTX *ctx = talloc_stackframe();
3357         struct security_descriptor *psd = NULL;
3358         bool guest_ok = false;
3359         char *canon_name = NULL;
3360         bool added_service = false;
3361         int ret = -1;
3362         NTSTATUS status;
3363
3364         /* Ensure share name doesn't contain invalid characters. */
3365         if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
3366                 DEBUG(0,("process_usershare_file: share name %s contains "
3367                         "invalid characters (any of %s)\n",
3368                         file_name, INVALID_SHARENAME_CHARS ));
3369                 goto out;
3370         }
3371
3372         canon_name = canonicalize_servicename(ctx, file_name);
3373         if (!canon_name) {
3374                 goto out;
3375         }
3376
3377         fname = talloc_asprintf(ctx, "%s/%s", dir_name, file_name);
3378         if (!fname) {
3379                 goto out;
3380         }
3381
3382         /* Minimize the race condition by doing an lstat before we
3383            open and fstat. Ensure this isn't a symlink link. */
3384
3385         if (sys_lstat(fname, &lsbuf, false) != 0) {
3386                 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
3387                         fname, strerror(errno) ));
3388                 goto out;
3389         }
3390
3391         /* This must be a regular file, not a symlink, directory or
3392            other strange filetype. */
3393         if (!check_usershare_stat(fname, &lsbuf)) {
3394                 goto out;
3395         }
3396
3397         {
3398                 TDB_DATA data;
3399
3400                 status = dbwrap_fetch_bystring(ServiceHash, canon_name,
3401                                                canon_name, &data);
3402
3403                 iService = -1;
3404
3405                 if (NT_STATUS_IS_OK(status) &&
3406                     (data.dptr != NULL) &&
3407                     (data.dsize == sizeof(iService))) {
3408                         memcpy(&iService, data.dptr, sizeof(iService));
3409                 }
3410         }
3411
3412         if (iService != -1 &&
3413             timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
3414                              &lsbuf.st_ex_mtime) == 0) {
3415                 /* Nothing changed - Mark valid and return. */
3416                 DEBUG(10,("process_usershare_file: service %s not changed.\n",
3417                         canon_name ));
3418                 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3419                 ret = iService;
3420                 goto out;
3421         }
3422
3423         /* Try and open the file read only - no symlinks allowed. */
3424 #ifdef O_NOFOLLOW
3425         fd = open(fname, O_RDONLY|O_NOFOLLOW, 0);
3426 #else
3427         fd = open(fname, O_RDONLY, 0);
3428 #endif
3429
3430         if (fd == -1) {
3431                 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
3432                         fname, strerror(errno) ));
3433                 goto out;
3434         }
3435
3436         /* Now fstat to be *SURE* it's a regular file. */
3437         if (sys_fstat(fd, &sbuf, false) != 0) {
3438                 close(fd);
3439                 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
3440                         fname, strerror(errno) ));
3441                 goto out;
3442         }
3443
3444         /* Is it the same dev/inode as was lstated ? */
3445         if (!check_same_stat(&lsbuf, &sbuf)) {
3446                 close(fd);
3447                 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
3448                         "Symlink spoofing going on ?\n", fname ));
3449                 goto out;
3450         }
3451
3452         /* This must be a regular file, not a symlink, directory or
3453            other strange filetype. */
3454         if (!check_usershare_stat(fname, &sbuf)) {
3455                 close(fd);
3456                 goto out;
3457         }
3458
3459         lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE, NULL);
3460
3461         close(fd);
3462         if (lines == NULL) {
3463                 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
3464                         fname, (unsigned int)sbuf.st_ex_uid ));
3465                 goto out;
3466         }
3467
3468         if (parse_usershare_file(ctx, &sbuf, file_name,
3469                         iService, lines, numlines, &sharepath,
3470                         &comment, &cp_service_name,
3471                         &psd, &guest_ok) != USERSHARE_OK) {
3472                 goto out;
3473         }
3474
3475         /* Everything ok - add the service possibly using a template. */
3476         if (iService < 0) {
3477                 const struct loadparm_service *sp = &sDefault;
3478                 if (snum_template != -1) {
3479                         sp = ServicePtrs[snum_template];
3480                 }
3481
3482                 if ((iService = add_a_service(sp, cp_service_name)) < 0) {
3483                         DEBUG(0, ("process_usershare_file: Failed to add "
3484                                 "new service %s\n", cp_service_name));
3485                         goto out;
3486                 }
3487
3488                 added_service = true;
3489
3490                 /* Read only is controlled by usershare ACL below. */
3491                 ServicePtrs[iService]->read_only = false;
3492         }
3493
3494         /* Write the ACL of the new/modified share. */
3495         status = set_share_security(canon_name, psd);
3496         if (!NT_STATUS_IS_OK(status)) {
3497                  DEBUG(0, ("process_usershare_file: Failed to set share "
3498                         "security for user share %s\n",
3499                         canon_name ));
3500                 goto out;
3501         }
3502
3503         /* If from a template it may be marked invalid. */
3504         ServicePtrs[iService]->valid = true;
3505
3506         /* Set the service as a valid usershare. */
3507         ServicePtrs[iService]->usershare = USERSHARE_VALID;
3508
3509         /* Set guest access. */
3510         if (lp_usershare_allow_guests()) {
3511                 ServicePtrs[iService]->guest_ok = guest_ok;
3512         }
3513
3514         /* And note when it was loaded. */
3515         ServicePtrs[iService]->usershare_last_mod = sbuf.st_ex_mtime;
3516         lpcfg_string_set(ServicePtrs[iService], &ServicePtrs[iService]->path,
3517                          sharepath);
3518         lpcfg_string_set(ServicePtrs[iService],
3519                          &ServicePtrs[iService]->comment, comment);
3520
3521         ret = iService;
3522
3523   out:
3524
3525         if (ret == -1 && iService != -1 && added_service) {
3526                 lp_remove_service(iService);
3527         }
3528
3529         TALLOC_FREE(lines);
3530         TALLOC_FREE(ctx);
3531         return ret;
3532 }
3533
3534 /***************************************************************************
3535  Checks if a usershare entry has been modified since last load.
3536 ***************************************************************************/
3537
3538 static bool usershare_exists(int iService, struct timespec *last_mod)
3539 {
3540         SMB_STRUCT_STAT lsbuf;
3541         const char *usersharepath = Globals.usershare_path;
3542         char *fname;
3543
3544         fname = talloc_asprintf(talloc_tos(),
3545                                 "%s/%s",
3546                                 usersharepath,
3547                                 ServicePtrs[iService]->szService);
3548         if (fname == NULL) {
3549                 return false;
3550         }
3551
3552         if (sys_lstat(fname, &lsbuf, false) != 0) {
3553                 TALLOC_FREE(fname);
3554                 return false;
3555         }
3556
3557         if (!S_ISREG(lsbuf.st_ex_mode)) {
3558                 TALLOC_FREE(fname);
3559                 return false;
3560         }
3561
3562         TALLOC_FREE(fname);
3563         *last_mod = lsbuf.st_ex_mtime;
3564         return true;
3565 }
3566
3567 static bool usershare_directory_is_root(uid_t uid)
3568 {
3569         if (uid == 0) {
3570                 return true;
3571         }
3572
3573         if (uid_wrapper_enabled()) {
3574                 return true;
3575         }
3576
3577         return false;
3578 }
3579
3580 /***************************************************************************
3581  Load a usershare service by name. Returns a valid servicenumber or -1.
3582 ***************************************************************************/
3583
3584 int load_usershare_service(const char *servicename)
3585 {
3586         SMB_STRUCT_STAT sbuf;
3587         const char *usersharepath = Globals.usershare_path;
3588         int max_user_shares = Globals.usershare_max_shares;
3589         int snum_template = -1;
3590
3591         if (*usersharepath == 0 ||  max_user_shares == 0) {
3592                 return -1;
3593         }
3594
3595         if (sys_stat(usersharepath, &sbuf, false) != 0) {
3596                 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
3597                         usersharepath, strerror(errno) ));
3598                 return -1;
3599         }
3600
3601         if (!S_ISDIR(sbuf.st_ex_mode)) {
3602                 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
3603                         usersharepath ));
3604                 return -1;
3605         }
3606
3607         /*
3608          * This directory must be owned by root, and have the 't' bit set.
3609          * It also must not be writable by "other".
3610          */
3611
3612 #ifdef S_ISVTX
3613         if (!usershare_directory_is_root(sbuf.st_ex_uid) ||
3614             !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3615 #else
3616         if (!usershare_directory_is_root(sbuf.st_ex_uid) ||
3617             (sbuf.st_ex_mode & S_IWOTH)) {
3618 #endif
3619                 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
3620                         "or does not have the sticky bit 't' set or is writable by anyone.\n",
3621                         usersharepath ));
3622                 return -1;
3623         }
3624
3625         /* Ensure the template share exists if it's set. */
3626         if (Globals.usershare_template_share[0]) {
3627                 /* We can't use lp_servicenumber here as we are recommending that
3628                    template shares have -valid=false set. */
3629                 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3630                         if (ServicePtrs[snum_template]->szService &&
3631                                         strequal(ServicePtrs[snum_template]->szService,
3632                                                 Globals.usershare_template_share)) {
3633                                 break;
3634                         }
3635                 }
3636
3637                 if (snum_template == -1) {
3638                         DEBUG(0,("load_usershare_service: usershare template share %s "
3639                                 "does not exist.\n",
3640                                 Globals.usershare_template_share ));
3641                         return -1;
3642                 }
3643         }
3644
3645         return process_usershare_file(usersharepath, servicename, snum_template);
3646 }
3647
3648 /***************************************************************************
3649  Load all user defined shares from the user share directory.
3650  We only do this if we're enumerating the share list.
3651  This is the function that can delete usershares that have
3652  been removed.
3653 ***************************************************************************/
3654
3655 int load_usershare_shares(struct smbd_server_connection *sconn,
3656                           bool (*snumused) (struct smbd_server_connection *, int))
3657 {
3658         DIR *dp;
3659         SMB_STRUCT_STAT sbuf;
3660         struct dirent *de;
3661         int num_usershares = 0;
3662         int max_user_shares = Globals.usershare_max_shares;
3663         unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
3664         unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
3665         unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
3666         int iService;
3667         int snum_template = -1;
3668         const char *usersharepath = Globals.usershare_path;
3669         int ret = lp_numservices();
3670         TALLOC_CTX *tmp_ctx;
3671
3672         if (max_user_shares == 0 || *usersharepath == '\0') {
3673                 return lp_numservices();
3674         }
3675
3676         if (sys_stat(usersharepath, &sbuf, false) != 0) {
3677                 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
3678                         usersharepath, strerror(errno) ));
3679                 return ret;
3680         }
3681
3682         /*
3683          * This directory must be owned by root, and have the 't' bit set.
3684          * It also must not be writable by "other".
3685          */
3686
3687 #ifdef S_ISVTX
3688         if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3689 #else
3690         if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3691 #endif
3692                 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
3693                         "or does not have the sticky bit 't' set or is writable by anyone.\n",
3694                         usersharepath ));
3695                 return ret;
3696         }
3697
3698         /* Ensure the template share exists if it's set. */
3699         if (Globals.usershare_template_share[0]) {
3700                 /* We can't use lp_servicenumber here as we are recommending that
3701                    template shares have -valid=false set. */
3702                 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3703                         if (ServicePtrs[snum_template]->szService &&
3704                                         strequal(ServicePtrs[snum_template]->szService,
3705                                                 Globals.usershare_template_share)) {
3706                                 break;
3707                         }
3708                 }
3709
3710                 if (snum_template == -1) {
3711                         DEBUG(0,("load_usershare_shares: usershare template share %s "
3712                                 "does not exist.\n",
3713                                 Globals.usershare_template_share ));
3714                         return ret;
3715                 }
3716         }
3717
3718         /* Mark all existing usershares as pending delete. */
3719         for (iService = iNumServices - 1; iService >= 0; iService--) {
3720                 if (VALID(iService) && ServicePtrs[iService]->usershare) {
3721                         ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
3722                 }
3723         }
3724
3725         dp = opendir(usersharepath);
3726         if (!dp) {
3727                 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
3728                         usersharepath, strerror(errno) ));
3729                 return ret;
3730         }
3731
3732         for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
3733                         (de = readdir(dp));
3734                         num_dir_entries++ ) {
3735                 int r;
3736                 const char *n = de->d_name;
3737
3738                 /* Ignore . and .. */
3739                 if (*n == '.') {
3740                         if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
3741                                 continue;
3742                         }
3743                 }
3744
3745                 if (n[0] == ':') {
3746                         /* Temporary file used when creating a share. */
3747                         num_tmp_dir_entries++;
3748                 }
3749
3750                 /* Allow 20% tmp entries. */
3751                 if (num_tmp_dir_entries > allowed_tmp_entries) {
3752                         DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
3753                                 "in directory %s\n",
3754                                 num_tmp_dir_entries, usersharepath));
3755                         break;
3756                 }
3757
3758                 r = process_usershare_file(usersharepath, n, snum_template);
3759                 if (r == 0) {
3760                         /* Update the services count. */
3761                         num_usershares++;
3762                         if (num_usershares >= max_user_shares) {
3763                                 DEBUG(0,("load_usershare_shares: max user shares reached "
3764                                         "on file %s in directory %s\n",
3765                                         n, usersharepath ));
3766                                 break;
3767                         }
3768                 } else if (r == -1) {
3769                         num_bad_dir_entries++;
3770                 }
3771
3772                 /* Allow 20% bad entries. */
3773                 if (num_bad_dir_entries > allowed_bad_entries) {
3774                         DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
3775                                 "in directory %s\n",
3776                                 num_bad_dir_entries, usersharepath));
3777                         break;
3778                 }
3779
3780                 /* Allow 20% bad entries. */
3781                 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
3782                         DEBUG(0,("load_usershare_shares: too many total entries (%u) "
3783                         "in directory %s\n",
3784                         num_dir_entries, usersharepath));
3785                         break;
3786                 }
3787         }
3788
3789         closedir(dp);
3790
3791         /* Sweep through and delete any non-refreshed usershares that are
3792            not currently in use. */
3793         tmp_ctx = talloc_stackframe();
3794         for (iService = iNumServices - 1; iService >= 0; iService--) {
3795                 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
3796                         const struct loadparm_substitution *lp_sub =
3797                                 loadparm_s3_global_substitution();
3798                         char *servname;
3799
3800                         if (snumused && snumused(sconn, iService)) {
3801                                 continue;
3802                         }
3803
3804                         servname = lp_servicename(tmp_ctx, lp_sub, iService);
3805
3806                         /* Remove from the share ACL db. */
3807                         DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
3808                                   servname ));
3809                         delete_share_security(servname);
3810                         free_service_byindex(iService);
3811                 }
3812         }
3813         talloc_free(tmp_ctx);
3814
3815         return lp_numservices();
3816 }
3817
3818 /********************************************************
3819  Destroy global resources allocated in this file
3820 ********************************************************/
3821
3822 void gfree_loadparm(void)
3823 {
3824         int i;
3825
3826         free_file_list();
3827
3828         /* Free resources allocated to services */
3829
3830         for ( i = 0; i < iNumServices; i++ ) {
3831                 if ( VALID(i) ) {
3832                         free_service_byindex(i);
3833                 }
3834         }
3835
3836         TALLOC_FREE( ServicePtrs );
3837         iNumServices = 0;
3838
3839         /* Now release all resources allocated to global
3840            parameters and the default service */
3841
3842         free_global_parameters();
3843 }
3844
3845
3846 /***************************************************************************
3847  Allow client apps to specify that they are a client
3848 ***************************************************************************/
3849 static void lp_set_in_client(bool b)
3850 {
3851     in_client = b;
3852 }
3853
3854
3855 /***************************************************************************
3856  Determine if we're running in a client app
3857 ***************************************************************************/
3858 static bool lp_is_in_client(void)
3859 {
3860     return in_client;
3861 }
3862
3863 static void lp_enforce_ad_dc_settings(void)
3864 {
3865         lp_do_parameter(GLOBAL_SECTION_SNUM, "passdb backend", "samba_dsdb");
3866         lp_do_parameter(GLOBAL_SECTION_SNUM,
3867                         "winbindd:use external pipes", "true");
3868         lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:default", "external");
3869         lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:svcctl", "embedded");
3870         lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:srvsvc", "embedded");
3871         lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:eventlog", "embedded");
3872         lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:ntsvcs", "embedded");
3873         lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:winreg", "embedded");
3874         lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:spoolss", "embedded");
3875         lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_daemon:spoolssd", "embedded");
3876         lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:tcpip", "no");
3877 }
3878
3879 /***************************************************************************
3880  Load the services array from the services file. Return true on success,
3881  false on failure.
3882 ***************************************************************************/
3883
3884 static bool lp_load_ex(const char *pszFname,
3885                        bool global_only,
3886                        bool save_defaults,
3887                        bool add_ipc,
3888                        bool reinit_globals,
3889                        bool allow_include_registry,
3890                        bool load_all_shares)
3891 {
3892         char *n2 = NULL;
3893         bool bRetval;
3894         TALLOC_CTX *frame = talloc_stackframe();
3895         struct loadparm_context *lp_ctx;
3896         int max_protocol, min_protocol;
3897
3898         DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
3899
3900         bInGlobalSection = true;
3901         bGlobalOnly = global_only;
3902         bAllowIncludeRegistry = allow_include_registry;
3903         sDefault = _sDefault;
3904
3905         lp_ctx = setup_lp_context(talloc_tos());
3906
3907         init_globals(lp_ctx, reinit_globals);
3908
3909         free_file_list();
3910
3911         if (save_defaults) {
3912                 init_locals();
3913                 lp_save_defaults();
3914         }
3915
3916         if (!reinit_globals) {
3917                 free_param_opts(&Globals.param_opt);
3918                 apply_lp_set_cmdline();
3919         }
3920
3921         lp_do_parameter(-1, "idmap config * : backend", Globals.idmap_backend);
3922
3923         /* We get sections first, so have to start 'behind' to make up */
3924         iServiceIndex = -1;
3925
3926         if (lp_config_backend_is_file()) {
3927                 n2 = talloc_sub_basic(talloc_tos(), get_current_username(),
3928                                         current_user_info.domain,
3929                                         pszFname);
3930                 if (!n2) {
3931                         smb_panic("lp_load_ex: out of memory");
3932                 }
3933
3934                 add_to_file_list(NULL, &file_lists, pszFname, n2);
3935
3936                 bRetval = pm_process(n2, lp_do_section, do_parameter, lp_ctx);
3937                 TALLOC_FREE(n2);
3938
3939                 /* finish up the last section */
3940                 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
3941                 if (bRetval) {
3942                         if (iServiceIndex >= 0) {
3943                                 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
3944                         }
3945                 }
3946
3947                 if (lp_config_backend_is_registry()) {
3948                         bool ok;
3949                         /* config backend changed to registry in config file */
3950                         /*
3951                          * We need to use this extra global variable here to
3952                          * survive restart: init_globals uses this as a default
3953                          * for config_backend. Otherwise, init_globals would
3954                          *  send us into an endless loop here.
3955                          */
3956
3957                         config_backend = CONFIG_BACKEND_REGISTRY;
3958                         /* start over */
3959                         DEBUG(1, ("lp_load_ex: changing to config backend "
3960                                   "registry\n"));
3961                         init_globals(lp_ctx, true);
3962
3963                         TALLOC_FREE(lp_ctx);
3964
3965                         lp_kill_all_services();
3966                         ok = lp_load_ex(pszFname, global_only, save_defaults,
3967                                         add_ipc, reinit_globals,
3968                                         allow_include_registry,
3969                                         load_all_shares);
3970                         TALLOC_FREE(frame);
3971                         return ok;
3972                 }
3973         } else if (lp_config_backend_is_registry()) {
3974                 bRetval = process_registry_globals();
3975         } else {
3976                 DEBUG(0, ("Illegal config  backend given: %d\n",
3977                           lp_config_backend()));
3978                 bRetval = false;
3979         }
3980
3981         if (bRetval && lp_registry_shares()) {
3982                 if (load_all_shares) {
3983                         bRetval = process_registry_shares();
3984                 } else {
3985                         bRetval = reload_registry_shares();
3986                 }
3987         }
3988
3989         {
3990                 const struct loadparm_substitution *lp_sub =
3991                         loadparm_s3_global_substitution();
3992                 char *serv = lp_auto_services(talloc_tos(), lp_sub);
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         const struct loadparm_substitution *lp_sub =
4289                 loadparm_s3_global_substitution();
4290         char *ret;
4291         const char *label = lp_volume(ctx, lp_sub, snum);
4292         size_t end = 32;
4293
4294         if (!*label) {
4295                 label = lp_servicename(ctx, lp_sub, snum);
4296         }
4297
4298         /*
4299          * Volume label can be a max of 32 bytes. Make sure to truncate
4300          * it at a codepoint boundary if it's longer than 32 and contains
4301          * multibyte characters. Windows insists on a volume label being
4302          * a valid mb sequence, and errors out if not.
4303          */
4304         if (strlen(label) > 32) {
4305                 /*
4306                  * A MB char can be a max of 5 bytes, thus
4307                  * we should have a valid mb character at a
4308                  * minimum position of (32-5) = 27.
4309                  */
4310                 while (end >= 27) {
4311                         /*
4312                          * Check if a codepoint starting from next byte
4313                          * is valid. If yes, then the current byte is the
4314                          * end of a MB or ascii sequence and the label can
4315                          * be safely truncated here. If not, keep going
4316                          * backwards till a valid codepoint is found.
4317                          */
4318                         size_t len = 0;
4319                         const char *s = &label[end];
4320                         codepoint_t c = next_codepoint(s, &len);
4321                         if (c != INVALID_CODEPOINT) {
4322                                 break;
4323                         }
4324                         end--;
4325                 }
4326         }
4327
4328         /* This returns a max of 33 byte guarenteed null terminated string. */
4329         ret = talloc_strndup(ctx, label, end);
4330         if (!ret) {
4331                 return "";
4332         }
4333         return ret;
4334 }
4335
4336 /*******************************************************************
4337  Get the default server type we will announce as via nmbd.
4338 ********************************************************************/
4339
4340 int lp_default_server_announce(void)
4341 {
4342         int default_server_announce = 0;
4343         default_server_announce |= SV_TYPE_WORKSTATION;
4344         default_server_announce |= SV_TYPE_SERVER;
4345         default_server_announce |= SV_TYPE_SERVER_UNIX;
4346
4347         /* note that the flag should be set only if we have a
4348            printer service but nmbd doesn't actually load the
4349            services so we can't tell   --jerry */
4350
4351         default_server_announce |= SV_TYPE_PRINTQ_SERVER;
4352
4353         default_server_announce |= SV_TYPE_SERVER_NT;
4354         default_server_announce |= SV_TYPE_NT;
4355
4356         switch (lp_server_role()) {
4357                 case ROLE_DOMAIN_MEMBER:
4358                         default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
4359                         break;
4360                 case ROLE_DOMAIN_PDC:
4361                         default_server_announce |= SV_TYPE_DOMAIN_CTRL;
4362                         break;
4363                 case ROLE_DOMAIN_BDC:
4364                         default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
4365                         break;
4366                 case ROLE_STANDALONE:
4367                 default:
4368                         break;
4369         }
4370         if (lp_time_server())
4371                 default_server_announce |= SV_TYPE_TIME_SOURCE;
4372
4373         if (lp_host_msdfs())
4374                 default_server_announce |= SV_TYPE_DFS_SERVER;
4375
4376         return default_server_announce;
4377 }
4378
4379 /***********************************************************
4380  If we are PDC then prefer us as DMB
4381 ************************************************************/
4382
4383 bool lp_domain_master(void)
4384 {
4385         if (Globals._domain_master == Auto)
4386                 return (lp_server_role() == ROLE_DOMAIN_PDC);
4387
4388         return (bool)Globals._domain_master;
4389 }
4390
4391 /***********************************************************
4392  If we are PDC then prefer us as DMB
4393 ************************************************************/
4394
4395 static bool lp_domain_master_true_or_auto(void)
4396 {
4397         if (Globals._domain_master) /* auto or yes */
4398                 return true;
4399
4400         return false;
4401 }
4402
4403 /***********************************************************
4404  If we are DMB then prefer us as LMB
4405 ************************************************************/
4406
4407 bool lp_preferred_master(void)
4408 {
4409         int preferred_master = lp__preferred_master();
4410
4411         if (preferred_master == Auto)
4412                 return (lp_local_master() && lp_domain_master());
4413
4414         return (bool)preferred_master;
4415 }
4416
4417 /*******************************************************************
4418  Remove a service.
4419 ********************************************************************/
4420
4421 void lp_remove_service(int snum)
4422 {
4423         ServicePtrs[snum]->valid = false;
4424 }
4425
4426 const char *lp_printername(TALLOC_CTX *ctx,
4427                            const struct loadparm_substitution *lp_sub,
4428                            int snum)
4429 {
4430         const char *ret = lp__printername(ctx, lp_sub, snum);
4431
4432         if (ret == NULL || *ret == '\0') {
4433                 ret = lp_const_servicename(snum);
4434         }
4435
4436         return ret;
4437 }
4438
4439
4440 /***********************************************************
4441  Allow daemons such as winbindd to fix their logfile name.
4442 ************************************************************/
4443
4444 void lp_set_logfile(const char *name)
4445 {
4446         lpcfg_string_set(Globals.ctx, &Globals.logfile, name);
4447         debug_set_logfile(name);
4448 }
4449
4450 /*******************************************************************
4451  Return the max print jobs per queue.
4452 ********************************************************************/
4453
4454 int lp_maxprintjobs(int snum)
4455 {
4456         int maxjobs = lp_max_print_jobs(snum);
4457
4458         if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
4459                 maxjobs = PRINT_MAX_JOBID - 1;
4460
4461         return maxjobs;
4462 }
4463
4464 const char *lp_printcapname(void)
4465 {
4466         const char *printcap_name = lp_printcap_name();
4467
4468         if ((printcap_name != NULL) &&
4469             (printcap_name[0] != '\0'))
4470                 return printcap_name;
4471
4472         if (sDefault.printing == PRINT_CUPS) {
4473                 return "cups";
4474         }
4475
4476         if (sDefault.printing == PRINT_BSD)
4477                 return "/etc/printcap";
4478
4479         return PRINTCAP_NAME;
4480 }
4481
4482 static uint32_t spoolss_state;
4483
4484 bool lp_disable_spoolss( void )
4485 {
4486         if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
4487                 spoolss_state = lp__disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4488
4489         return spoolss_state == SVCCTL_STOPPED ? true : false;
4490 }
4491
4492 void lp_set_spoolss_state( uint32_t state )
4493 {
4494         SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
4495
4496         spoolss_state = state;
4497 }
4498
4499 uint32_t lp_get_spoolss_state( void )
4500 {
4501         return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4502 }
4503
4504 /*******************************************************************
4505  Ensure we don't use sendfile if server smb signing is active.
4506 ********************************************************************/
4507
4508 bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state)
4509 {
4510         bool sign_active = false;
4511
4512         /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
4513         if (get_Protocol() < PROTOCOL_NT1) {
4514                 return false;
4515         }
4516         if (signing_state) {
4517                 sign_active = smb_signing_is_active(signing_state);
4518         }
4519         return (lp__use_sendfile(snum) &&
4520                         (get_remote_arch() != RA_WIN95) &&
4521                         !sign_active);
4522 }
4523
4524 /*******************************************************************
4525  Turn off sendfile if we find the underlying OS doesn't support it.
4526 ********************************************************************/
4527
4528 void set_use_sendfile(int snum, bool val)
4529 {
4530         if (LP_SNUM_OK(snum))
4531                 ServicePtrs[snum]->_use_sendfile = val;
4532         else
4533                 sDefault._use_sendfile = val;
4534 }
4535
4536 void lp_set_mangling_method(const char *new_method)
4537 {
4538         lpcfg_string_set(Globals.ctx, &Globals.mangling_method, new_method);
4539 }
4540
4541 /*******************************************************************
4542  Global state for POSIX pathname processing.
4543 ********************************************************************/
4544
4545 static bool posix_pathnames;
4546
4547 bool lp_posix_pathnames(void)
4548 {
4549         return posix_pathnames;
4550 }
4551
4552 /*******************************************************************
4553  Change everything needed to ensure POSIX pathname processing (currently
4554  not much).
4555 ********************************************************************/
4556
4557 void lp_set_posix_pathnames(void)
4558 {
4559         posix_pathnames = true;
4560 }
4561
4562 /*******************************************************************
4563  Global state for POSIX lock processing - CIFS unix extensions.
4564 ********************************************************************/
4565
4566 bool posix_default_lock_was_set;
4567 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
4568
4569 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
4570 {
4571         if (posix_default_lock_was_set) {
4572                 return posix_cifsx_locktype;
4573         } else {
4574                 return (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
4575                         POSIX_LOCK : WINDOWS_LOCK;
4576         }
4577 }
4578
4579 /*******************************************************************
4580 ********************************************************************/
4581
4582 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
4583 {
4584         posix_default_lock_was_set = true;
4585         posix_cifsx_locktype = val;
4586 }
4587
4588 int lp_min_receive_file_size(void)
4589 {
4590         int min_receivefile_size = lp_min_receivefile_size();
4591
4592         if (min_receivefile_size < 0) {
4593                 return 0;
4594         }
4595         return min_receivefile_size;
4596 }
4597
4598 /*******************************************************************
4599  Safe wide links checks.
4600  This helper function always verify the validity of wide links,
4601  even after a configuration file reload.
4602 ********************************************************************/
4603
4604 void widelinks_warning(int snum)
4605 {
4606         if (lp_allow_insecure_wide_links()) {
4607                 return;
4608         }
4609
4610         if (lp_unix_extensions() && lp_wide_links(snum)) {
4611                 DBG_ERR("Share '%s' has wide links and unix extensions enabled. "
4612                         "These parameters are incompatible. "
4613                         "Wide links will be disabled for this share.\n",
4614                          lp_const_servicename(snum));
4615         }
4616 }
4617
4618 bool lp_widelinks(int snum)
4619 {
4620         /* wide links is always incompatible with unix extensions */
4621         if (lp_unix_extensions()) {
4622                 /*
4623                  * Unless we have "allow insecure widelinks"
4624                  * turned on.
4625                  */
4626                 if (!lp_allow_insecure_wide_links()) {
4627                         return false;
4628                 }
4629         }
4630
4631         return lp_wide_links(snum);
4632 }
4633
4634 int lp_server_role(void)
4635 {
4636         return lp_find_server_role(lp__server_role(),
4637                                    lp__security(),
4638                                    lp__domain_logons(),
4639                                    lp_domain_master_true_or_auto());
4640 }
4641
4642 int lp_security(void)
4643 {
4644         return lp_find_security(lp__server_role(),
4645                                 lp__security());
4646 }
4647
4648 int lp_client_max_protocol(void)
4649 {
4650         int client_max_protocol = lp__client_max_protocol();
4651         if (client_max_protocol == PROTOCOL_DEFAULT) {
4652                 return PROTOCOL_LATEST;
4653         }
4654         return client_max_protocol;
4655 }
4656
4657 int lp_client_ipc_min_protocol(void)
4658 {
4659         int client_ipc_min_protocol = lp__client_ipc_min_protocol();
4660         if (client_ipc_min_protocol == PROTOCOL_DEFAULT) {
4661                 client_ipc_min_protocol = lp_client_min_protocol();
4662         }
4663         if (client_ipc_min_protocol < PROTOCOL_NT1) {
4664                 return PROTOCOL_NT1;
4665         }
4666         return client_ipc_min_protocol;
4667 }
4668
4669 int lp_client_ipc_max_protocol(void)
4670 {
4671         int client_ipc_max_protocol = lp__client_ipc_max_protocol();
4672         if (client_ipc_max_protocol == PROTOCOL_DEFAULT) {
4673                 return PROTOCOL_LATEST;
4674         }
4675         if (client_ipc_max_protocol < PROTOCOL_NT1) {
4676                 return PROTOCOL_NT1;
4677         }
4678         return client_ipc_max_protocol;
4679 }
4680
4681 int lp_client_ipc_signing(void)
4682 {
4683         int client_ipc_signing = lp__client_ipc_signing();
4684         if (client_ipc_signing == SMB_SIGNING_DEFAULT) {
4685                 return SMB_SIGNING_REQUIRED;
4686         }
4687         return client_ipc_signing;
4688 }
4689
4690 int lp_rpc_low_port(void)
4691 {
4692         return Globals.rpc_low_port;
4693 }
4694
4695 int lp_rpc_high_port(void)
4696 {
4697         return Globals.rpc_high_port;
4698 }
4699
4700 /*
4701  * Do not allow LanMan auth if unless NTLMv1 is also allowed
4702  *
4703  * This also ensures it is disabled if NTLM is totally disabled
4704  */
4705 bool lp_lanman_auth(void)
4706 {
4707         enum ntlm_auth_level ntlm_auth_level = lp_ntlm_auth();
4708
4709         if (ntlm_auth_level == NTLM_AUTH_ON) {
4710                 return lp__lanman_auth();
4711         } else {
4712                 return false;
4713         }
4714 }
4715
4716 struct loadparm_global * get_globals(void)
4717 {
4718         return &Globals;
4719 }
4720
4721 unsigned int * get_flags(void)
4722 {
4723         if (flags_list == NULL) {
4724                 flags_list = talloc_zero_array(NULL, unsigned int, num_parameters());
4725         }
4726
4727         return flags_list;
4728 }