source3/param/loadparm.c

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