source3/param/loadparm.c

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