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