source3/param/loadparm.c

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