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   set a option from the commandline in 'a=b' format. Use to support --option
2984 */
2985 bool lp_set_option(const char *option)
2986 {
2987         char *p, *s;
2988         bool ret;
2989
2990         s = talloc_strdup(NULL, option);
2991         if (!s) {
2992                 return false;
2993         }
2994
2995         p = strchr(s, '=');
2996         if (!p) {
2997                 talloc_free(s);
2998                 return false;
2999         }
3000
3001         *p = 0;
3002
3003         /* skip white spaces after the = sign */
3004         do {
3005                 p++;
3006         } while (*p == ' ');
3007
3008         ret = lp_set_cmdline(s, p);
3009         talloc_free(s);
3010         return ret;
3011 }
3012
3013 /***************************************************************************
3014  Initialize any local variables in the sDefault table, after parsing a
3015  [globals] section.
3016 ***************************************************************************/
3017
3018 static void init_locals(void)
3019 {
3020         /*
3021          * We run this check once the [globals] is parsed, to force
3022          * the VFS objects and other per-share settings we need for
3023          * the standard way a AD DC is operated.  We may change these
3024          * as our code evolves, which is why we force these settings.
3025          *
3026          * We can't do this at the end of lp_load_ex(), as by that
3027          * point the services have been loaded and they will already
3028          * have "" as their vfs objects.
3029          */
3030         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
3031                 const char **vfs_objects = lp_vfs_objects(-1);
3032                 if (!vfs_objects || !vfs_objects[0]) {
3033                         if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL)) {
3034                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
3035                         } else if (lp_parm_const_string(-1, "posix", "eadb", NULL)) {
3036                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
3037                         } else {
3038                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
3039                         }
3040                 }
3041
3042                 lp_do_parameter(-1, "map hidden", "no");
3043                 lp_do_parameter(-1, "map system", "no");
3044                 lp_do_parameter(-1, "map readonly", "no");
3045                 lp_do_parameter(-1, "map archive", "no");
3046                 lp_do_parameter(-1, "store dos attributes", "yes");
3047         }
3048 }
3049
3050 /***************************************************************************
3051  Process a new section (service). At this stage all sections are services.
3052  Later we'll have special sections that permit server parameters to be set.
3053  Returns true on success, false on failure.
3054 ***************************************************************************/
3055
3056 static bool do_section(const char *pszSectionName, void *userdata)
3057 {
3058         bool bRetval;
3059         bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
3060                          (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
3061         bRetval = false;
3062
3063         /* if we were in a global section then do the local inits */
3064         if (bInGlobalSection && !isglobal)
3065                 init_locals();
3066
3067         /* if we've just struck a global section, note the fact. */
3068         bInGlobalSection = isglobal;
3069
3070         /* check for multiple global sections */
3071         if (bInGlobalSection) {
3072                 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
3073                 return true;
3074         }
3075
3076         if (!bInGlobalSection && bGlobalOnly)
3077                 return true;
3078
3079         /* if we have a current service, tidy it up before moving on */
3080         bRetval = true;
3081
3082         if (iServiceIndex >= 0)
3083                 bRetval = service_ok(iServiceIndex);
3084
3085         /* if all is still well, move to the next record in the services array */
3086         if (bRetval) {
3087                 /* We put this here to avoid an odd message order if messages are */
3088                 /* issued by the post-processing of a previous section. */
3089                 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
3090
3091                 iServiceIndex = add_a_service(&sDefault, pszSectionName);
3092                 if (iServiceIndex < 0) {
3093                         DEBUG(0, ("Failed to add a new service\n"));
3094                         return false;
3095                 }
3096                 /* Clean all parametric options for service */
3097                 /* They will be added during parsing again */
3098                 free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
3099         }
3100
3101         return bRetval;
3102 }
3103
3104
3105 /***************************************************************************
3106  Determine if a partcular base parameter is currentl set to the default value.
3107 ***************************************************************************/
3108
3109 static bool is_default(int i)
3110 {
3111         switch (parm_table[i].type) {
3112                 case P_LIST:
3113                 case P_CMDLIST:
3114                         return str_list_equal((const char * const *)parm_table[i].def.lvalue,
3115                                               *(const char ***)lp_parm_ptr(NULL,
3116                                                                            &parm_table[i]));
3117                 case P_STRING:
3118                 case P_USTRING:
3119                         return strequal(parm_table[i].def.svalue,
3120                                         *(char **)lp_parm_ptr(NULL,
3121                                                               &parm_table[i]));
3122                 case P_BOOL:
3123                 case P_BOOLREV:
3124                         return parm_table[i].def.bvalue ==
3125                                 *(bool *)lp_parm_ptr(NULL,
3126                                                      &parm_table[i]);
3127                 case P_CHAR:
3128                         return parm_table[i].def.cvalue ==
3129                                 *(char *)lp_parm_ptr(NULL,
3130                                                      &parm_table[i]);
3131                 case P_INTEGER:
3132                 case P_OCTAL:
3133                 case P_ENUM:
3134                 case P_BYTES:
3135                         return parm_table[i].def.ivalue ==
3136                                 *(int *)lp_parm_ptr(NULL,
3137                                                     &parm_table[i]);
3138                 case P_SEP:
3139                         break;
3140         }
3141         return false;
3142 }
3143
3144 /***************************************************************************
3145 Display the contents of the global structure.
3146 ***************************************************************************/
3147
3148 static void dump_globals(FILE *f)
3149 {
3150         int i;
3151         struct parmlist_entry *data;
3152
3153         fprintf(f, "[global]\n");
3154
3155         for (i = 0; parm_table[i].label; i++)
3156                 if (parm_table[i].p_class == P_GLOBAL &&
3157                     !(parm_table[i].flags & FLAG_META) &&
3158                     (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset))) {
3159                         if (defaults_saved && is_default(i))
3160                                 continue;
3161                         fprintf(f, "\t%s = ", parm_table[i].label);
3162                         lpcfg_print_parameter(&parm_table[i], lp_parm_ptr(NULL,
3163                                                                           &parm_table[i]),
3164                                         f);
3165                         fprintf(f, "\n");
3166         }
3167         if (Globals.param_opt != NULL) {
3168                 data = Globals.param_opt;
3169                 while(data) {
3170                         fprintf(f, "\t%s = %s\n", data->key, data->value);
3171                         data = data->next;
3172                 }
3173         }
3174
3175 }
3176
3177 /***************************************************************************
3178  Display the contents of a single services record.
3179 ***************************************************************************/
3180
3181 static void dump_a_service(struct loadparm_service *pService, FILE * f)
3182 {
3183         int i;
3184         struct parmlist_entry *data;
3185
3186         if (pService != &sDefault)
3187                 fprintf(f, "[%s]\n", pService->szService);
3188
3189         for (i = 0; parm_table[i].label; i++) {
3190
3191                 if (parm_table[i].p_class == P_LOCAL &&
3192                     !(parm_table[i].flags & FLAG_META) &&
3193                     (*parm_table[i].label != '-') &&
3194                     (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset)))
3195                 {
3196                         if (pService == &sDefault) {
3197                                 if (defaults_saved && is_default(i))
3198                                         continue;
3199                         } else {
3200                                 if (lpcfg_equal_parameter(parm_table[i].type,
3201                                                           lp_parm_ptr(pService, &parm_table[i]),
3202                                                           lp_parm_ptr(NULL, &parm_table[i])))
3203                                         continue;
3204                         }
3205
3206                         fprintf(f, "\t%s = ", parm_table[i].label);
3207                         lpcfg_print_parameter(&parm_table[i],
3208                                         lp_parm_ptr(pService, &parm_table[i]),
3209                                         f);
3210                         fprintf(f, "\n");
3211                 }
3212         }
3213
3214                 if (pService->param_opt != NULL) {
3215                         data = pService->param_opt;
3216                         while(data) {
3217                                 fprintf(f, "\t%s = %s\n", data->key, data->value);
3218                                 data = data->next;
3219                         }
3220                 }
3221 }
3222
3223 /***************************************************************************
3224  Display the contents of a parameter of a single services record.
3225 ***************************************************************************/
3226
3227 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
3228 {
3229         bool result = false;
3230         fstring local_parm_name;
3231         char *parm_opt;
3232         const char *parm_opt_value;
3233
3234         struct loadparm_context *lp_ctx;
3235
3236         /* check for parametrical option */
3237         fstrcpy( local_parm_name, parm_name);
3238         parm_opt = strchr( local_parm_name, ':');
3239
3240         if (parm_opt) {
3241                 *parm_opt = '\0';
3242                 parm_opt++;
3243                 if (strlen(parm_opt)) {
3244                         parm_opt_value = lp_parm_const_string( snum,
3245                                 local_parm_name, parm_opt, NULL);
3246                         if (parm_opt_value) {
3247                                 printf( "%s\n", parm_opt_value);
3248                                 result = true;
3249                         }
3250                 }
3251                 return result;
3252         }
3253
3254         lp_ctx = loadparm_init_s3(talloc_tos(), loadparm_s3_helpers());
3255         if (lp_ctx == NULL) {
3256                 return false;
3257         }
3258
3259         if (isGlobal) {
3260                 result = lpcfg_dump_a_parameter(lp_ctx, NULL, parm_name, f);
3261         } else {
3262                 result = lpcfg_dump_a_parameter(lp_ctx, ServicePtrs[snum], parm_name, f);
3263         }
3264         TALLOC_FREE(lp_ctx);
3265         return result;
3266 }
3267
3268 /***************************************************************************
3269  Return info about the requested parameter (given as a string).
3270  Return NULL when the string is not a valid parameter name.
3271 ***************************************************************************/
3272
3273 struct parm_struct *lp_get_parameter(const char *param_name)
3274 {
3275         int num = lpcfg_map_parameter(param_name);
3276
3277         if (num < 0) {
3278                 return NULL;
3279         }
3280
3281         return &parm_table[num];
3282 }
3283
3284 #if 0
3285 /***************************************************************************
3286  Display the contents of a single copy structure.
3287 ***************************************************************************/
3288 static void dump_copy_map(bool *pcopymap)
3289 {
3290         int i;
3291         if (!pcopymap)
3292                 return;
3293
3294         printf("\n\tNon-Copied parameters:\n");
3295
3296         for (i = 0; parm_table[i].label; i++)
3297                 if (parm_table[i].p_class == P_LOCAL &&
3298                     parm_table[i].ptr && !pcopymap[i] &&
3299                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
3300                 {
3301                         printf("\t\t%s\n", parm_table[i].label);
3302                 }
3303 }
3304 #endif
3305
3306 /***************************************************************************
3307  Return TRUE if the passed service number is within range.
3308 ***************************************************************************/
3309
3310 bool lp_snum_ok(int iService)
3311 {
3312         return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
3313 }
3314
3315 /***************************************************************************
3316  Auto-load some home services.
3317 ***************************************************************************/
3318
3319 static void lp_add_auto_services(char *str)
3320 {
3321         char *s;
3322         char *p;
3323         int homes;
3324         char *saveptr;
3325
3326         if (!str)
3327                 return;
3328
3329         s = talloc_strdup(talloc_tos(), str);
3330         if (!s) {
3331                 smb_panic("talloc_strdup failed");
3332                 return;
3333         }
3334
3335         homes = lp_servicenumber(HOMES_NAME);
3336
3337         for (p = strtok_r(s, LIST_SEP, &saveptr); p;
3338              p = strtok_r(NULL, LIST_SEP, &saveptr)) {
3339                 char *home;
3340
3341                 if (lp_servicenumber(p) >= 0)
3342                         continue;
3343
3344                 home = get_user_home_dir(talloc_tos(), p);
3345
3346                 if (home && home[0] && homes >= 0)
3347                         lp_add_home(p, homes, p, home);
3348
3349                 TALLOC_FREE(home);
3350         }
3351         TALLOC_FREE(s);
3352 }
3353
3354 /***************************************************************************
3355  Auto-load one printer.
3356 ***************************************************************************/
3357
3358 void lp_add_one_printer(const char *name, const char *comment,
3359                         const char *location, void *pdata)
3360 {
3361         int printers = lp_servicenumber(PRINTERS_NAME);
3362         int i;
3363
3364         if (lp_servicenumber(name) < 0) {
3365                 lp_add_printer(name, printers);
3366                 if ((i = lp_servicenumber(name)) >= 0) {
3367                         string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
3368                         ServicePtrs[i]->autoloaded = true;
3369                 }
3370         }
3371 }
3372
3373 /***************************************************************************
3374  Have we loaded a services file yet?
3375 ***************************************************************************/
3376
3377 bool lp_loaded(void)
3378 {
3379         return (bLoaded);
3380 }
3381
3382 /***************************************************************************
3383  Unload unused services.
3384 ***************************************************************************/
3385
3386 void lp_killunused(struct smbd_server_connection *sconn,
3387                    bool (*snumused) (struct smbd_server_connection *, int))
3388 {
3389         int i;
3390         for (i = 0; i < iNumServices; i++) {
3391                 if (!VALID(i))
3392                         continue;
3393
3394                 /* don't kill autoloaded or usershare services */
3395                 if ( ServicePtrs[i]->autoloaded ||
3396                                 ServicePtrs[i]->usershare == USERSHARE_VALID) {
3397                         continue;
3398                 }
3399
3400                 if (!snumused || !snumused(sconn, i)) {
3401                         free_service_byindex(i);
3402                 }
3403         }
3404 }
3405
3406 /**
3407  * Kill all except autoloaded and usershare services - convenience wrapper
3408  */
3409 void lp_kill_all_services(void)
3410 {
3411         lp_killunused(NULL, NULL);
3412 }
3413
3414 /***************************************************************************
3415  Unload a service.
3416 ***************************************************************************/
3417
3418 void lp_killservice(int iServiceIn)
3419 {
3420         if (VALID(iServiceIn)) {
3421                 free_service_byindex(iServiceIn);
3422         }
3423 }
3424
3425 /***************************************************************************
3426  Save the curent values of all global and sDefault parameters into the
3427  defaults union. This allows testparm to show only the
3428  changed (ie. non-default) parameters.
3429 ***************************************************************************/
3430
3431 static void lp_save_defaults(void)
3432 {
3433         int i;
3434         for (i = 0; parm_table[i].label; i++) {
3435                 if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
3436                     && parm_table[i].p_class == parm_table[i - 1].p_class)
3437                         continue;
3438                 switch (parm_table[i].type) {
3439                         case P_LIST:
3440                         case P_CMDLIST:
3441                                 parm_table[i].def.lvalue = str_list_copy(
3442                                         NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
3443                                 break;
3444                         case P_STRING:
3445                         case P_USTRING:
3446                                 parm_table[i].def.svalue = talloc_strdup(Globals.ctx, *(char **)lp_parm_ptr(NULL, &parm_table[i]));
3447                                 if (parm_table[i].def.svalue == NULL) {
3448                                         smb_panic("talloc_strdup failed");
3449                                 }
3450                                 break;
3451                         case P_BOOL:
3452                         case P_BOOLREV:
3453                                 parm_table[i].def.bvalue =
3454                                         *(bool *)lp_parm_ptr(NULL, &parm_table[i]);
3455                                 break;
3456                         case P_CHAR:
3457                                 parm_table[i].def.cvalue =
3458                                         *(char *)lp_parm_ptr(NULL, &parm_table[i]);
3459                                 break;
3460                         case P_INTEGER:
3461                         case P_OCTAL:
3462                         case P_ENUM:
3463                         case P_BYTES:
3464                                 parm_table[i].def.ivalue =
3465                                         *(int *)lp_parm_ptr(NULL, &parm_table[i]);
3466                                 break;
3467                         case P_SEP:
3468                                 break;
3469                 }
3470         }
3471         defaults_saved = true;
3472 }
3473
3474 /***********************************************************
3475  If we should send plaintext/LANMAN passwords in the clinet
3476 ************************************************************/
3477
3478 static void set_allowed_client_auth(void)
3479 {
3480         if (Globals.client_ntlmv2_auth) {
3481                 Globals.client_lanman_auth = false;
3482         }
3483         if (!Globals.client_lanman_auth) {
3484                 Globals.client_plaintext_auth = false;
3485         }
3486 }
3487
3488 /***************************************************************************
3489  JRA.
3490  The following code allows smbd to read a user defined share file.
3491  Yes, this is my intent. Yes, I'm comfortable with that...
3492
3493  THE FOLLOWING IS SECURITY CRITICAL CODE.
3494
3495  It washes your clothes, it cleans your house, it guards you while you sleep...
3496  Do not f%^k with it....
3497 ***************************************************************************/
3498
3499 #define MAX_USERSHARE_FILE_SIZE (10*1024)
3500
3501 /***************************************************************************
3502  Check allowed stat state of a usershare file.
3503  Ensure we print out who is dicking with us so the admin can
3504  get their sorry ass fired.
3505 ***************************************************************************/
3506
3507 static bool check_usershare_stat(const char *fname,
3508                                  const SMB_STRUCT_STAT *psbuf)
3509 {
3510         if (!S_ISREG(psbuf->st_ex_mode)) {
3511                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3512                         "not a regular file\n",
3513                         fname, (unsigned int)psbuf->st_ex_uid ));
3514                 return false;
3515         }
3516
3517         /* Ensure this doesn't have the other write bit set. */
3518         if (psbuf->st_ex_mode & S_IWOTH) {
3519                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
3520                         "public write. Refusing to allow as a usershare file.\n",
3521                         fname, (unsigned int)psbuf->st_ex_uid ));
3522                 return false;
3523         }
3524
3525         /* Should be 10k or less. */
3526         if (psbuf->st_ex_size > MAX_USERSHARE_FILE_SIZE) {
3527                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3528                         "too large (%u) to be a user share file.\n",
3529                         fname, (unsigned int)psbuf->st_ex_uid,
3530                         (unsigned int)psbuf->st_ex_size ));
3531                 return false;
3532         }
3533
3534         return true;
3535 }
3536
3537 /***************************************************************************
3538  Parse the contents of a usershare file.
3539 ***************************************************************************/
3540
3541 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
3542                         SMB_STRUCT_STAT *psbuf,
3543                         const char *servicename,
3544                         int snum,
3545                         char **lines,
3546                         int numlines,
3547                         char **pp_sharepath,
3548                         char **pp_comment,
3549                         char **pp_cp_servicename,
3550                         struct security_descriptor **ppsd,
3551                         bool *pallow_guest)
3552 {
3553         const char **prefixallowlist = lp_usershare_prefix_allow_list();
3554         const char **prefixdenylist = lp_usershare_prefix_deny_list();
3555         int us_vers;
3556         DIR *dp;
3557         SMB_STRUCT_STAT sbuf;
3558         char *sharepath = NULL;
3559         char *comment = NULL;
3560
3561         *pp_sharepath = NULL;
3562         *pp_comment = NULL;
3563
3564         *pallow_guest = false;
3565
3566         if (numlines < 4) {
3567                 return USERSHARE_MALFORMED_FILE;
3568         }
3569
3570         if (strcmp(lines[0], "#VERSION 1") == 0) {
3571                 us_vers = 1;
3572         } else if (strcmp(lines[0], "#VERSION 2") == 0) {
3573                 us_vers = 2;
3574                 if (numlines < 5) {
3575                         return USERSHARE_MALFORMED_FILE;
3576                 }
3577         } else {
3578                 return USERSHARE_BAD_VERSION;
3579         }
3580
3581         if (strncmp(lines[1], "path=", 5) != 0) {
3582                 return USERSHARE_MALFORMED_PATH;
3583         }
3584
3585         sharepath = talloc_strdup(ctx, &lines[1][5]);
3586         if (!sharepath) {
3587                 return USERSHARE_POSIX_ERR;
3588         }
3589         trim_string(sharepath, " ", " ");
3590
3591         if (strncmp(lines[2], "comment=", 8) != 0) {
3592                 return USERSHARE_MALFORMED_COMMENT_DEF;
3593         }
3594
3595         comment = talloc_strdup(ctx, &lines[2][8]);
3596         if (!comment) {
3597                 return USERSHARE_POSIX_ERR;
3598         }
3599         trim_string(comment, " ", " ");
3600         trim_char(comment, '"', '"');
3601
3602         if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
3603                 return USERSHARE_MALFORMED_ACL_DEF;
3604         }
3605
3606         if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
3607                 return USERSHARE_ACL_ERR;
3608         }
3609
3610         if (us_vers == 2) {
3611                 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
3612                         return USERSHARE_MALFORMED_ACL_DEF;
3613                 }
3614                 if (lines[4][9] == 'y') {
3615                         *pallow_guest = true;
3616                 }
3617
3618                 /* Backwards compatible extension to file version #2. */
3619                 if (numlines > 5) {
3620                         if (strncmp(lines[5], "sharename=", 10) != 0) {
3621                                 return USERSHARE_MALFORMED_SHARENAME_DEF;
3622                         }
3623                         if (!strequal(&lines[5][10], servicename)) {
3624                                 return USERSHARE_BAD_SHARENAME;
3625                         }
3626                         *pp_cp_servicename = talloc_strdup(ctx, &lines[5][10]);
3627                         if (!*pp_cp_servicename) {
3628                                 return USERSHARE_POSIX_ERR;
3629                         }
3630                 }
3631         }
3632
3633         if (*pp_cp_servicename == NULL) {
3634                 *pp_cp_servicename = talloc_strdup(ctx, servicename);
3635                 if (!*pp_cp_servicename) {
3636                         return USERSHARE_POSIX_ERR;
3637                 }
3638         }
3639
3640         if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->path) == 0)) {
3641                 /* Path didn't change, no checks needed. */
3642                 *pp_sharepath = sharepath;
3643                 *pp_comment = comment;
3644                 return USERSHARE_OK;
3645         }
3646
3647         /* The path *must* be absolute. */
3648         if (sharepath[0] != '/') {
3649                 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
3650                         servicename, sharepath));
3651                 return USERSHARE_PATH_NOT_ABSOLUTE;
3652         }
3653
3654         /* If there is a usershare prefix deny list ensure one of these paths
3655            doesn't match the start of the user given path. */
3656         if (prefixdenylist) {
3657                 int i;
3658                 for ( i=0; prefixdenylist[i]; i++ ) {
3659                         DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
3660                                 servicename, i, prefixdenylist[i], sharepath ));
3661                         if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
3662                                 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
3663                                         "usershare prefix deny list entries.\n",
3664                                         servicename, sharepath));
3665                                 return USERSHARE_PATH_IS_DENIED;
3666                         }
3667                 }
3668         }
3669
3670         /* If there is a usershare prefix allow list ensure one of these paths
3671            does match the start of the user given path. */
3672
3673         if (prefixallowlist) {
3674                 int i;
3675                 for ( i=0; prefixallowlist[i]; i++ ) {
3676                         DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
3677                                 servicename, i, prefixallowlist[i], sharepath ));
3678                         if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
3679                                 break;
3680                         }
3681                 }
3682                 if (prefixallowlist[i] == NULL) {
3683                         DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
3684                                 "usershare prefix allow list entries.\n",
3685                                 servicename, sharepath));
3686                         return USERSHARE_PATH_NOT_ALLOWED;
3687                 }
3688         }
3689
3690         /* Ensure this is pointing to a directory. */
3691         dp = opendir(sharepath);
3692
3693         if (!dp) {
3694                 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3695                         servicename, sharepath));
3696                 return USERSHARE_PATH_NOT_DIRECTORY;
3697         }
3698
3699         /* Ensure the owner of the usershare file has permission to share
3700            this directory. */
3701
3702         if (sys_stat(sharepath, &sbuf, false) == -1) {
3703                 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
3704                         servicename, sharepath, strerror(errno) ));
3705                 closedir(dp);
3706                 return USERSHARE_POSIX_ERR;
3707         }
3708
3709         closedir(dp);
3710
3711         if (!S_ISDIR(sbuf.st_ex_mode)) {
3712                 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3713                         servicename, sharepath ));
3714                 return USERSHARE_PATH_NOT_DIRECTORY;
3715         }
3716
3717         /* Check if sharing is restricted to owner-only. */
3718         /* psbuf is the stat of the usershare definition file,
3719            sbuf is the stat of the target directory to be shared. */
3720
3721         if (lp_usershare_owner_only()) {
3722                 /* root can share anything. */
3723                 if ((psbuf->st_ex_uid != 0) && (sbuf.st_ex_uid != psbuf->st_ex_uid)) {
3724                         return USERSHARE_PATH_NOT_ALLOWED;
3725                 }
3726         }
3727
3728         *pp_sharepath = sharepath;
3729         *pp_comment = comment;
3730         return USERSHARE_OK;
3731 }
3732
3733 /***************************************************************************
3734  Deal with a usershare file.
3735  Returns:
3736         >= 0 - snum
3737         -1 - Bad name, invalid contents.
3738            - service name already existed and not a usershare, problem
3739             with permissions to share directory etc.
3740 ***************************************************************************/
3741
3742 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
3743 {
3744         SMB_STRUCT_STAT sbuf;
3745         SMB_STRUCT_STAT lsbuf;
3746         char *fname = NULL;
3747         char *sharepath = NULL;
3748         char *comment = NULL;
3749         char *cp_service_name = NULL;
3750         char **lines = NULL;
3751         int numlines = 0;
3752         int fd = -1;
3753         int iService = -1;
3754         TALLOC_CTX *ctx = talloc_stackframe();
3755         struct security_descriptor *psd = NULL;
3756         bool guest_ok = false;
3757         char *canon_name = NULL;
3758         bool added_service = false;
3759         int ret = -1;
3760
3761         /* Ensure share name doesn't contain invalid characters. */
3762         if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
3763                 DEBUG(0,("process_usershare_file: share name %s contains "
3764                         "invalid characters (any of %s)\n",
3765                         file_name, INVALID_SHARENAME_CHARS ));
3766                 goto out;
3767         }
3768
3769         canon_name = canonicalize_servicename(ctx, file_name);
3770         if (!canon_name) {
3771                 goto out;
3772         }
3773
3774         fname = talloc_asprintf(ctx, "%s/%s", dir_name, file_name);
3775         if (!fname) {
3776                 goto out;
3777         }
3778
3779         /* Minimize the race condition by doing an lstat before we
3780            open and fstat. Ensure this isn't a symlink link. */
3781
3782         if (sys_lstat(fname, &lsbuf, false) != 0) {
3783                 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
3784                         fname, strerror(errno) ));
3785                 goto out;
3786         }
3787
3788         /* This must be a regular file, not a symlink, directory or
3789            other strange filetype. */
3790         if (!check_usershare_stat(fname, &lsbuf)) {
3791                 goto out;
3792         }
3793
3794         {
3795                 TDB_DATA data;
3796                 NTSTATUS status;
3797
3798                 status = dbwrap_fetch_bystring(ServiceHash, canon_name,
3799                                                canon_name, &data);
3800
3801                 iService = -1;
3802
3803                 if (NT_STATUS_IS_OK(status) &&
3804                     (data.dptr != NULL) &&
3805                     (data.dsize == sizeof(iService))) {
3806                         memcpy(&iService, data.dptr, sizeof(iService));
3807                 }
3808         }
3809
3810         if (iService != -1 &&
3811             timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
3812                              &lsbuf.st_ex_mtime) == 0) {
3813                 /* Nothing changed - Mark valid and return. */
3814                 DEBUG(10,("process_usershare_file: service %s not changed.\n",
3815                         canon_name ));
3816                 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3817                 ret = iService;
3818                 goto out;
3819         }
3820
3821         /* Try and open the file read only - no symlinks allowed. */
3822 #ifdef O_NOFOLLOW
3823         fd = open(fname, O_RDONLY|O_NOFOLLOW, 0);
3824 #else
3825         fd = open(fname, O_RDONLY, 0);
3826 #endif
3827
3828         if (fd == -1) {
3829                 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
3830                         fname, strerror(errno) ));
3831                 goto out;
3832         }
3833
3834         /* Now fstat to be *SURE* it's a regular file. */
3835         if (sys_fstat(fd, &sbuf, false) != 0) {
3836                 close(fd);
3837                 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
3838                         fname, strerror(errno) ));
3839                 goto out;
3840         }
3841
3842         /* Is it the same dev/inode as was lstated ? */
3843         if (!check_same_stat(&lsbuf, &sbuf)) {
3844                 close(fd);
3845                 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
3846                         "Symlink spoofing going on ?\n", fname ));
3847                 goto out;
3848         }
3849
3850         /* This must be a regular file, not a symlink, directory or
3851            other strange filetype. */
3852         if (!check_usershare_stat(fname, &sbuf)) {
3853                 close(fd);
3854                 goto out;
3855         }
3856
3857         lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE, NULL);
3858
3859         close(fd);
3860         if (lines == NULL) {
3861                 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
3862                         fname, (unsigned int)sbuf.st_ex_uid ));
3863                 goto out;
3864         }
3865
3866         if (parse_usershare_file(ctx, &sbuf, file_name,
3867                         iService, lines, numlines, &sharepath,
3868                         &comment, &cp_service_name,
3869                         &psd, &guest_ok) != USERSHARE_OK) {
3870                 goto out;
3871         }
3872
3873         /* Everything ok - add the service possibly using a template. */
3874         if (iService < 0) {
3875                 const struct loadparm_service *sp = &sDefault;
3876                 if (snum_template != -1) {
3877                         sp = ServicePtrs[snum_template];
3878                 }
3879
3880                 if ((iService = add_a_service(sp, cp_service_name)) < 0) {
3881                         DEBUG(0, ("process_usershare_file: Failed to add "
3882                                 "new service %s\n", cp_service_name));
3883                         goto out;
3884                 }
3885
3886                 added_service = true;
3887
3888                 /* Read only is controlled by usershare ACL below. */
3889                 ServicePtrs[iService]->read_only = false;
3890         }
3891
3892         /* Write the ACL of the new/modified share. */
3893         if (!set_share_security(canon_name, psd)) {
3894                  DEBUG(0, ("process_usershare_file: Failed to set share "
3895                         "security for user share %s\n",
3896                         canon_name ));
3897                 goto out;
3898         }
3899
3900         /* If from a template it may be marked invalid. */
3901         ServicePtrs[iService]->valid = true;
3902
3903         /* Set the service as a valid usershare. */
3904         ServicePtrs[iService]->usershare = USERSHARE_VALID;
3905
3906         /* Set guest access. */
3907         if (lp_usershare_allow_guests()) {
3908                 ServicePtrs[iService]->guest_ok = guest_ok;
3909         }
3910
3911         /* And note when it was loaded. */
3912         ServicePtrs[iService]->usershare_last_mod = sbuf.st_ex_mtime;
3913         string_set(ServicePtrs[iService], &ServicePtrs[iService]->path, sharepath);
3914         string_set(ServicePtrs[iService], &ServicePtrs[iService]->comment, comment);
3915
3916         ret = iService;
3917
3918   out:
3919
3920         if (ret == -1 && iService != -1 && added_service) {
3921                 lp_remove_service(iService);
3922         }
3923
3924         TALLOC_FREE(lines);
3925         TALLOC_FREE(ctx);
3926         return ret;
3927 }
3928
3929 /***************************************************************************
3930  Checks if a usershare entry has been modified since last load.
3931 ***************************************************************************/
3932
3933 static bool usershare_exists(int iService, struct timespec *last_mod)
3934 {
3935         SMB_STRUCT_STAT lsbuf;
3936         const char *usersharepath = Globals.usershare_path;
3937         char *fname;
3938
3939         fname = talloc_asprintf(talloc_tos(),
3940                                 "%s/%s",
3941                                 usersharepath,
3942                                 ServicePtrs[iService]->szService);
3943         if (fname == NULL) {
3944                 return false;
3945         }
3946
3947         if (sys_lstat(fname, &lsbuf, false) != 0) {
3948                 TALLOC_FREE(fname);
3949                 return false;
3950         }
3951
3952         if (!S_ISREG(lsbuf.st_ex_mode)) {
3953                 TALLOC_FREE(fname);
3954                 return false;
3955         }
3956
3957         TALLOC_FREE(fname);
3958         *last_mod = lsbuf.st_ex_mtime;
3959         return true;
3960 }
3961
3962 /***************************************************************************
3963  Load a usershare service by name. Returns a valid servicenumber or -1.
3964 ***************************************************************************/
3965
3966 int load_usershare_service(const char *servicename)
3967 {
3968         SMB_STRUCT_STAT sbuf;
3969         const char *usersharepath = Globals.usershare_path;
3970         int max_user_shares = Globals.usershare_max_shares;
3971         int snum_template = -1;
3972
3973         if (*usersharepath == 0 ||  max_user_shares == 0) {
3974                 return -1;
3975         }
3976
3977         if (sys_stat(usersharepath, &sbuf, false) != 0) {
3978                 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
3979                         usersharepath, strerror(errno) ));
3980                 return -1;
3981         }
3982
3983         if (!S_ISDIR(sbuf.st_ex_mode)) {
3984                 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
3985                         usersharepath ));
3986                 return -1;
3987         }
3988
3989         /*
3990          * This directory must be owned by root, and have the 't' bit set.
3991          * It also must not be writable by "other".
3992          */
3993
3994 #ifdef S_ISVTX
3995         if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3996 #else
3997         if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3998 #endif
3999                 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
4000                         "or does not have the sticky bit 't' set or is writable by anyone.\n",
4001                         usersharepath ));
4002                 return -1;
4003         }
4004
4005         /* Ensure the template share exists if it's set. */
4006         if (Globals.usershare_template_share[0]) {
4007                 /* We can't use lp_servicenumber here as we are recommending that
4008                    template shares have -valid=false set. */
4009                 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
4010                         if (ServicePtrs[snum_template]->szService &&
4011                                         strequal(ServicePtrs[snum_template]->szService,
4012                                                 Globals.usershare_template_share)) {
4013                                 break;
4014                         }
4015                 }
4016
4017                 if (snum_template == -1) {
4018                         DEBUG(0,("load_usershare_service: usershare template share %s "
4019                                 "does not exist.\n",
4020                                 Globals.usershare_template_share ));
4021                         return -1;
4022                 }
4023         }
4024
4025         return process_usershare_file(usersharepath, servicename, snum_template);
4026 }
4027
4028 /***************************************************************************
4029  Load all user defined shares from the user share directory.
4030  We only do this if we're enumerating the share list.
4031  This is the function that can delete usershares that have
4032  been removed.
4033 ***************************************************************************/
4034
4035 int load_usershare_shares(struct smbd_server_connection *sconn,
4036                           bool (*snumused) (struct smbd_server_connection *, int))
4037 {
4038         DIR *dp;
4039         SMB_STRUCT_STAT sbuf;
4040         struct dirent *de;
4041         int num_usershares = 0;
4042         int max_user_shares = Globals.usershare_max_shares;
4043         unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
4044         unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
4045         unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
4046         int iService;
4047         int snum_template = -1;
4048         const char *usersharepath = Globals.usershare_path;
4049         int ret = lp_numservices();
4050         TALLOC_CTX *tmp_ctx;
4051
4052         if (max_user_shares == 0 || *usersharepath == '\0') {
4053                 return lp_numservices();
4054         }
4055
4056         if (sys_stat(usersharepath, &sbuf, false) != 0) {
4057                 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
4058                         usersharepath, strerror(errno) ));
4059                 return ret;
4060         }
4061
4062         /*
4063          * This directory must be owned by root, and have the 't' bit set.
4064          * It also must not be writable by "other".
4065          */
4066
4067 #ifdef S_ISVTX
4068         if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
4069 #else
4070         if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
4071 #endif
4072                 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
4073                         "or does not have the sticky bit 't' set or is writable by anyone.\n",
4074                         usersharepath ));
4075                 return ret;
4076         }
4077
4078         /* Ensure the template share exists if it's set. */
4079         if (Globals.usershare_template_share[0]) {
4080                 /* We can't use lp_servicenumber here as we are recommending that
4081                    template shares have -valid=false set. */
4082                 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
4083                         if (ServicePtrs[snum_template]->szService &&
4084                                         strequal(ServicePtrs[snum_template]->szService,
4085                                                 Globals.usershare_template_share)) {
4086                                 break;
4087                         }
4088                 }
4089
4090                 if (snum_template == -1) {
4091                         DEBUG(0,("load_usershare_shares: usershare template share %s "
4092                                 "does not exist.\n",
4093                                 Globals.usershare_template_share ));
4094                         return ret;
4095                 }
4096         }
4097
4098         /* Mark all existing usershares as pending delete. */
4099         for (iService = iNumServices - 1; iService >= 0; iService--) {
4100                 if (VALID(iService) && ServicePtrs[iService]->usershare) {
4101                         ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
4102                 }
4103         }
4104
4105         dp = opendir(usersharepath);
4106         if (!dp) {
4107                 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
4108                         usersharepath, strerror(errno) ));
4109                 return ret;
4110         }
4111
4112         for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
4113                         (de = readdir(dp));
4114                         num_dir_entries++ ) {
4115                 int r;
4116                 const char *n = de->d_name;
4117
4118                 /* Ignore . and .. */
4119                 if (*n == '.') {
4120                         if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
4121                                 continue;
4122                         }
4123                 }
4124
4125                 if (n[0] == ':') {
4126                         /* Temporary file used when creating a share. */
4127                         num_tmp_dir_entries++;
4128                 }
4129
4130                 /* Allow 20% tmp entries. */
4131                 if (num_tmp_dir_entries > allowed_tmp_entries) {
4132                         DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
4133                                 "in directory %s\n",
4134                                 num_tmp_dir_entries, usersharepath));
4135                         break;
4136                 }
4137
4138                 r = process_usershare_file(usersharepath, n, snum_template);
4139                 if (r == 0) {
4140                         /* Update the services count. */
4141                         num_usershares++;
4142                         if (num_usershares >= max_user_shares) {
4143                                 DEBUG(0,("load_usershare_shares: max user shares reached "
4144                                         "on file %s in directory %s\n",
4145                                         n, usersharepath ));
4146                                 break;
4147                         }
4148                 } else if (r == -1) {
4149                         num_bad_dir_entries++;
4150                 }
4151
4152                 /* Allow 20% bad entries. */
4153                 if (num_bad_dir_entries > allowed_bad_entries) {
4154                         DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
4155                                 "in directory %s\n",
4156                                 num_bad_dir_entries, usersharepath));
4157                         break;
4158                 }
4159
4160                 /* Allow 20% bad entries. */
4161                 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
4162                         DEBUG(0,("load_usershare_shares: too many total entries (%u) "
4163                         "in directory %s\n",
4164                         num_dir_entries, usersharepath));
4165                         break;
4166                 }
4167         }
4168
4169         closedir(dp);
4170
4171         /* Sweep through and delete any non-refreshed usershares that are
4172            not currently in use. */
4173         tmp_ctx = talloc_stackframe();
4174         for (iService = iNumServices - 1; iService >= 0; iService--) {
4175                 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
4176                         char *servname;
4177
4178                         if (snumused && snumused(sconn, iService)) {
4179                                 continue;
4180                         }
4181
4182                         servname = lp_servicename(tmp_ctx, iService);
4183
4184                         /* Remove from the share ACL db. */
4185                         DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
4186                                   servname ));
4187                         delete_share_security(servname);
4188                         free_service_byindex(iService);
4189                 }
4190         }
4191         talloc_free(tmp_ctx);
4192
4193         return lp_numservices();
4194 }
4195
4196 /********************************************************
4197  Destroy global resources allocated in this file
4198 ********************************************************/
4199
4200 void gfree_loadparm(void)
4201 {
4202         int i;
4203
4204         free_file_list();
4205
4206         /* Free resources allocated to services */
4207
4208         for ( i = 0; i < iNumServices; i++ ) {
4209                 if ( VALID(i) ) {
4210                         free_service_byindex(i);
4211                 }
4212         }
4213
4214         TALLOC_FREE( ServicePtrs );
4215         iNumServices = 0;
4216
4217         /* Now release all resources allocated to global
4218            parameters and the default service */
4219
4220         free_global_parameters();
4221 }
4222
4223
4224 /***************************************************************************
4225  Allow client apps to specify that they are a client
4226 ***************************************************************************/
4227 static void lp_set_in_client(bool b)
4228 {
4229     in_client = b;
4230 }
4231
4232
4233 /***************************************************************************
4234  Determine if we're running in a client app
4235 ***************************************************************************/
4236 static bool lp_is_in_client(void)
4237 {
4238     return in_client;
4239 }
4240
4241 /***************************************************************************
4242  Load the services array from the services file. Return true on success,
4243  false on failure.
4244 ***************************************************************************/
4245
4246 static bool lp_load_ex(const char *pszFname,
4247                        bool global_only,
4248                        bool save_defaults,
4249                        bool add_ipc,
4250                        bool initialize_globals,
4251                        bool allow_include_registry,
4252                        bool load_all_shares)
4253 {
4254         char *n2 = NULL;
4255         bool bRetval;
4256
4257         bRetval = false;
4258
4259         DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
4260
4261         bInGlobalSection = true;
4262         bGlobalOnly = global_only;
4263         bAllowIncludeRegistry = allow_include_registry;
4264
4265         init_globals(initialize_globals);
4266
4267         free_file_list();
4268
4269         if (save_defaults) {
4270                 init_locals();
4271                 lp_save_defaults();
4272         }
4273
4274         if (!initialize_globals) {
4275                 free_param_opts(&Globals.param_opt);
4276                 apply_lp_set_cmdline();
4277         }
4278
4279         lp_do_parameter(-1, "idmap config * : backend", Globals.szIdmapBackend);
4280
4281         /* We get sections first, so have to start 'behind' to make up */
4282         iServiceIndex = -1;
4283
4284         if (lp_config_backend_is_file()) {
4285                 n2 = talloc_sub_basic(talloc_tos(), get_current_username(),
4286                                         current_user_info.domain,
4287                                         pszFname);
4288                 if (!n2) {
4289                         smb_panic("lp_load_ex: out of memory");
4290                 }
4291
4292                 add_to_file_list(NULL, &file_lists, pszFname, n2);
4293
4294                 bRetval = pm_process(n2, do_section, do_parameter, NULL);
4295                 TALLOC_FREE(n2);
4296
4297                 /* finish up the last section */
4298                 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
4299                 if (bRetval) {
4300                         if (iServiceIndex >= 0) {
4301                                 bRetval = service_ok(iServiceIndex);
4302                         }
4303                 }
4304
4305                 if (lp_config_backend_is_registry()) {
4306                         /* config backend changed to registry in config file */
4307                         /*
4308                          * We need to use this extra global variable here to
4309                          * survive restart: init_globals uses this as a default
4310                          * for config_backend. Otherwise, init_globals would
4311                          *  send us into an endless loop here.
4312                          */
4313                         config_backend = CONFIG_BACKEND_REGISTRY;
4314                         /* start over */
4315                         DEBUG(1, ("lp_load_ex: changing to config backend "
4316                                   "registry\n"));
4317                         init_globals(true);
4318                         lp_kill_all_services();
4319                         return lp_load_ex(pszFname, global_only, save_defaults,
4320                                           add_ipc, initialize_globals,
4321                                           allow_include_registry,
4322                                           load_all_shares);
4323                 }
4324         } else if (lp_config_backend_is_registry()) {
4325                 bRetval = process_registry_globals();
4326         } else {
4327                 DEBUG(0, ("Illegal config  backend given: %d\n",
4328                           lp_config_backend()));
4329                 bRetval = false;
4330         }
4331
4332         if (bRetval && lp_registry_shares()) {
4333                 if (load_all_shares) {
4334                         bRetval = process_registry_shares();
4335                 } else {
4336                         bRetval = reload_registry_shares();
4337                 }
4338         }
4339
4340         {
4341                 char *serv = lp_auto_services(talloc_tos());
4342                 lp_add_auto_services(serv);
4343                 TALLOC_FREE(serv);
4344         }
4345
4346         if (add_ipc) {
4347                 /* When 'restrict anonymous = 2' guest connections to ipc$
4348                    are denied */
4349                 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
4350                 if ( lp_enable_asu_support() ) {
4351                         lp_add_ipc("ADMIN$", false);
4352                 }
4353         }
4354
4355         set_allowed_client_auth();
4356
4357         if (lp_security() == SEC_ADS && strchr(lp_password_server(), ':')) {
4358                 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
4359                           lp_password_server()));
4360         }
4361
4362         bLoaded = true;
4363
4364         /* Now we check we_are_a_wins_server and set szWINSserver to 127.0.0.1 */
4365         /* if we_are_a_wins_server is true and we are in the client            */
4366         if (lp_is_in_client() && Globals.we_are_a_wins_server) {
4367                 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
4368         }
4369
4370         init_iconv();
4371
4372         fault_configure(smb_panic_s3);
4373
4374         /*
4375          * We run this check once the whole smb.conf is parsed, to
4376          * force some settings for the standard way a AD DC is
4377          * operated.  We may changed these as our code evolves, which
4378          * is why we force these settings.
4379          */
4380         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
4381                 lp_do_parameter(-1, "passdb backend", "samba_dsdb");
4382
4383                 lp_do_parameter(-1, "rpc_server:default", "external");
4384                 lp_do_parameter(-1, "rpc_server:svcctl", "embedded");
4385                 lp_do_parameter(-1, "rpc_server:srvsvc", "embedded");
4386                 lp_do_parameter(-1, "rpc_server:eventlog", "embedded");
4387                 lp_do_parameter(-1, "rpc_server:ntsvcs", "embedded");
4388                 lp_do_parameter(-1, "rpc_server:winreg", "embedded");
4389                 lp_do_parameter(-1, "rpc_server:spoolss", "embedded");
4390                 lp_do_parameter(-1, "rpc_daemon:spoolssd", "embedded");
4391                 lp_do_parameter(-1, "rpc_server:tcpip", "no");
4392         }
4393
4394         bAllowIncludeRegistry = true;
4395
4396         return (bRetval);
4397 }
4398
4399 bool lp_load(const char *pszFname,
4400              bool global_only,
4401              bool save_defaults,
4402              bool add_ipc,
4403              bool initialize_globals)
4404 {
4405         return lp_load_ex(pszFname,
4406                           global_only,
4407                           save_defaults,
4408                           add_ipc,
4409                           initialize_globals,
4410                           true,   /* allow_include_registry */
4411                           false); /* load_all_shares*/
4412 }
4413
4414 bool lp_load_initial_only(const char *pszFname)
4415 {
4416         return lp_load_ex(pszFname,
4417                           true,   /* global only */
4418                           false,  /* save_defaults */
4419                           false,  /* add_ipc */
4420                           true,   /* initialize_globals */
4421                           false,  /* allow_include_registry */
4422                           false); /* load_all_shares*/
4423 }
4424
4425 /**
4426  * most common lp_load wrapper, loading only the globals
4427  */
4428 bool lp_load_global(const char *file_name)
4429 {
4430         return lp_load_ex(file_name,
4431                           true,   /* global_only */
4432                           false,  /* save_defaults */
4433                           false,  /* add_ipc */
4434                           true,   /* initialize_globals */
4435                           true,   /* allow_include_registry */
4436                           false); /* load_all_shares*/
4437 }
4438
4439 /**
4440  * lp_load wrapper, especially for clients
4441  */
4442 bool lp_load_client(const char *file_name)
4443 {
4444         lp_set_in_client(true);
4445
4446         return lp_load_global(file_name);
4447 }
4448
4449 /**
4450  * lp_load wrapper, loading only globals, but intended
4451  * for subsequent calls, not reinitializing the globals
4452  * to default values
4453  */
4454 bool lp_load_global_no_reinit(const char *file_name)
4455 {
4456         return lp_load_ex(file_name,
4457                           true,   /* global_only */
4458                           false,  /* save_defaults */
4459                           false,  /* add_ipc */
4460                           false,  /* initialize_globals */
4461                           true,   /* allow_include_registry */
4462                           false); /* load_all_shares*/
4463 }
4464
4465 /**
4466  * lp_load wrapper, especially for clients, no reinitialization
4467  */
4468 bool lp_load_client_no_reinit(const char *file_name)
4469 {
4470         lp_set_in_client(true);
4471
4472         return lp_load_global_no_reinit(file_name);
4473 }
4474
4475 bool lp_load_with_registry_shares(const char *pszFname,
4476                                   bool global_only,
4477                                   bool save_defaults,
4478                                   bool add_ipc,
4479                                   bool initialize_globals)
4480 {
4481         return lp_load_ex(pszFname,
4482                           global_only,
4483                           save_defaults,
4484                           add_ipc,
4485                           initialize_globals,
4486                           true,  /* allow_include_registry */
4487                           true); /* load_all_shares*/
4488 }
4489
4490 /***************************************************************************
4491  Return the max number of services.
4492 ***************************************************************************/
4493
4494 int lp_numservices(void)
4495 {
4496         return (iNumServices);
4497 }
4498
4499 /***************************************************************************
4500 Display the contents of the services array in human-readable form.
4501 ***************************************************************************/
4502
4503 void lp_dump(FILE *f, bool show_defaults, int maxtoprint)
4504 {
4505         int iService;
4506
4507         if (show_defaults)
4508                 defaults_saved = false;
4509
4510         dump_globals(f);
4511
4512         dump_a_service(&sDefault, f);
4513
4514         for (iService = 0; iService < maxtoprint; iService++) {
4515                 fprintf(f,"\n");
4516                 lp_dump_one(f, show_defaults, iService);
4517         }
4518 }
4519
4520 /***************************************************************************
4521 Display the contents of one service in human-readable form.
4522 ***************************************************************************/
4523
4524 void lp_dump_one(FILE * f, bool show_defaults, int snum)
4525 {
4526         if (VALID(snum)) {
4527                 if (ServicePtrs[snum]->szService[0] == '\0')
4528                         return;
4529                 dump_a_service(ServicePtrs[snum], f);
4530         }
4531 }
4532
4533 /***************************************************************************
4534 Return the number of the service with the given name, or -1 if it doesn't
4535 exist. Note that this is a DIFFERENT ANIMAL from the internal function
4536 getservicebyname()! This works ONLY if all services have been loaded, and
4537 does not copy the found service.
4538 ***************************************************************************/
4539
4540 int lp_servicenumber(const char *pszServiceName)
4541 {
4542         int iService;
4543         fstring serviceName;
4544
4545         if (!pszServiceName) {
4546                 return GLOBAL_SECTION_SNUM;
4547         }
4548
4549         for (iService = iNumServices - 1; iService >= 0; iService--) {
4550                 if (VALID(iService) && ServicePtrs[iService]->szService) {
4551                         /*
4552                          * The substitution here is used to support %U is
4553                          * service names
4554                          */
4555                         fstrcpy(serviceName, ServicePtrs[iService]->szService);
4556                         standard_sub_basic(get_current_username(),
4557                                            current_user_info.domain,
4558                                            serviceName,sizeof(serviceName));
4559                         if (strequal(serviceName, pszServiceName)) {
4560                                 break;
4561                         }
4562                 }
4563         }
4564
4565         if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
4566                 struct timespec last_mod;
4567
4568                 if (!usershare_exists(iService, &last_mod)) {
4569                         /* Remove the share security tdb entry for it. */
4570                         delete_share_security(lp_servicename(talloc_tos(), iService));
4571                         /* Remove it from the array. */
4572                         free_service_byindex(iService);
4573                         /* Doesn't exist anymore. */
4574                         return GLOBAL_SECTION_SNUM;
4575                 }
4576
4577                 /* Has it been modified ? If so delete and reload. */
4578                 if (timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
4579                                      &last_mod) < 0) {
4580                         /* Remove it from the array. */
4581                         free_service_byindex(iService);
4582                         /* and now reload it. */
4583                         iService = load_usershare_service(pszServiceName);
4584                 }
4585         }
4586
4587         if (iService < 0) {
4588                 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
4589                 return GLOBAL_SECTION_SNUM;
4590         }
4591
4592         return (iService);
4593 }
4594
4595 /*******************************************************************
4596  A useful volume label function.
4597 ********************************************************************/
4598
4599 const char *volume_label(TALLOC_CTX *ctx, int snum)
4600 {
4601         char *ret;
4602         const char *label = lp_volume(ctx, snum);
4603         if (!*label) {
4604                 label = lp_servicename(ctx, snum);
4605         }
4606
4607         /* This returns a 33 byte guarenteed null terminated string. */
4608         ret = talloc_strndup(ctx, label, 32);
4609         if (!ret) {
4610                 return "";
4611         }
4612         return ret;
4613 }
4614
4615 /*******************************************************************
4616  Get the default server type we will announce as via nmbd.
4617 ********************************************************************/
4618
4619 int lp_default_server_announce(void)
4620 {
4621         int default_server_announce = 0;
4622         default_server_announce |= SV_TYPE_WORKSTATION;
4623         default_server_announce |= SV_TYPE_SERVER;
4624         default_server_announce |= SV_TYPE_SERVER_UNIX;
4625
4626         /* note that the flag should be set only if we have a
4627            printer service but nmbd doesn't actually load the
4628            services so we can't tell   --jerry */
4629
4630         default_server_announce |= SV_TYPE_PRINTQ_SERVER;
4631
4632         default_server_announce |= SV_TYPE_SERVER_NT;
4633         default_server_announce |= SV_TYPE_NT;
4634
4635         switch (lp_server_role()) {
4636                 case ROLE_DOMAIN_MEMBER:
4637                         default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
4638                         break;
4639                 case ROLE_DOMAIN_PDC:
4640                         default_server_announce |= SV_TYPE_DOMAIN_CTRL;
4641                         break;
4642                 case ROLE_DOMAIN_BDC:
4643                         default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
4644                         break;
4645                 case ROLE_STANDALONE:
4646                 default:
4647                         break;
4648         }
4649         if (lp_time_server())
4650                 default_server_announce |= SV_TYPE_TIME_SOURCE;
4651
4652         if (lp_host_msdfs())
4653                 default_server_announce |= SV_TYPE_DFS_SERVER;
4654
4655         return default_server_announce;
4656 }
4657
4658 /***********************************************************
4659  If we are PDC then prefer us as DMB
4660 ************************************************************/
4661
4662 bool lp_domain_master(void)
4663 {
4664         if (Globals._domain_master == Auto)
4665                 return (lp_server_role() == ROLE_DOMAIN_PDC);
4666
4667         return (bool)Globals._domain_master;
4668 }
4669
4670 /***********************************************************
4671  If we are PDC then prefer us as DMB
4672 ************************************************************/
4673
4674 static bool lp_domain_master_true_or_auto(void)
4675 {
4676         if (Globals._domain_master) /* auto or yes */
4677                 return true;
4678
4679         return false;
4680 }
4681
4682 /***********************************************************
4683  If we are DMB then prefer us as LMB
4684 ************************************************************/
4685
4686 bool lp_preferred_master(void)
4687 {
4688         if (Globals.iPreferredMaster == Auto)
4689                 return (lp_local_master() && lp_domain_master());
4690
4691         return (bool)Globals.iPreferredMaster;
4692 }
4693
4694 /*******************************************************************
4695  Remove a service.
4696 ********************************************************************/
4697
4698 void lp_remove_service(int snum)
4699 {
4700         ServicePtrs[snum]->valid = false;
4701 }
4702
4703 const char *lp_printername(TALLOC_CTX *ctx, int snum)
4704 {
4705         const char *ret = lp__printername(ctx, snum);
4706         if (ret == NULL || *ret == '\0') {
4707                 ret = lp_const_servicename(snum);
4708         }
4709
4710         return ret;
4711 }
4712
4713
4714 /***********************************************************
4715  Allow daemons such as winbindd to fix their logfile name.
4716 ************************************************************/
4717
4718 void lp_set_logfile(const char *name)
4719 {
4720         string_set(Globals.ctx, &Globals.logfile, name);
4721         debug_set_logfile(name);
4722 }
4723
4724 /*******************************************************************
4725  Return the max print jobs per queue.
4726 ********************************************************************/
4727
4728 int lp_maxprintjobs(int snum)
4729 {
4730         int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
4731         if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
4732                 maxjobs = PRINT_MAX_JOBID - 1;
4733
4734         return maxjobs;
4735 }
4736
4737 const char *lp_printcapname(void)
4738 {
4739         if ((Globals.szPrintcapname != NULL) &&
4740             (Globals.szPrintcapname[0] != '\0'))
4741                 return Globals.szPrintcapname;
4742
4743         if (sDefault.printing == PRINT_CUPS) {
4744                 return "cups";
4745         }
4746
4747         if (sDefault.printing == PRINT_BSD)
4748                 return "/etc/printcap";
4749
4750         return PRINTCAP_NAME;
4751 }
4752
4753 static uint32 spoolss_state;
4754
4755 bool lp_disable_spoolss( void )
4756 {
4757         if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
4758                 spoolss_state = lp__disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4759
4760         return spoolss_state == SVCCTL_STOPPED ? true : false;
4761 }
4762
4763 void lp_set_spoolss_state( uint32 state )
4764 {
4765         SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
4766
4767         spoolss_state = state;
4768 }
4769
4770 uint32 lp_get_spoolss_state( void )
4771 {
4772         return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4773 }
4774
4775 /*******************************************************************
4776  Ensure we don't use sendfile if server smb signing is active.
4777 ********************************************************************/
4778
4779 bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state)
4780 {
4781         bool sign_active = false;
4782
4783         /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
4784         if (get_Protocol() < PROTOCOL_NT1) {
4785                 return false;
4786         }
4787         if (signing_state) {
4788                 sign_active = smb_signing_is_active(signing_state);
4789         }
4790         return (lp__use_sendfile(snum) &&
4791                         (get_remote_arch() != RA_WIN95) &&
4792                         !sign_active);
4793 }
4794
4795 /*******************************************************************
4796  Turn off sendfile if we find the underlying OS doesn't support it.
4797 ********************************************************************/
4798
4799 void set_use_sendfile(int snum, bool val)
4800 {
4801         if (LP_SNUM_OK(snum))
4802                 ServicePtrs[snum]->_use_sendfile = val;
4803         else
4804                 sDefault._use_sendfile = val;
4805 }
4806
4807 /*******************************************************************
4808  Turn off storing DOS attributes if this share doesn't support it.
4809 ********************************************************************/
4810
4811 void set_store_dos_attributes(int snum, bool val)
4812 {
4813         if (!LP_SNUM_OK(snum))
4814                 return;
4815         ServicePtrs[(snum)]->store_dos_attributes = val;
4816 }
4817
4818 void lp_set_mangling_method(const char *new_method)
4819 {
4820         string_set(Globals.ctx, &Globals.mangling_method, new_method);
4821 }
4822
4823 /*******************************************************************
4824  Global state for POSIX pathname processing.
4825 ********************************************************************/
4826
4827 static bool posix_pathnames;
4828
4829 bool lp_posix_pathnames(void)
4830 {
4831         return posix_pathnames;
4832 }
4833
4834 /*******************************************************************
4835  Change everything needed to ensure POSIX pathname processing (currently
4836  not much).
4837 ********************************************************************/
4838
4839 void lp_set_posix_pathnames(void)
4840 {
4841         posix_pathnames = true;
4842 }
4843
4844 /*******************************************************************
4845  Global state for POSIX lock processing - CIFS unix extensions.
4846 ********************************************************************/
4847
4848 bool posix_default_lock_was_set;
4849 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
4850
4851 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
4852 {
4853         if (posix_default_lock_was_set) {
4854                 return posix_cifsx_locktype;
4855         } else {
4856                 return fsp->posix_open ? POSIX_LOCK : WINDOWS_LOCK;
4857         }
4858 }
4859
4860 /*******************************************************************
4861 ********************************************************************/
4862
4863 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
4864 {
4865         posix_default_lock_was_set = true;
4866         posix_cifsx_locktype = val;
4867 }
4868
4869 int lp_min_receive_file_size(void)
4870 {
4871         if (Globals.iminreceivefile < 0) {
4872                 return 0;
4873         }
4874         return Globals.iminreceivefile;
4875 }
4876
4877 /*******************************************************************
4878  Safe wide links checks.
4879  This helper function always verify the validity of wide links,
4880  even after a configuration file reload.
4881 ********************************************************************/
4882
4883 static bool lp_widelinks_internal(int snum)
4884 {
4885         return (bool)(LP_SNUM_OK(snum)? ServicePtrs[(snum)]->bWidelinks :
4886                         sDefault.bWidelinks);
4887 }
4888
4889 void widelinks_warning(int snum)
4890 {
4891         if (lp_allow_insecure_wide_links()) {
4892                 return;
4893         }
4894
4895         if (lp_unix_extensions() && lp_widelinks_internal(snum)) {
4896                 DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
4897                         "These parameters are incompatible. "
4898                         "Wide links will be disabled for this share.\n",
4899                          lp_servicename(talloc_tos(), snum) ));
4900         }
4901 }
4902
4903 bool lp_widelinks(int snum)
4904 {
4905         /* wide links is always incompatible with unix extensions */
4906         if (lp_unix_extensions()) {
4907                 /*
4908                  * Unless we have "allow insecure widelinks"
4909                  * turned on.
4910                  */
4911                 if (!lp_allow_insecure_wide_links()) {
4912                         return false;
4913                 }
4914         }
4915
4916         return lp_widelinks_internal(snum);
4917 }
4918
4919 int lp_server_role(void)
4920 {
4921         return lp_find_server_role(lp__server_role(),
4922                                    lp__security(),
4923                                    lp__domain_logons(),
4924                                    lp_domain_master_true_or_auto());
4925 }
4926
4927 int lp_security(void)
4928 {
4929         return lp_find_security(lp__server_role(),
4930                                 lp__security());
4931 }
4932
4933 struct loadparm_global * get_globals(void)
4934 {
4935         return &Globals;
4936 }