source3/param/loadparm.c

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