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