source3/param/loadparm.c

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