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