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