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