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