source3/param/loadparm.c

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