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