source3/param/loadparm.c

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