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