param: Remove winbindd privileged socket directory option
[bbaumbach/samba-autobuild/.git] / source3 / param / loadparm.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Parameter loading functions
4    Copyright (C) Karl Auer 1993-1998
5
6    Largely re-written by Andrew Tridgell, September 1994
7
8    Copyright (C) Simo Sorce 2001
9    Copyright (C) Alexander Bokovoy 2002
10    Copyright (C) Stefan (metze) Metzmacher 2002
11    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
12    Copyright (C) Michael Adam 2008
13    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
14    Copyright (C) Andrew Bartlett 2011
15
16    This program is free software; you can redistribute it and/or modify
17    it under the terms of the GNU General Public License as published by
18    the Free Software Foundation; either version 3 of the License, or
19    (at your option) any later version.
20
21    This program is distributed in the hope that it will be useful,
22    but WITHOUT ANY WARRANTY; without even the implied warranty of
23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24    GNU General Public License for more details.
25
26    You should have received a copy of the GNU General Public License
27    along with this program.  If not, see <http://www.gnu.org/licenses/>.
28 */
29
30 /*
31  *  Load parameters.
32  *
33  *  This module provides suitable callback functions for the params
34  *  module. It builds the internal table of service details which is
35  *  then used by the rest of the server.
36  *
37  * To add a parameter:
38  *
39  * 1) add it to the global or service structure definition
40  * 2) add it to the parm_table
41  * 3) add it to the list of available functions (eg: using FN_GLOBAL_STRING())
42  * 4) If it's a global then initialise it in init_globals. If a local
43  *    (ie. service) parameter then initialise it in the sDefault structure
44  *  
45  *
46  * Notes:
47  *   The configuration file is processed sequentially for speed. It is NOT
48  *   accessed randomly as happens in 'real' Windows. For this reason, there
49  *   is a fair bit of sequence-dependent code here - ie., code which assumes
50  *   that certain things happen before others. In particular, the code which
51  *   happens at the boundary between sections is delicately poised, so be
52  *   careful!
53  *
54  */
55
56 #include "includes.h"
57 #include "system/filesys.h"
58 #include "util_tdb.h"
59 #include "lib/param/loadparm.h"
60 #include "lib/param/param.h"
61 #include "printing.h"
62 #include "lib/smbconf/smbconf.h"
63 #include "lib/smbconf/smbconf_init.h"
64
65 #include "ads.h"
66 #include "../librpc/gen_ndr/svcctl.h"
67 #include "intl.h"
68 #include "../libcli/smb/smb_signing.h"
69 #include "dbwrap/dbwrap.h"
70 #include "dbwrap/dbwrap_rbt.h"
71 #include "../lib/util/bitmap.h"
72 #include "librpc/gen_ndr/nbt.h"
73 #include "source4/lib/tls/tls.h"
74
75 #ifdef HAVE_SYS_SYSCTL_H
76 #include <sys/sysctl.h>
77 #endif
78
79 bool bLoaded = false;
80
81 extern userdom_struct current_user_info;
82
83 /* the special value for the include parameter
84  * to be interpreted not as a file name but to
85  * trigger loading of the global smb.conf options
86  * from registry. */
87 #ifndef INCLUDE_REGISTRY_NAME
88 #define INCLUDE_REGISTRY_NAME "registry"
89 #endif
90
91 static bool in_client = false;          /* Not in the client by default */
92 static struct smbconf_csn conf_last_csn;
93
94 static int config_backend = CONFIG_BACKEND_FILE;
95
96 /* some helpful bits */
97 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && \
98                        (ServicePtrs != NULL) && \
99                        (ServicePtrs[(i)] != NULL) && ServicePtrs[(i)]->valid)
100 #define VALID(i) ((ServicePtrs != NULL) && (ServicePtrs[i]!= NULL) && \
101                   ServicePtrs[i]->valid)
102
103 #define USERSHARE_VALID 1
104 #define USERSHARE_PENDING_DELETE 2
105
106 static bool defaults_saved = false;
107
108 #include "lib/param/param_global.h"
109
110 static struct loadparm_global Globals;
111
112 /* This is a default service used to prime a services structure */
113 static struct loadparm_service sDefault =
114 {
115         .valid = true,
116         .autoloaded = false,
117         .usershare = 0,
118         .usershare_last_mod = {0, 0},
119         .szService = NULL,
120         .path = NULL,
121         .invalid_users = NULL,
122         .valid_users = NULL,
123         .admin_users = NULL,
124         .copy = NULL,
125         .include = NULL,
126         .preexec = NULL,
127         .postexec = NULL,
128         .root_preexec = NULL,
129         .root_postexec = NULL,
130         .cups_options = NULL,
131         .print_command = NULL,
132         .lpq_command = NULL,
133         .lprm_command = NULL,
134         .lppause_command = NULL,
135         .lpresume_command = NULL,
136         .queuepause_command = NULL,
137         .queueresume_command = NULL,
138         ._printername = NULL,
139         .printjob_username = NULL,
140         .dont_descend = NULL,
141         .hosts_allow = NULL,
142         .hosts_deny = NULL,
143         .magic_script = NULL,
144         .magic_output = NULL,
145         .veto_files = NULL,
146         .hide_files = NULL,
147         .veto_oplock_files = NULL,
148         .comment = NULL,
149         .force_user = NULL,
150         .force_group = NULL,
151         .read_list = NULL,
152         .write_list = NULL,
153         .volume = NULL,
154         .fstype = NULL,
155         .vfs_objects = NULL,
156         .msdfs_proxy = NULL,
157         .aio_write_behind = NULL,
158         .dfree_command = NULL,
159         .min_print_space = 0,
160         .max_print_jobs = 1000,
161         .max_reported_print_jobs = 0,
162         .write_cache_size = 0,
163         .create_mask = 0744,
164         .force_create_mode = 0,
165         .directory_mask = 0755,
166         .force_directory_mode = 0,
167         .max_connections = 0,
168         .default_case = CASE_LOWER,
169         .printing = DEFAULT_PRINTING,
170         .oplock_contention_limit = 2,
171         .csc_policy = 0,
172         .block_size = 1024,
173         .dfree_cache_time = 0,
174         .preexec_close = false,
175         .root_preexec_close = false,
176         .case_sensitive = Auto,
177         .preserve_case = true,
178         .short_preserve_case = true,
179         .hide_dot_files = true,
180         .hide_special_files = false,
181         .hide_unreadable = false,
182         .hide_unwriteable_files = false,
183         .browseable = true,
184         .access_based_share_enum = false,
185         .available = true,
186         .read_only = true,
187         .spotlight = false,
188         .guest_only = false,
189         .administrative_share = false,
190         .guest_ok = false,
191         .printable = false,
192         .print_notify_backchannel = false,
193         .map_system = false,
194         .map_hidden = false,
195         .map_archive = true,
196         .store_dos_attributes = false,
197         .dmapi_support = false,
198         .locking = true,
199         .strict_locking = Auto,
200         .posix_locking = true,
201         .oplocks = true,
202         .kernel_oplocks = false,
203         .level2_oplocks = true,
204         .mangled_names = MANGLED_NAMES_YES,
205         .wide_links = false,
206         .follow_symlinks = true,
207         .sync_always = false,
208         .strict_allocate = false,
209         .strict_rename = false,
210         .strict_sync = false,
211         .mangling_char = '~',
212         .copymap = NULL,
213         .delete_readonly = false,
214         .fake_oplocks = false,
215         .delete_veto_files = false,
216         .dos_filemode = false,
217         .dos_filetimes = true,
218         .dos_filetime_resolution = false,
219         .fake_directory_create_times = false,
220         .blocking_locks = true,
221         .inherit_permissions = false,
222         .inherit_acls = false,
223         .inherit_owner = false,
224         .msdfs_root = false,
225         .msdfs_shuffle_referrals = false,
226         .use_client_driver = false,
227         .default_devmode = true,
228         .force_printername = false,
229         .nt_acl_support = true,
230         .force_unknown_acl_user = false,
231         ._use_sendfile = false,
232         .profile_acls = false,
233         .map_acl_inherit = false,
234         .afs_share = false,
235         .ea_support = false,
236         .acl_check_permissions = true,
237         .acl_map_full_control = true,
238         .acl_group_control = false,
239         .acl_allow_execute_always = false,
240         .allocation_roundup_size = SMB_ROUNDUP_ALLOCATION_SIZE,
241         .aio_read_size = 0,
242         .aio_write_size = 0,
243         .map_readonly = MAP_READONLY_YES,
244         .directory_name_cache_size = 100,
245         .smb_encrypt = SMB_SIGNING_DEFAULT,
246         .kernel_share_modes = true,
247         .durable_handles = true,
248         .param_opt = NULL,
249         .dummy = ""
250 };
251
252 /* local variables */
253 static struct loadparm_service **ServicePtrs = NULL;
254 static int iNumServices = 0;
255 static int iServiceIndex = 0;
256 static struct db_context *ServiceHash;
257 static bool bInGlobalSection = true;
258 static bool bGlobalOnly = false;
259 static struct file_lists *file_lists = NULL;
260 static unsigned int *flags_list = NULL;
261
262 static void set_allowed_client_auth(void);
263
264 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue);
265 static void free_param_opts(struct parmlist_entry **popts);
266
267 /**
268  *  Function to return the default value for the maximum number of open
269  *  file descriptors permitted.  This function tries to consult the
270  *  kernel-level (sysctl) and ulimit (getrlimit()) values and goes
271  *  the smaller of those.
272  */
273 static int max_open_files(void)
274 {
275         int sysctl_max = MAX_OPEN_FILES;
276         int rlimit_max = MAX_OPEN_FILES;
277
278 #ifdef HAVE_SYSCTLBYNAME
279         {
280                 size_t size = sizeof(sysctl_max);
281                 sysctlbyname("kern.maxfilesperproc", &sysctl_max, &size, NULL,
282                              0);
283         }
284 #endif
285
286 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
287         {
288                 struct rlimit rl;
289
290                 ZERO_STRUCT(rl);
291
292                 if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
293                         rlimit_max = rl.rlim_cur;
294
295 #if defined(RLIM_INFINITY)
296                 if(rl.rlim_cur == RLIM_INFINITY)
297                         rlimit_max = MAX_OPEN_FILES;
298 #endif
299         }
300 #endif
301
302         if (sysctl_max < MIN_OPEN_FILES_WINDOWS) {
303                 DEBUG(2,("max_open_files: increasing sysctl_max (%d) to "
304                         "minimum Windows limit (%d)\n",
305                         sysctl_max,
306                         MIN_OPEN_FILES_WINDOWS));
307                 sysctl_max = MIN_OPEN_FILES_WINDOWS;
308         }
309
310         if (rlimit_max < MIN_OPEN_FILES_WINDOWS) {
311                 DEBUG(2,("rlimit_max: increasing rlimit_max (%d) to "
312                         "minimum Windows limit (%d)\n",
313                         rlimit_max,
314                         MIN_OPEN_FILES_WINDOWS));
315                 rlimit_max = MIN_OPEN_FILES_WINDOWS;
316         }
317
318         return MIN(sysctl_max, rlimit_max);
319 }
320
321 /**
322  * Common part of freeing allocated data for one parameter.
323  */
324 static void free_one_parameter_common(void *parm_ptr,
325                                       struct parm_struct parm)
326 {
327         if ((parm.type == P_STRING) ||
328             (parm.type == P_USTRING))
329         {
330                 lpcfg_string_free((char**)parm_ptr);
331         } else if (parm.type == P_LIST || parm.type == P_CMDLIST) {
332                 TALLOC_FREE(*((char***)parm_ptr));
333         }
334 }
335
336 /**
337  * Free the allocated data for one parameter for a share
338  * given as a service struct.
339  */
340 static void free_one_parameter(struct loadparm_service *service,
341                                struct parm_struct parm)
342 {
343         void *parm_ptr;
344
345         if (parm.p_class != P_LOCAL) {
346                 return;
347         }
348
349         parm_ptr = lp_parm_ptr(service, &parm);
350
351         free_one_parameter_common(parm_ptr, parm);
352 }
353
354 /**
355  * Free the allocated parameter data of a share given
356  * as a service struct.
357  */
358 static void free_parameters(struct loadparm_service *service)
359 {
360         uint32_t i;
361
362         for (i=0; parm_table[i].label; i++) {
363                 free_one_parameter(service, parm_table[i]);
364         }
365 }
366
367 /**
368  * Free the allocated data for one parameter for a given share
369  * specified by an snum.
370  */
371 static void free_one_parameter_by_snum(int snum, struct parm_struct parm)
372 {
373         void *parm_ptr;
374
375         if (snum < 0) {
376                 parm_ptr = lp_parm_ptr(NULL, &parm);
377         } else if (parm.p_class != P_LOCAL) {
378                 return;
379         } else {
380                 parm_ptr = lp_parm_ptr(ServicePtrs[snum], &parm);
381         }
382
383         free_one_parameter_common(parm_ptr, parm);
384 }
385
386 /**
387  * Free the allocated parameter data for a share specified
388  * by an snum.
389  */
390 static void free_parameters_by_snum(int snum)
391 {
392         uint32_t i;
393
394         for (i=0; parm_table[i].label; i++) {
395                 free_one_parameter_by_snum(snum, parm_table[i]);
396         }
397 }
398
399 /**
400  * Free the allocated global parameters.
401  */
402 static void free_global_parameters(void)
403 {
404         uint32_t i;
405         struct parm_struct *parm;
406
407         free_param_opts(&Globals.param_opt);
408         free_parameters_by_snum(GLOBAL_SECTION_SNUM);
409
410         /* Reset references in the defaults because the context is going to be freed */
411         for (i=0; parm_table[i].label; i++) {
412                 parm = &parm_table[i];
413                 if ((parm->type == P_STRING) ||
414                     (parm->type == P_USTRING)) {
415                         if ((parm->def.svalue != NULL) &&
416                             (*(parm->def.svalue) != '\0')) {
417                                 if (talloc_parent(parm->def.svalue) == Globals.ctx) {
418                                         parm->def.svalue = NULL;
419                                 }
420                         }
421                 }
422         }
423         TALLOC_FREE(Globals.ctx);
424 }
425
426 struct lp_stored_option {
427         struct lp_stored_option *prev, *next;
428         const char *label;
429         const char *value;
430 };
431
432 static struct lp_stored_option *stored_options;
433
434 /*
435   save options set by lp_set_cmdline() into a list. This list is
436   re-applied when we do a globals reset, so that cmdline set options
437   are sticky across reloads of smb.conf
438  */
439 bool store_lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
440 {
441         struct lp_stored_option *entry, *entry_next;
442         for (entry = stored_options; entry != NULL; entry = entry_next) {
443                 entry_next = entry->next;
444                 if (strcmp(pszParmName, entry->label) == 0) {
445                         DLIST_REMOVE(stored_options, entry);
446                         talloc_free(entry);
447                         break;
448                 }
449         }
450
451         entry = talloc(NULL, struct lp_stored_option);
452         if (!entry) {
453                 return false;
454         }
455
456         entry->label = talloc_strdup(entry, pszParmName);
457         if (!entry->label) {
458                 talloc_free(entry);
459                 return false;
460         }
461
462         entry->value = talloc_strdup(entry, pszParmValue);
463         if (!entry->value) {
464                 talloc_free(entry);
465                 return false;
466         }
467
468         DLIST_ADD_END(stored_options, entry);
469
470         return true;
471 }
472
473 static bool apply_lp_set_cmdline(void)
474 {
475         struct lp_stored_option *entry = NULL;
476         for (entry = stored_options; entry != NULL; entry = entry->next) {
477                 if (!lp_set_cmdline_helper(entry->label, entry->value)) {
478                         DEBUG(0, ("Failed to re-apply cmdline parameter %s = %s\n",
479                                   entry->label, entry->value));
480                         return false;
481                 }
482         }
483         return true;
484 }
485
486 /***************************************************************************
487  Initialise the global parameter structure.
488 ***************************************************************************/
489
490 static void init_globals(struct loadparm_context *lp_ctx, bool reinit_globals)
491 {
492         static bool done_init = false;
493         char *s = NULL;
494         int i;
495
496         /* If requested to initialize only once and we've already done it... */
497         if (!reinit_globals && done_init) {
498                 /* ... then we have nothing more to do */
499                 return;
500         }
501
502         if (!done_init) {
503                 /* The logfile can be set before this is invoked. Free it if so. */
504                 lpcfg_string_free(&Globals.logfile);
505                 done_init = true;
506         } else {
507                 free_global_parameters();
508         }
509
510         /* This memset and the free_global_parameters() above will
511          * wipe out smb.conf options set with lp_set_cmdline().  The
512          * apply_lp_set_cmdline() call puts these values back in the
513          * table once the defaults are set */
514         ZERO_STRUCT(Globals);
515
516         Globals.ctx = talloc_pooled_object(NULL, char, 272, 2048);
517
518         /* Initialize the flags list if necessary */
519         if (flags_list == NULL) {
520                 get_flags();
521         }
522
523         for (i = 0; parm_table[i].label; i++) {
524                 if ((parm_table[i].type == P_STRING ||
525                      parm_table[i].type == P_USTRING))
526                 {
527                         lpcfg_string_set(
528                                 Globals.ctx,
529                                 (char **)lp_parm_ptr(NULL, &parm_table[i]),
530                                 "");
531                 }
532         }
533
534
535         lpcfg_string_set(Globals.ctx, &sDefault.fstype, FSTYPE_STRING);
536         lpcfg_string_set(Globals.ctx, &sDefault.printjob_username, "%U");
537
538         init_printer_values(lp_ctx, Globals.ctx, &sDefault);
539
540         sDefault.ntvfs_handler = str_list_make_v3_const(NULL, "unixuid default", NULL);
541
542         DEBUG(3, ("Initialising global parameters\n"));
543
544         /* Must manually force to upper case here, as this does not go via the handler */
545         lpcfg_string_set(Globals.ctx, &Globals.netbios_name,
546                          myhostname_upper());
547
548         lpcfg_string_set(Globals.ctx, &Globals.smb_passwd_file,
549                          get_dyn_SMB_PASSWD_FILE());
550         lpcfg_string_set(Globals.ctx, &Globals.private_dir,
551                          get_dyn_PRIVATE_DIR());
552
553         /* use the new 'hash2' method by default, with a prefix of 1 */
554         lpcfg_string_set(Globals.ctx, &Globals.mangling_method, "hash2");
555         Globals.mangle_prefix = 1;
556
557         lpcfg_string_set(Globals.ctx, &Globals.guest_account, GUEST_ACCOUNT);
558
559         /* using UTF8 by default allows us to support all chars */
560         lpcfg_string_set(Globals.ctx, &Globals.unix_charset,
561                          DEFAULT_UNIX_CHARSET);
562
563         /* Use codepage 850 as a default for the dos character set */
564         lpcfg_string_set(Globals.ctx, &Globals.dos_charset,
565                          DEFAULT_DOS_CHARSET);
566
567         /*
568          * Allow the default PASSWD_CHAT to be overridden in local.h.
569          */
570         lpcfg_string_set(Globals.ctx, &Globals.passwd_chat,
571                          DEFAULT_PASSWD_CHAT);
572
573         lpcfg_string_set(Globals.ctx, &Globals.workgroup, DEFAULT_WORKGROUP);
574
575         lpcfg_string_set(Globals.ctx, &Globals.passwd_program, "");
576         lpcfg_string_set(Globals.ctx, &Globals.lock_directory,
577                          get_dyn_LOCKDIR());
578         lpcfg_string_set(Globals.ctx, &Globals.state_directory,
579                          get_dyn_STATEDIR());
580         lpcfg_string_set(Globals.ctx, &Globals.cache_directory,
581                          get_dyn_CACHEDIR());
582         lpcfg_string_set(Globals.ctx, &Globals.pid_directory,
583                          get_dyn_PIDDIR());
584         lpcfg_string_set(Globals.ctx, &Globals.nbt_client_socket_address,
585                          "0.0.0.0");
586         /*
587          * By default support explicit binding to broadcast
588          * addresses.
589          */
590         Globals.nmbd_bind_explicit_broadcast = true;
591
592         s = talloc_asprintf(talloc_tos(), "Samba %s", samba_version_string());
593         if (s == NULL) {
594                 smb_panic("init_globals: ENOMEM");
595         }
596         lpcfg_string_set(Globals.ctx, &Globals.server_string, s);
597         TALLOC_FREE(s);
598 #ifdef DEVELOPER
599         lpcfg_string_set(Globals.ctx, &Globals.panic_action,
600                          "/bin/sleep 999999999");
601 #endif
602
603         lpcfg_string_set(Globals.ctx, &Globals.socket_options,
604                          DEFAULT_SOCKET_OPTIONS);
605
606         lpcfg_string_set(Globals.ctx, &Globals.logon_drive, "");
607         /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
608         lpcfg_string_set(Globals.ctx, &Globals.logon_home, "\\\\%N\\%U");
609         lpcfg_string_set(Globals.ctx, &Globals.logon_path,
610                          "\\\\%N\\%U\\profile");
611
612         Globals.name_resolve_order = str_list_make_v3_const(NULL, "lmhosts wins host bcast", NULL);
613         lpcfg_string_set(Globals.ctx, &Globals.password_server, "*");
614
615         Globals.algorithmic_rid_base = BASE_RID;
616
617         Globals.load_printers = true;
618         Globals.printcap_cache_time = 750;      /* 12.5 minutes */
619
620         Globals.config_backend = config_backend;
621         Globals._server_role = ROLE_AUTO;
622
623         /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
624         /* Discovered by 2 days of pain by Don McCall @ HP :-). */
625         Globals.max_xmit = 0x4104;
626         Globals.max_mux = 50;   /* This is *needed* for profile support. */
627         Globals.lpq_cache_time = 30;    /* changed to handle large print servers better -- jerry */
628         Globals._disable_spoolss = false;
629         Globals.max_smbd_processes = 0;/* no limit specified */
630         Globals.username_level = 0;
631         Globals.deadtime = 0;
632         Globals.getwd_cache = true;
633         Globals.large_readwrite = true;
634         Globals.max_log_size = 5000;
635         Globals.max_open_files = max_open_files();
636         Globals.server_max_protocol = PROTOCOL_SMB3_11;
637         Globals.server_min_protocol = PROTOCOL_LANMAN1;
638         Globals._client_max_protocol = PROTOCOL_DEFAULT;
639         Globals.client_min_protocol = PROTOCOL_CORE;
640         Globals._client_ipc_max_protocol = PROTOCOL_DEFAULT;
641         Globals._client_ipc_min_protocol = PROTOCOL_DEFAULT;
642         Globals._security = SEC_AUTO;
643         Globals.encrypt_passwords = true;
644         Globals.client_schannel = Auto;
645         Globals.winbind_sealed_pipes = true;
646         Globals.require_strong_key = true;
647         Globals.server_schannel = Auto;
648         Globals.read_raw = true;
649         Globals.write_raw = true;
650         Globals.null_passwords = false;
651         Globals.old_password_allowed_period = 60;
652         Globals.obey_pam_restrictions = false;
653         Globals.syslog = 1;
654         Globals.syslog_only = false;
655         Globals.timestamp_logs = true;
656         lpcfg_string_set(Globals.ctx, &Globals.log_level, "0");
657         Globals.debug_prefix_timestamp = false;
658         Globals.debug_hires_timestamp = true;
659         Globals.debug_pid = false;
660         Globals.debug_uid = false;
661         Globals.debug_class = false;
662         Globals.enable_core_files = true;
663         Globals.max_ttl = 60 * 60 * 24 * 3;     /* 3 days default. */
664         Globals.max_wins_ttl = 60 * 60 * 24 * 6;        /* 6 days default. */
665         Globals.min_wins_ttl = 60 * 60 * 6;     /* 6 hours default. */
666         Globals.machine_password_timeout = 60 * 60 * 24 * 7;    /* 7 days default. */
667         Globals.lm_announce = Auto;     /* = Auto: send only if LM clients found */
668         Globals.lm_interval = 60;
669 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
670         Globals.nis_homedir = false;
671 #ifdef WITH_NISPLUS_HOME
672         lpcfg_string_set(Globals.ctx, &Globals.homedir_map,
673                          "auto_home.org_dir");
674 #else
675         lpcfg_string_set(Globals.ctx, &Globals.homedir_map, "auto.home");
676 #endif
677 #endif
678         Globals.time_server = false;
679         Globals.bind_interfaces_only = false;
680         Globals.unix_password_sync = false;
681         Globals.pam_password_change = false;
682         Globals.passwd_chat_debug = false;
683         Globals.passwd_chat_timeout = 2; /* 2 second default. */
684         Globals.nt_pipe_support = true; /* Do NT pipes by default. */
685         Globals.nt_status_support = true; /* Use NT status by default. */
686         Globals.smbd_profiling_level = 0;
687         Globals.stat_cache = true;      /* use stat cache by default */
688         Globals.max_stat_cache_size = 256; /* 256k by default */
689         Globals.restrict_anonymous = 0;
690         Globals.client_lanman_auth = false;     /* Do NOT use the LanMan hash if it is available */
691         Globals.client_plaintext_auth = false;  /* Do NOT use a plaintext password even if is requested by the server */
692         Globals.lanman_auth = false;    /* Do NOT use the LanMan hash, even if it is supplied */
693         Globals.ntlm_auth = false;      /* Do NOT use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
694         Globals.raw_ntlmv2_auth = false; /* Reject NTLMv2 without NTLMSSP */
695         Globals.client_ntlmv2_auth = true; /* Client should always use use NTLMv2, as we can't tell that the server supports it, but most modern servers do */
696         /* Note, that we will also use NTLM2 session security (which is different), if it is available */
697
698         Globals.allow_dcerpc_auth_level_connect = false; /* we don't allow this by default */
699
700         Globals.map_to_guest = 0;       /* By Default, "Never" */
701         Globals.oplock_break_wait_time = 0;     /* By Default, 0 msecs. */
702         Globals.enhanced_browsing = true;
703         Globals.lock_spin_time = WINDOWS_MINIMUM_LOCK_TIMEOUT_MS; /* msec. */
704 #ifdef MMAP_BLACKLIST
705         Globals.use_mmap = false;
706 #else
707         Globals.use_mmap = true;
708 #endif
709         Globals.unicode = true;
710         Globals.unix_extensions = true;
711         Globals.reset_on_zero_vc = false;
712         Globals.log_writeable_files_on_exit = false;
713         Globals.create_krb5_conf = true;
714         Globals.include_system_krb5_conf = true;
715         Globals._winbind_max_domain_connections = 1;
716
717         /* hostname lookups can be very expensive and are broken on
718            a large number of sites (tridge) */
719         Globals.hostname_lookups = false;
720
721         Globals.change_notify = true,
722         Globals.kernel_change_notify = true,
723
724         lpcfg_string_set(Globals.ctx, &Globals.passdb_backend, "tdbsam");
725         lpcfg_string_set(Globals.ctx, &Globals.ldap_suffix, "");
726         lpcfg_string_set(Globals.ctx, &Globals._ldap_machine_suffix, "");
727         lpcfg_string_set(Globals.ctx, &Globals._ldap_user_suffix, "");
728         lpcfg_string_set(Globals.ctx, &Globals._ldap_group_suffix, "");
729         lpcfg_string_set(Globals.ctx, &Globals._ldap_idmap_suffix, "");
730
731         lpcfg_string_set(Globals.ctx, &Globals.ldap_admin_dn, "");
732         Globals.ldap_ssl = LDAP_SSL_START_TLS;
733         Globals.ldap_ssl_ads = false;
734         Globals.ldap_deref = -1;
735         Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
736         Globals.ldap_delete_dn = false;
737         Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
738         Globals.ldap_follow_referral = Auto;
739         Globals.ldap_timeout = LDAP_DEFAULT_TIMEOUT;
740         Globals.ldap_connection_timeout = LDAP_CONNECTION_DEFAULT_TIMEOUT;
741         Globals.ldap_page_size = LDAP_PAGE_SIZE;
742
743         Globals.ldap_debug_level = 0;
744         Globals.ldap_debug_threshold = 10;
745
746         Globals.client_ldap_sasl_wrapping = ADS_AUTH_SASL_SIGN;
747
748         Globals.ldap_server_require_strong_auth =
749                 LDAP_SERVER_REQUIRE_STRONG_AUTH_YES;
750
751         /* This is what we tell the afs client. in reality we set the token 
752          * to never expire, though, when this runs out the afs client will 
753          * forget the token. Set to 0 to get NEVERDATE.*/
754         Globals.afs_token_lifetime = 604800;
755         Globals.cups_connection_timeout = CUPS_DEFAULT_CONNECTION_TIMEOUT;
756
757 /* these parameters are set to defaults that are more appropriate
758    for the increasing samba install base:
759
760    as a member of the workgroup, that will possibly become a
761    _local_ master browser (lm = true).  this is opposed to a forced
762    local master browser startup (pm = true).
763
764    doesn't provide WINS server service by default (wsupp = false),
765    and doesn't provide domain master browser services by default, either.
766
767 */
768
769         Globals.show_add_printer_wizard = true;
770         Globals.os_level = 20;
771         Globals.local_master = true;
772         Globals._domain_master = Auto;  /* depending on _domain_logons */
773         Globals._domain_logons = false;
774         Globals.browse_list = true;
775         Globals.we_are_a_wins_server = false;
776         Globals.wins_proxy = false;
777
778         TALLOC_FREE(Globals.init_logon_delayed_hosts);
779         Globals.init_logon_delay = 100; /* 100 ms default delay */
780
781         Globals.wins_dns_proxy = true;
782
783         Globals.allow_trusted_domains = true;
784         lpcfg_string_set(Globals.ctx, &Globals.idmap_backend, "tdb");
785
786         lpcfg_string_set(Globals.ctx, &Globals.template_shell, "/bin/false");
787         lpcfg_string_set(Globals.ctx, &Globals.template_homedir,
788                          "/home/%D/%U");
789         lpcfg_string_set(Globals.ctx, &Globals.winbind_separator, "\\");
790         lpcfg_string_set(Globals.ctx, &Globals.winbindd_socket_directory,
791                          dyn_WINBINDD_SOCKET_DIR);
792
793         lpcfg_string_set(Globals.ctx, &Globals.cups_server, "");
794         lpcfg_string_set(Globals.ctx, &Globals.iprint_server, "");
795
796         lpcfg_string_set(Globals.ctx, &Globals._ctdbd_socket, "");
797
798         Globals.cluster_addresses = NULL;
799         Globals.clustering = false;
800         Globals.ctdb_timeout = 0;
801         Globals.ctdb_locktime_warn_threshold = 0;
802
803         Globals.winbind_cache_time = 300;       /* 5 minutes */
804         Globals.winbind_reconnect_delay = 30;   /* 30 seconds */
805         Globals.winbind_request_timeout = 60;   /* 60 seconds */
806         Globals.winbind_max_clients = 200;
807         Globals.winbind_enum_users = false;
808         Globals.winbind_enum_groups = false;
809         Globals.winbind_use_default_domain = false;
810         Globals.winbind_trusted_domains_only = false;
811         Globals.winbind_nested_groups = true;
812         Globals.winbind_expand_groups = 0;
813         Globals.winbind_nss_info = str_list_make_v3_const(NULL, "template", NULL);
814         Globals.winbind_refresh_tickets = false;
815         Globals.winbind_offline_logon = false;
816
817         Globals.idmap_cache_time = 86400 * 7; /* a week by default */
818         Globals.idmap_negative_cache_time = 120; /* 2 minutes by default */
819
820         Globals.passdb_expand_explicit = false;
821
822         Globals.name_cache_timeout = 660; /* In seconds */
823
824         Globals.use_spnego = true;
825         Globals.client_use_spnego = true;
826
827         Globals.client_signing = SMB_SIGNING_DEFAULT;
828         Globals._client_ipc_signing = SMB_SIGNING_DEFAULT;
829         Globals.server_signing = SMB_SIGNING_DEFAULT;
830
831         Globals.defer_sharing_violations = true;
832         Globals.smb_ports = str_list_make_v3_const(NULL, SMB_PORTS, NULL);
833
834         Globals.enable_privileges = true;
835         Globals.host_msdfs        = true;
836         Globals.enable_asu_support       = false;
837
838         /* User defined shares. */
839         s = talloc_asprintf(talloc_tos(), "%s/usershares", get_dyn_STATEDIR());
840         if (s == NULL) {
841                 smb_panic("init_globals: ENOMEM");
842         }
843         lpcfg_string_set(Globals.ctx, &Globals.usershare_path, s);
844         TALLOC_FREE(s);
845         lpcfg_string_set(Globals.ctx, &Globals.usershare_template_share, "");
846         Globals.usershare_max_shares = 0;
847         /* By default disallow sharing of directories not owned by the sharer. */
848         Globals.usershare_owner_only = true;
849         /* By default disallow guest access to usershares. */
850         Globals.usershare_allow_guests = false;
851
852         Globals.keepalive = DEFAULT_KEEPALIVE;
853
854         /* By default no shares out of the registry */
855         Globals.registry_shares = false;
856
857         Globals.min_receivefile_size = 0;
858
859         Globals.map_untrusted_to_domain = false;
860         Globals.multicast_dns_register = true;
861
862         Globals.smb2_max_read = DEFAULT_SMB2_MAX_READ;
863         Globals.smb2_max_write = DEFAULT_SMB2_MAX_WRITE;
864         Globals.smb2_max_trans = DEFAULT_SMB2_MAX_TRANSACT;
865         Globals.smb2_max_credits = DEFAULT_SMB2_MAX_CREDITS;
866         Globals.smb2_leases = true;
867
868         lpcfg_string_set(Globals.ctx, &Globals.ncalrpc_dir,
869                          get_dyn_NCALRPCDIR());
870
871         Globals.server_services = str_list_make_v3_const(NULL, "s3fs rpc nbt wrepl ldap cldap kdc drepl winbindd ntp_signd kcc dnsupdate dns", NULL);
872
873         Globals.dcerpc_endpoint_servers = str_list_make_v3_const(NULL, "epmapper wkssvc rpcecho samr netlogon lsarpc drsuapi dssetup unixinfo browser eventlog6 backupkey dnsserver", NULL);
874
875         Globals.tls_enabled = true;
876         Globals.tls_verify_peer = TLS_VERIFY_PEER_AS_STRICT_AS_POSSIBLE;
877
878         lpcfg_string_set(Globals.ctx, &Globals._tls_keyfile, "tls/key.pem");
879         lpcfg_string_set(Globals.ctx, &Globals._tls_certfile, "tls/cert.pem");
880         lpcfg_string_set(Globals.ctx, &Globals._tls_cafile, "tls/ca.pem");
881         lpcfg_string_set(Globals.ctx, &Globals.tls_priority,
882                          "NORMAL:-VERS-SSL3.0");
883
884         lpcfg_string_set(Globals.ctx, &Globals.share_backend, "classic");
885
886         Globals._preferred_master = Auto;
887
888         Globals.allow_dns_updates = DNS_UPDATE_SIGNED;
889
890         lpcfg_string_set(Globals.ctx, &Globals.ntp_signd_socket_directory,
891                          get_dyn_NTP_SIGND_SOCKET_DIR());
892
893         s = talloc_asprintf(talloc_tos(), "%s/samba_kcc", get_dyn_SCRIPTSBINDIR());
894         if (s == NULL) {
895                 smb_panic("init_globals: ENOMEM");
896         }
897         Globals.samba_kcc_command = str_list_make_v3_const(NULL, s, NULL);
898         TALLOC_FREE(s);
899
900         s = talloc_asprintf(talloc_tos(), "%s/samba_dnsupdate", get_dyn_SCRIPTSBINDIR());
901         if (s == NULL) {
902                 smb_panic("init_globals: ENOMEM");
903         }
904         Globals.dns_update_command = str_list_make_v3_const(NULL, s, NULL);
905         TALLOC_FREE(s);
906
907         s = talloc_asprintf(talloc_tos(), "%s/samba_spnupdate", get_dyn_SCRIPTSBINDIR());
908         if (s == NULL) {
909                 smb_panic("init_globals: ENOMEM");
910         }
911         Globals.spn_update_command = str_list_make_v3_const(NULL, s, NULL);
912         TALLOC_FREE(s);
913
914         Globals.nsupdate_command = str_list_make_v3_const(NULL, "/usr/bin/nsupdate -g", NULL);
915
916         Globals.rndc_command = str_list_make_v3_const(NULL, "/usr/sbin/rndc", NULL);
917
918         Globals.cldap_port = 389;
919
920         Globals.dgram_port = NBT_DGRAM_SERVICE_PORT;
921
922         Globals.nbt_port = NBT_NAME_SERVICE_PORT;
923
924         Globals.krb5_port = 88;
925
926         Globals.kpasswd_port = 464;
927
928         Globals.web_port = 901;
929
930         Globals.aio_max_threads = 100;
931
932         /* Now put back the settings that were set with lp_set_cmdline() */
933         apply_lp_set_cmdline();
934 }
935
936 /* Convenience routine to setup an lp_context with additional s3 variables */
937 static struct loadparm_context *setup_lp_context(TALLOC_CTX *mem_ctx)
938 {
939         struct loadparm_context *lp_ctx;
940
941         lp_ctx = loadparm_init_s3(mem_ctx,
942                                   loadparm_s3_helpers());
943         if (lp_ctx == NULL) {
944                 DEBUG(0, ("loadparm_init_s3 failed\n"));
945                 return NULL;
946         }
947
948         lp_ctx->sDefault = &sDefault;
949         lp_ctx->services = NULL; /* We do not want to access this directly */
950         lp_ctx->bInGlobalSection = bInGlobalSection;
951         lp_ctx->flags = flags_list;
952
953         return lp_ctx;
954 }
955
956 /*******************************************************************
957  Convenience routine to grab string parameters into talloced memory
958  and run standard_sub_basic on them. The buffers can be written to by
959  callers without affecting the source string.
960 ********************************************************************/
961
962 char *lp_string(TALLOC_CTX *ctx, const char *s)
963 {
964         char *ret;
965
966         /* The follow debug is useful for tracking down memory problems
967            especially if you have an inner loop that is calling a lp_*()
968            function that returns a string.  Perhaps this debug should be
969            present all the time? */
970
971 #if 0
972         DEBUG(10, ("lp_string(%s)\n", s));
973 #endif
974         if (!s) {
975                 return NULL;
976         }
977
978         ret = talloc_sub_basic(ctx,
979                         get_current_username(),
980                         current_user_info.domain,
981                         s);
982         if (trim_char(ret, '\"', '\"')) {
983                 if (strchr(ret,'\"') != NULL) {
984                         TALLOC_FREE(ret);
985                         ret = talloc_sub_basic(ctx,
986                                         get_current_username(),
987                                         current_user_info.domain,
988                                         s);
989                 }
990         }
991         return ret;
992 }
993
994 /*
995    In this section all the functions that are used to access the
996    parameters from the rest of the program are defined
997 */
998
999 #define FN_GLOBAL_STRING(fn_name,ptr) \
1000 char *lp_ ## fn_name(TALLOC_CTX *ctx) {return(lp_string((ctx), *(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : ""));}
1001 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1002  const char *lp_ ## fn_name(void) {return(*(const char * const *)(&Globals.ptr) ? *(const char * const *)(&Globals.ptr) : "");}
1003 #define FN_GLOBAL_LIST(fn_name,ptr) \
1004  const char **lp_ ## fn_name(void) {return(*(const char ***)(&Globals.ptr));}
1005 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1006  bool lp_ ## fn_name(void) {return(*(bool *)(&Globals.ptr));}
1007 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1008  char lp_ ## fn_name(void) {return(*(char *)(&Globals.ptr));}
1009 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1010  int lp_ ## fn_name(void) {return(*(int *)(&Globals.ptr));}
1011
1012 #define FN_LOCAL_STRING(fn_name,val) \
1013 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));}
1014 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1015  const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1016 #define FN_LOCAL_LIST(fn_name,val) \
1017  const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1018 #define FN_LOCAL_BOOL(fn_name,val) \
1019  bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1020 #define FN_LOCAL_INTEGER(fn_name,val) \
1021  int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1022
1023 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1024  bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1025 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1026  int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1027 #define FN_LOCAL_PARM_CHAR(fn_name,val) \
1028  char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1029
1030 int lp_winbind_max_domain_connections(void)
1031 {
1032         if (lp_winbind_offline_logon() &&
1033             lp__winbind_max_domain_connections() > 1) {
1034                 DEBUG(1, ("offline logons active, restricting max domain "
1035                           "connections to 1\n"));
1036                 return 1;
1037         }
1038         return MAX(1, lp__winbind_max_domain_connections());
1039 }
1040
1041 /* These functions remain in source3/param for now */
1042
1043 #include "lib/param/param_functions.c"
1044
1045 FN_LOCAL_STRING(servicename, szService)
1046 FN_LOCAL_CONST_STRING(const_servicename, szService)
1047
1048 /* These functions cannot be auto-generated */
1049 FN_LOCAL_BOOL(autoloaded, autoloaded)
1050 FN_GLOBAL_CONST_STRING(dnsdomain, dnsdomain)
1051
1052 /* local prototypes */
1053
1054 static int map_parameter_canonical(const char *pszParmName, bool *inverse);
1055 static const char *get_boolean(bool bool_value);
1056 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
1057                          void *userdata);
1058 static bool hash_a_service(const char *name, int number);
1059 static void free_service_byindex(int iService);
1060 static void show_parameter(int parmIndex);
1061 static bool is_synonym_of(int parm1, int parm2, bool *inverse);
1062 static bool lp_parameter_value_is_valid(const char *parm_name, const char *val);
1063
1064 /*
1065  * This is a helper function for parametrical options support.  It returns a
1066  * pointer to parametrical option value if it exists or NULL otherwise. Actual
1067  * parametrical functions are quite simple
1068  */
1069 static struct parmlist_entry *get_parametrics(int snum, const char *type,
1070                                                 const char *option)
1071 {
1072         if (snum >= iNumServices) return NULL;
1073
1074         if (snum < 0) {
1075                 return get_parametric_helper(NULL, type, option, Globals.param_opt);
1076         } else {
1077                 return get_parametric_helper(ServicePtrs[snum],
1078                                              type, option, Globals.param_opt);
1079         }
1080 }
1081
1082 static void discard_whitespace(char *str)
1083 {
1084         size_t len = strlen(str);
1085         size_t i = 0;
1086
1087         while (i < len) {
1088                 if (isspace(str[i])) {
1089                         memmove(&str[i], &str[i+1], len-i);
1090                         len -= 1;
1091                         continue;
1092                 }
1093                 i += 1;
1094         }
1095 }
1096
1097 /**
1098  * @brief Go through all global parametric parameters
1099  *
1100  * @param regex_str     A regular expression to scan param for
1101  * @param max_matches   Max number of submatches the regexp expects
1102  * @param cb            Function to call on match. Should return true
1103  *                      when it wants wi_scan_global_parametrics to stop
1104  *                      scanning
1105  * @param private_data  Anonymous pointer passed to cb
1106  *
1107  * @return              0: success, regcomp/regexec return value on error.
1108  *                      See "man regexec" for possible errors
1109  */
1110
1111 int lp_wi_scan_global_parametrics(
1112         const char *regex_str, size_t max_matches,
1113         bool (*cb)(const char *string, regmatch_t matches[],
1114                    void *private_data),
1115         void *private_data)
1116 {
1117         struct parmlist_entry *data;
1118         regex_t regex;
1119         int ret;
1120
1121         ret = regcomp(&regex, regex_str, REG_ICASE);
1122         if (ret != 0) {
1123                 return ret;
1124         }
1125
1126         for (data = Globals.param_opt; data != NULL; data = data->next) {
1127                 size_t keylen = strlen(data->key);
1128                 char key[keylen+1];
1129                 regmatch_t matches[max_matches];
1130                 bool stop;
1131
1132                 memcpy(key, data->key, sizeof(key));
1133                 discard_whitespace(key);
1134
1135                 ret = regexec(&regex, key, max_matches, matches, 0);
1136                 if (ret == REG_NOMATCH) {
1137                         continue;
1138                 }
1139                 if (ret != 0) {
1140                         goto fail;
1141                 }
1142
1143                 stop = cb(key, matches, private_data);
1144                 if (stop) {
1145                         break;
1146                 }
1147         }
1148
1149         ret = 0;
1150 fail:
1151         regfree(&regex);
1152         return ret;
1153 }
1154
1155
1156 #define MISSING_PARAMETER(name) \
1157     DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
1158
1159 /*******************************************************************
1160 convenience routine to return enum parameters.
1161 ********************************************************************/
1162 static int lp_enum(const char *s,const struct enum_list *_enum)
1163 {
1164         int i;
1165
1166         if (!s || !*s || !_enum) {
1167                 MISSING_PARAMETER(lp_enum);
1168                 return (-1);
1169         }
1170
1171         for (i=0; _enum[i].name; i++) {
1172                 if (strequal(_enum[i].name,s))
1173                         return _enum[i].value;
1174         }
1175
1176         DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
1177         return (-1);
1178 }
1179
1180 #undef MISSING_PARAMETER
1181
1182 /* Return parametric option from a given service. Type is a part of option before ':' */
1183 /* Parametric option has following syntax: 'Type: option = value' */
1184 char *lp_parm_talloc_string(TALLOC_CTX *ctx, int snum, const char *type, const char *option, const char *def)
1185 {
1186         struct parmlist_entry *data = get_parametrics(snum, type, option);
1187
1188         if (data == NULL||data->value==NULL) {
1189                 if (def) {
1190                         return lp_string(ctx, def);
1191                 } else {
1192                         return NULL;
1193                 }
1194         }
1195
1196         return lp_string(ctx, data->value);
1197 }
1198
1199 /* Return parametric option from a given service. Type is a part of option before ':' */
1200 /* Parametric option has following syntax: 'Type: option = value' */
1201 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
1202 {
1203         struct parmlist_entry *data = get_parametrics(snum, type, option);
1204
1205         if (data == NULL||data->value==NULL)
1206                 return def;
1207
1208         return data->value;
1209 }
1210
1211
1212 /* Return parametric option from a given service. Type is a part of option before ':' */
1213 /* Parametric option has following syntax: 'Type: option = value' */
1214
1215 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
1216 {
1217         struct parmlist_entry *data = get_parametrics(snum, type, option);
1218
1219         if (data == NULL||data->value==NULL)
1220                 return (const char **)def;
1221
1222         if (data->list==NULL) {
1223                 data->list = str_list_make_v3(NULL, data->value, NULL);
1224         }
1225
1226         return discard_const_p(const char *, data->list);
1227 }
1228
1229 /* Return parametric option from a given service. Type is a part of option before ':' */
1230 /* Parametric option has following syntax: 'Type: option = value' */
1231
1232 int lp_parm_int(int snum, const char *type, const char *option, int def)
1233 {
1234         struct parmlist_entry *data = get_parametrics(snum, type, option);
1235
1236         if (data && data->value && *data->value)
1237                 return lp_int(data->value);
1238
1239         return def;
1240 }
1241
1242 /* Return parametric option from a given service. Type is a part of option before ':' */
1243 /* Parametric option has following syntax: 'Type: option = value' */
1244
1245 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
1246 {
1247         struct parmlist_entry *data = get_parametrics(snum, type, option);
1248
1249         if (data && data->value && *data->value)
1250                 return lp_ulong(data->value);
1251
1252         return def;
1253 }
1254
1255 /* Return parametric option from a given service. Type is a part of option before ':' */
1256 /* Parametric option has following syntax: 'Type: option = value' */
1257
1258 unsigned long long lp_parm_ulonglong(int snum, const char *type,
1259                                      const char *option, unsigned long long def)
1260 {
1261         struct parmlist_entry *data = get_parametrics(snum, type, option);
1262
1263         if (data && data->value && *data->value) {
1264                 return lp_ulonglong(data->value);
1265         }
1266
1267         return def;
1268 }
1269
1270 /* Return parametric option from a given service. Type is a part of option
1271  * before ':' */
1272 /* Parametric option has following syntax: 'Type: option = value' */
1273
1274 bool lp_parm_bool(int snum, const char *type, const char *option, bool def)
1275 {
1276         struct parmlist_entry *data = get_parametrics(snum, type, option);
1277
1278         if (data && data->value && *data->value)
1279                 return lp_bool(data->value);
1280
1281         return def;
1282 }
1283
1284 /* Return parametric option from a given service. Type is a part of option before ':' */
1285 /* Parametric option has following syntax: 'Type: option = value' */
1286
1287 int lp_parm_enum(int snum, const char *type, const char *option,
1288                  const struct enum_list *_enum, int def)
1289 {
1290         struct parmlist_entry *data = get_parametrics(snum, type, option);
1291
1292         if (data && data->value && *data->value && _enum)
1293                 return lp_enum(data->value, _enum);
1294
1295         return def;
1296 }
1297
1298 /**
1299  * free a param_opts structure.
1300  * param_opts handling should be moved to talloc;
1301  * then this whole functions reduces to a TALLOC_FREE().
1302  */
1303
1304 static void free_param_opts(struct parmlist_entry **popts)
1305 {
1306         struct parmlist_entry *opt, *next_opt;
1307
1308         if (*popts != NULL) {
1309                 DEBUG(5, ("Freeing parametrics:\n"));
1310         }
1311         opt = *popts;
1312         while (opt != NULL) {
1313                 lpcfg_string_free(&opt->key);
1314                 lpcfg_string_free(&opt->value);
1315                 TALLOC_FREE(opt->list);
1316                 next_opt = opt->next;
1317                 TALLOC_FREE(opt);
1318                 opt = next_opt;
1319         }
1320         *popts = NULL;
1321 }
1322
1323 /***************************************************************************
1324  Free the dynamically allocated parts of a service struct.
1325 ***************************************************************************/
1326
1327 static void free_service(struct loadparm_service *pservice)
1328 {
1329         if (!pservice)
1330                 return;
1331
1332         if (pservice->szService)
1333                 DEBUG(5, ("free_service: Freeing service %s\n",
1334                        pservice->szService));
1335
1336         free_parameters(pservice);
1337
1338         lpcfg_string_free(&pservice->szService);
1339         TALLOC_FREE(pservice->copymap);
1340
1341         free_param_opts(&pservice->param_opt);
1342
1343         ZERO_STRUCTP(pservice);
1344 }
1345
1346
1347 /***************************************************************************
1348  remove a service indexed in the ServicePtrs array from the ServiceHash
1349  and free the dynamically allocated parts
1350 ***************************************************************************/
1351
1352 static void free_service_byindex(int idx)
1353 {
1354         if ( !LP_SNUM_OK(idx) ) 
1355                 return;
1356
1357         ServicePtrs[idx]->valid = false;
1358
1359         /* we have to cleanup the hash record */
1360
1361         if (ServicePtrs[idx]->szService) {
1362                 char *canon_name = canonicalize_servicename(
1363                         talloc_tos(),
1364                         ServicePtrs[idx]->szService );
1365
1366                 dbwrap_delete_bystring(ServiceHash, canon_name );
1367                 TALLOC_FREE(canon_name);
1368         }
1369
1370         free_service(ServicePtrs[idx]);
1371         TALLOC_FREE(ServicePtrs[idx]);
1372 }
1373
1374 /***************************************************************************
1375  Add a new service to the services array initialising it with the given 
1376  service. 
1377 ***************************************************************************/
1378
1379 static int add_a_service(const struct loadparm_service *pservice, const char *name)
1380 {
1381         int i;
1382         struct loadparm_service **tsp = NULL;
1383
1384         /* it might already exist */
1385         if (name) {
1386                 i = getservicebyname(name, NULL);
1387                 if (i >= 0) {
1388                         return (i);
1389                 }
1390         }
1391
1392         /* Re use empty slots if any before allocating new one.*/
1393         for (i=0; i < iNumServices; i++) {
1394                 if (ServicePtrs[i] == NULL) {
1395                         break;
1396                 }
1397         }
1398         if (i == iNumServices) {
1399                 /* if not, then create one */
1400                 tsp = talloc_realloc(NULL, ServicePtrs,
1401                                      struct loadparm_service *,
1402                                      iNumServices + 1);
1403                 if (tsp == NULL) {
1404                         DEBUG(0, ("add_a_service: failed to enlarge "
1405                                   "ServicePtrs!\n"));
1406                         return (-1);
1407                 }
1408                 ServicePtrs = tsp;
1409                 iNumServices++;
1410         }
1411         ServicePtrs[i] = talloc_zero(ServicePtrs, struct loadparm_service);
1412         if (!ServicePtrs[i]) {
1413                 DEBUG(0,("add_a_service: out of memory!\n"));
1414                 return (-1);
1415         }
1416
1417         ServicePtrs[i]->valid = true;
1418
1419         copy_service(ServicePtrs[i], pservice, NULL);
1420         if (name)
1421                 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->szService,
1422                                  name);
1423
1424         DEBUG(8,("add_a_service: Creating snum = %d for %s\n", 
1425                 i, ServicePtrs[i]->szService));
1426
1427         if (!hash_a_service(ServicePtrs[i]->szService, i)) {
1428                 return (-1);
1429         }
1430
1431         return (i);
1432 }
1433
1434 /***************************************************************************
1435   Convert a string to uppercase and remove whitespaces.
1436 ***************************************************************************/
1437
1438 char *canonicalize_servicename(TALLOC_CTX *ctx, const char *src)
1439 {
1440         char *result;
1441
1442         if ( !src ) {
1443                 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
1444                 return NULL;
1445         }
1446
1447         result = talloc_strdup(ctx, src);
1448         SMB_ASSERT(result != NULL);
1449
1450         if (!strlower_m(result)) {
1451                 TALLOC_FREE(result);
1452                 return NULL;
1453         }
1454         return result;
1455 }
1456
1457 /***************************************************************************
1458   Add a name/index pair for the services array to the hash table.
1459 ***************************************************************************/
1460
1461 static bool hash_a_service(const char *name, int idx)
1462 {
1463         char *canon_name;
1464
1465         if ( !ServiceHash ) {
1466                 DEBUG(10,("hash_a_service: creating servicehash\n"));
1467                 ServiceHash = db_open_rbt(NULL);
1468                 if ( !ServiceHash ) {
1469                         DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
1470                         return false;
1471                 }
1472         }
1473
1474         DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
1475                 idx, name));
1476
1477         canon_name = canonicalize_servicename(talloc_tos(), name );
1478
1479         dbwrap_store_bystring(ServiceHash, canon_name,
1480                               make_tdb_data((uint8_t *)&idx, sizeof(idx)),
1481                               TDB_REPLACE);
1482
1483         TALLOC_FREE(canon_name);
1484
1485         return true;
1486 }
1487
1488 /***************************************************************************
1489  Add a new home service, with the specified home directory, defaults coming
1490  from service ifrom.
1491 ***************************************************************************/
1492
1493 bool lp_add_home(const char *pszHomename, int iDefaultService,
1494                  const char *user, const char *pszHomedir)
1495 {
1496         int i;
1497
1498         if (pszHomename == NULL || user == NULL || pszHomedir == NULL ||
1499                         pszHomedir[0] == '\0') {
1500                 return false;
1501         }
1502
1503         i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
1504
1505         if (i < 0)
1506                 return false;
1507
1508         if (!(*(ServicePtrs[iDefaultService]->path))
1509             || strequal(ServicePtrs[iDefaultService]->path,
1510                         lp_path(talloc_tos(), GLOBAL_SECTION_SNUM))) {
1511                 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path,
1512                                  pszHomedir);
1513         }
1514
1515         if (!(*(ServicePtrs[i]->comment))) {
1516                 char *comment = talloc_asprintf(talloc_tos(), "Home directory of %s", user);
1517                 if (comment == NULL) {
1518                         return false;
1519                 }
1520                 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment,
1521                                  comment);
1522                 TALLOC_FREE(comment);
1523         }
1524
1525         /* set the browseable flag from the global default */
1526
1527         ServicePtrs[i]->browseable = sDefault.browseable;
1528         ServicePtrs[i]->access_based_share_enum = sDefault.access_based_share_enum;
1529
1530         ServicePtrs[i]->autoloaded = true;
1531
1532         DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename, 
1533                user, ServicePtrs[i]->path ));
1534
1535         return true;
1536 }
1537
1538 /***************************************************************************
1539  Add a new service, based on an old one.
1540 ***************************************************************************/
1541
1542 int lp_add_service(const char *pszService, int iDefaultService)
1543 {
1544         if (iDefaultService < 0) {
1545                 return add_a_service(&sDefault, pszService);
1546         }
1547
1548         return (add_a_service(ServicePtrs[iDefaultService], pszService));
1549 }
1550
1551 /***************************************************************************
1552  Add the IPC service.
1553 ***************************************************************************/
1554
1555 static bool lp_add_ipc(const char *ipc_name, bool guest_ok)
1556 {
1557         char *comment = NULL;
1558         int i = add_a_service(&sDefault, ipc_name);
1559
1560         if (i < 0)
1561                 return false;
1562
1563         comment = talloc_asprintf(talloc_tos(), "IPC Service (%s)",
1564                                   Globals.server_string);
1565         if (comment == NULL) {
1566                 return false;
1567         }
1568
1569         lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path, tmpdir());
1570         lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1571         lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->fstype, "IPC");
1572         ServicePtrs[i]->max_connections = 0;
1573         ServicePtrs[i]->available = true;
1574         ServicePtrs[i]->read_only = true;
1575         ServicePtrs[i]->guest_only = false;
1576         ServicePtrs[i]->administrative_share = true;
1577         ServicePtrs[i]->guest_ok = guest_ok;
1578         ServicePtrs[i]->printable = false;
1579         ServicePtrs[i]->browseable = sDefault.browseable;
1580         ServicePtrs[i]->autoloaded = true;
1581
1582         DEBUG(3, ("adding IPC service\n"));
1583
1584         TALLOC_FREE(comment);
1585         return true;
1586 }
1587
1588 /***************************************************************************
1589  Add a new printer service, with defaults coming from service iFrom.
1590 ***************************************************************************/
1591
1592 bool lp_add_printer(const char *pszPrintername, int iDefaultService)
1593 {
1594         const char *comment = "From Printcap";
1595         int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
1596
1597         if (i < 0)
1598                 return false;
1599
1600         /* note that we do NOT default the availability flag to true - */
1601         /* we take it from the default service passed. This allows all */
1602         /* dynamic printers to be disabled by disabling the [printers] */
1603         /* entry (if/when the 'available' keyword is implemented!).    */
1604
1605         /* the printer name is set to the service name. */
1606         lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->_printername,
1607                          pszPrintername);
1608         lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1609
1610         /* set the browseable flag from the gloabl default */
1611         ServicePtrs[i]->browseable = sDefault.browseable;
1612
1613         /* Printers cannot be read_only. */
1614         ServicePtrs[i]->read_only = false;
1615         /* No oplocks on printer services. */
1616         ServicePtrs[i]->oplocks = false;
1617         /* Printer services must be printable. */
1618         ServicePtrs[i]->printable = true;
1619
1620         DEBUG(3, ("adding printer service %s\n", pszPrintername));
1621
1622         return true;
1623 }
1624
1625
1626 /***************************************************************************
1627  Check whether the given parameter name is valid.
1628  Parametric options (names containing a colon) are considered valid.
1629 ***************************************************************************/
1630
1631 bool lp_parameter_is_valid(const char *pszParmName)
1632 {
1633         return ((lpcfg_map_parameter(pszParmName) != -1) ||
1634                 (strchr(pszParmName, ':') != NULL));
1635 }
1636
1637 /***************************************************************************
1638  Check whether the given name is the name of a global parameter.
1639  Returns true for strings belonging to parameters of class
1640  P_GLOBAL, false for all other strings, also for parametric options
1641  and strings not belonging to any option.
1642 ***************************************************************************/
1643
1644 bool lp_parameter_is_global(const char *pszParmName)
1645 {
1646         int num = lpcfg_map_parameter(pszParmName);
1647
1648         if (num >= 0) {
1649                 return (parm_table[num].p_class == P_GLOBAL);
1650         }
1651
1652         return false;
1653 }
1654
1655 /**************************************************************************
1656  Determine the canonical name for a parameter.
1657  Indicate when it is an inverse (boolean) synonym instead of a
1658  "usual" synonym.
1659 **************************************************************************/
1660
1661 bool lp_canonicalize_parameter(const char *parm_name, const char **canon_parm,
1662                                bool *inverse)
1663 {
1664         int num;
1665
1666         if (!lp_parameter_is_valid(parm_name)) {
1667                 *canon_parm = NULL;
1668                 return false;
1669         }
1670
1671         num = map_parameter_canonical(parm_name, inverse);
1672         if (num < 0) {
1673                 /* parametric option */
1674                 *canon_parm = parm_name;
1675         } else {
1676                 *canon_parm = parm_table[num].label;
1677         }
1678
1679         return true;
1680
1681 }
1682
1683 /**************************************************************************
1684  Determine the canonical name for a parameter.
1685  Turn the value given into the inverse boolean expression when
1686  the synonym is an invers boolean synonym.
1687
1688  Return true if
1689  - parm_name is a valid parameter name and
1690  - val is a valid value for this parameter and
1691  - in case the parameter is an inverse boolean synonym, if the val
1692    string could successfully be converted to the reverse bool.
1693  Return false in all other cases.
1694 **************************************************************************/
1695
1696 bool lp_canonicalize_parameter_with_value(const char *parm_name,
1697                                           const char *val,
1698                                           const char **canon_parm,
1699                                           const char **canon_val)
1700 {
1701         int num;
1702         bool inverse;
1703         bool ret;
1704
1705         if (!lp_parameter_is_valid(parm_name)) {
1706                 *canon_parm = NULL;
1707                 *canon_val = NULL;
1708                 return false;
1709         }
1710
1711         num = map_parameter_canonical(parm_name, &inverse);
1712         if (num < 0) {
1713                 /* parametric option */
1714                 *canon_parm = parm_name;
1715                 *canon_val = val;
1716                 return true;
1717         }
1718
1719         *canon_parm = parm_table[num].label;
1720         if (inverse) {
1721                 if (!lp_invert_boolean(val, canon_val)) {
1722                         *canon_val = NULL;
1723                         return false;
1724                 }
1725         } else {
1726                 *canon_val = val;
1727         }
1728
1729         ret = lp_parameter_value_is_valid(*canon_parm, *canon_val);
1730
1731         return ret;
1732 }
1733
1734 /***************************************************************************
1735  Map a parameter's string representation to the index of the canonical
1736  form of the parameter (it might be a synonym).
1737  Returns -1 if the parameter string is not recognised.
1738 ***************************************************************************/
1739
1740 static int map_parameter_canonical(const char *pszParmName, bool *inverse)
1741 {
1742         int parm_num, canon_num;
1743         bool loc_inverse = false;
1744
1745         parm_num = lpcfg_map_parameter(pszParmName);
1746         if ((parm_num < 0) || !(parm_table[parm_num].flags & FLAG_SYNONYM)) {
1747                 /* invalid, parametric or no canidate for synonyms ... */
1748                 goto done;
1749         }
1750
1751         for (canon_num = 0; parm_table[canon_num].label; canon_num++) {
1752                 if (is_synonym_of(parm_num, canon_num, &loc_inverse)) {
1753                         parm_num = canon_num;
1754                         goto done;
1755                 }
1756         }
1757
1758 done:
1759         if (inverse != NULL) {
1760                 *inverse = loc_inverse;
1761         }
1762         return parm_num;
1763 }
1764
1765 /***************************************************************************
1766  return true if parameter number parm1 is a synonym of parameter
1767  number parm2 (parm2 being the principal name).
1768  set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
1769  false otherwise.
1770 ***************************************************************************/
1771
1772 static bool is_synonym_of(int parm1, int parm2, bool *inverse)
1773 {
1774         if ((parm_table[parm1].offset == parm_table[parm2].offset) &&
1775             (parm_table[parm1].p_class == parm_table[parm2].p_class) &&
1776             (parm_table[parm1].flags & FLAG_SYNONYM) &&
1777             !(parm_table[parm2].flags & FLAG_SYNONYM))
1778         {
1779                 if (inverse != NULL) {
1780                         if ((parm_table[parm1].type == P_BOOLREV) &&
1781                             (parm_table[parm2].type == P_BOOL))
1782                         {
1783                                 *inverse = true;
1784                         } else {
1785                                 *inverse = false;
1786                         }
1787                 }
1788                 return true;
1789         }
1790         return false;
1791 }
1792
1793 /***************************************************************************
1794  Show one parameter's name, type, [values,] and flags.
1795  (helper functions for show_parameter_list)
1796 ***************************************************************************/
1797
1798 static void show_parameter(int parmIndex)
1799 {
1800         int enumIndex, flagIndex;
1801         int parmIndex2;
1802         bool hadFlag;
1803         bool hadSyn;
1804         bool inverse;
1805         const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
1806                 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
1807                 "P_ENUM", "P_BYTES", "P_CMDLIST" };
1808         unsigned flags[] = { FLAG_DEPRECATED, FLAG_SYNONYM };
1809         const char *flag_names[] = { "FLAG_DEPRECATED", "FLAG_SYNONYM", NULL};
1810
1811         printf("%s=%s", parm_table[parmIndex].label,
1812                type[parm_table[parmIndex].type]);
1813         if (parm_table[parmIndex].type == P_ENUM) {
1814                 printf(",");
1815                 for (enumIndex=0;
1816                      parm_table[parmIndex].enum_list[enumIndex].name;
1817                      enumIndex++)
1818                 {
1819                         printf("%s%s",
1820                                enumIndex ? "|" : "",
1821                                parm_table[parmIndex].enum_list[enumIndex].name);
1822                 }
1823         }
1824         printf(",");
1825         hadFlag = false;
1826         for (flagIndex=0; flag_names[flagIndex]; flagIndex++) {
1827                 if (parm_table[parmIndex].flags & flags[flagIndex]) {
1828                         printf("%s%s",
1829                                 hadFlag ? "|" : "",
1830                                 flag_names[flagIndex]);
1831                         hadFlag = true;
1832                 }
1833         }
1834
1835         /* output synonyms */
1836         hadSyn = false;
1837         for (parmIndex2=0; parm_table[parmIndex2].label; parmIndex2++) {
1838                 if (is_synonym_of(parmIndex, parmIndex2, &inverse)) {
1839                         printf(" (%ssynonym of %s)", inverse ? "inverse " : "",
1840                                parm_table[parmIndex2].label);
1841                 } else if (is_synonym_of(parmIndex2, parmIndex, &inverse)) {
1842                         if (!hadSyn) {
1843                                 printf(" (synonyms: ");
1844                                 hadSyn = true;
1845                         } else {
1846                                 printf(", ");
1847                         }
1848                         printf("%s%s", parm_table[parmIndex2].label,
1849                                inverse ? "[i]" : "");
1850                 }
1851         }
1852         if (hadSyn) {
1853                 printf(")");
1854         }
1855
1856         printf("\n");
1857 }
1858
1859 /*
1860  * Check the value for a P_ENUM
1861  */
1862 static bool check_enum_parameter(struct parm_struct *parm, const char *value)
1863 {
1864         int i;
1865
1866         for (i = 0; parm->enum_list[i].name; i++) {
1867                 if (strwicmp(value, parm->enum_list[i].name) == 0) {
1868                         return true;
1869                 }
1870         }
1871         return false;
1872 }
1873
1874 /**************************************************************************
1875  Check whether the given value is valid for the given parameter name.
1876 **************************************************************************/
1877
1878 static bool lp_parameter_value_is_valid(const char *parm_name, const char *val)
1879 {
1880         bool ret = false, tmp_bool;
1881         int num = lpcfg_map_parameter(parm_name), tmp_int;
1882         uint64_t tmp_int64 = 0;
1883         struct parm_struct *parm;
1884
1885         /* parametric options (parameter names containing a colon) cannot
1886            be checked and are therefore considered valid. */
1887         if (strchr(parm_name, ':') != NULL) {
1888                 return true;
1889         }
1890
1891         if (num >= 0) {
1892                 parm = &parm_table[num];
1893                 switch (parm->type) {
1894                         case P_BOOL:
1895                         case P_BOOLREV:
1896                                 ret = set_boolean(val, &tmp_bool);
1897                                 break;
1898
1899                         case P_INTEGER:
1900                                 ret = (sscanf(val, "%d", &tmp_int) == 1);
1901                                 break;
1902
1903                         case P_OCTAL:
1904                                 ret = (sscanf(val, "%o", &tmp_int) == 1);
1905                                 break;
1906
1907                         case P_ENUM:
1908                                 ret = check_enum_parameter(parm, val);
1909                                 break;
1910
1911                         case P_BYTES:
1912                                 if (conv_str_size_error(val, &tmp_int64) &&
1913                                     tmp_int64 <= INT_MAX) {
1914                                         ret = true;
1915                                 }
1916                                 break;
1917
1918                         case P_CHAR:
1919                         case P_LIST:
1920                         case P_STRING:
1921                         case P_USTRING:
1922                         case P_CMDLIST:
1923                                 ret = true;
1924                                 break;
1925                 }
1926         }
1927         return ret;
1928 }
1929
1930 /***************************************************************************
1931  Show all parameter's name, type, [values,] and flags.
1932 ***************************************************************************/
1933
1934 void show_parameter_list(void)
1935 {
1936         int classIndex, parmIndex;
1937         const char *section_names[] = { "local", "global", NULL};
1938
1939         for (classIndex=0; section_names[classIndex]; classIndex++) {
1940                 printf("[%s]\n", section_names[classIndex]);
1941                 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
1942                         if (parm_table[parmIndex].p_class == classIndex) {
1943                                 show_parameter(parmIndex);
1944                         }
1945                 }
1946         }
1947 }
1948
1949 /***************************************************************************
1950  Get the standard string representation of a boolean value ("yes" or "no")
1951 ***************************************************************************/
1952
1953 static const char *get_boolean(bool bool_value)
1954 {
1955         static const char *yes_str = "yes";
1956         static const char *no_str = "no";
1957
1958         return (bool_value ? yes_str : no_str);
1959 }
1960
1961 /***************************************************************************
1962  Provide the string of the negated boolean value associated to the boolean
1963  given as a string. Returns false if the passed string does not correctly
1964  represent a boolean.
1965 ***************************************************************************/
1966
1967 bool lp_invert_boolean(const char *str, const char **inverse_str)
1968 {
1969         bool val;
1970
1971         if (!set_boolean(str, &val)) {
1972                 return false;
1973         }
1974
1975         *inverse_str = get_boolean(!val);
1976         return true;
1977 }
1978
1979 /***************************************************************************
1980  Provide the canonical string representation of a boolean value given
1981  as a string. Return true on success, false if the string given does
1982  not correctly represent a boolean.
1983 ***************************************************************************/
1984
1985 bool lp_canonicalize_boolean(const char *str, const char**canon_str)
1986 {
1987         bool val;
1988
1989         if (!set_boolean(str, &val)) {
1990                 return false;
1991         }
1992
1993         *canon_str = get_boolean(val);
1994         return true;
1995 }
1996
1997 /***************************************************************************
1998 Find a service by name. Otherwise works like get_service.
1999 ***************************************************************************/
2000
2001 int getservicebyname(const char *pszServiceName, struct loadparm_service *pserviceDest)
2002 {
2003         int iService = -1;
2004         char *canon_name;
2005         TDB_DATA data;
2006         NTSTATUS status;
2007
2008         if (ServiceHash == NULL) {
2009                 return -1;
2010         }
2011
2012         canon_name = canonicalize_servicename(talloc_tos(), pszServiceName);
2013
2014         status = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name,
2015                                        &data);
2016
2017         if (NT_STATUS_IS_OK(status) &&
2018             (data.dptr != NULL) &&
2019             (data.dsize == sizeof(iService)))
2020         {
2021                 memcpy(&iService, data.dptr, sizeof(iService));
2022         }
2023
2024         TALLOC_FREE(canon_name);
2025
2026         if ((iService != -1) && (LP_SNUM_OK(iService))
2027             && (pserviceDest != NULL)) {
2028                 copy_service(pserviceDest, ServicePtrs[iService], NULL);
2029         }
2030
2031         return (iService);
2032 }
2033
2034 /* Return a pointer to a service by name.  Unlike getservicebyname, it does not copy the service */
2035 struct loadparm_service *lp_service(const char *pszServiceName)
2036 {
2037         int iService = getservicebyname(pszServiceName, NULL);
2038         if (iService == -1 || !LP_SNUM_OK(iService)) {
2039                 return NULL;
2040         }
2041         return ServicePtrs[iService];
2042 }
2043
2044 struct loadparm_service *lp_servicebynum(int snum)
2045 {
2046         if ((snum == -1) || !LP_SNUM_OK(snum)) {
2047                 return NULL;
2048         }
2049         return ServicePtrs[snum];
2050 }
2051
2052 struct loadparm_service *lp_default_loadparm_service()
2053 {
2054         return &sDefault;
2055 }
2056
2057 static struct smbconf_ctx *lp_smbconf_ctx(void)
2058 {
2059         sbcErr err;
2060         static struct smbconf_ctx *conf_ctx = NULL;
2061
2062         if (conf_ctx == NULL) {
2063                 err = smbconf_init(NULL, &conf_ctx, "registry:");
2064                 if (!SBC_ERROR_IS_OK(err)) {
2065                         DEBUG(1, ("error initializing registry configuration: "
2066                                   "%s\n", sbcErrorString(err)));
2067                         conf_ctx = NULL;
2068                 }
2069         }
2070
2071         return conf_ctx;
2072 }
2073
2074 static bool process_smbconf_service(struct smbconf_service *service)
2075 {
2076         uint32_t count;
2077         bool ret;
2078
2079         if (service == NULL) {
2080                 return false;
2081         }
2082
2083         ret = lp_do_section(service->name, NULL);
2084         if (ret != true) {
2085                 return false;
2086         }
2087         for (count = 0; count < service->num_params; count++) {
2088
2089                 if (!bInGlobalSection && bGlobalOnly) {
2090                         ret = true;
2091                 } else {
2092                         const char *pszParmName = service->param_names[count];
2093                         const char *pszParmValue = service->param_values[count];
2094
2095                         DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2096
2097                         ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2098                                               pszParmName, pszParmValue);
2099                 }
2100
2101                 if (ret != true) {
2102                         return false;
2103                 }
2104         }
2105         if (iServiceIndex >= 0) {
2106                 return lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2107         }
2108         return true;
2109 }
2110
2111 /**
2112  * load a service from registry and activate it
2113  */
2114 bool process_registry_service(const char *service_name)
2115 {
2116         sbcErr err;
2117         struct smbconf_service *service = NULL;
2118         TALLOC_CTX *mem_ctx = talloc_stackframe();
2119         struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2120         bool ret = false;
2121
2122         if (conf_ctx == NULL) {
2123                 goto done;
2124         }
2125
2126         DEBUG(5, ("process_registry_service: service name %s\n", service_name));
2127
2128         if (!smbconf_share_exists(conf_ctx, service_name)) {
2129                 /*
2130                  * Registry does not contain data for this service (yet),
2131                  * but make sure lp_load doesn't return false.
2132                  */
2133                 ret = true;
2134                 goto done;
2135         }
2136
2137         err = smbconf_get_share(conf_ctx, mem_ctx, service_name, &service);
2138         if (!SBC_ERROR_IS_OK(err)) {
2139                 goto done;
2140         }
2141
2142         ret = process_smbconf_service(service);
2143         if (!ret) {
2144                 goto done;
2145         }
2146
2147         /* store the csn */
2148         smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2149
2150 done:
2151         TALLOC_FREE(mem_ctx);
2152         return ret;
2153 }
2154
2155 /*
2156  * process_registry_globals
2157  */
2158 static bool process_registry_globals(void)
2159 {
2160         bool ret;
2161
2162         add_to_file_list(NULL, &file_lists, INCLUDE_REGISTRY_NAME, INCLUDE_REGISTRY_NAME);
2163
2164         if (!bInGlobalSection && bGlobalOnly) {
2165                 ret = true;
2166         } else {
2167                 const char *pszParmName = "registry shares";
2168                 const char *pszParmValue = "yes";
2169
2170                 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2171
2172                 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2173                                       pszParmName, pszParmValue);
2174         }
2175
2176         if (!ret) {
2177                 return ret;
2178         }
2179
2180         return process_registry_service(GLOBAL_NAME);
2181 }
2182
2183 bool process_registry_shares(void)
2184 {
2185         sbcErr err;
2186         uint32_t count;
2187         struct smbconf_service **service = NULL;
2188         uint32_t num_shares = 0;
2189         TALLOC_CTX *mem_ctx = talloc_stackframe();
2190         struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2191         bool ret = false;
2192
2193         if (conf_ctx == NULL) {
2194                 goto done;
2195         }
2196
2197         err = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &service);
2198         if (!SBC_ERROR_IS_OK(err)) {
2199                 goto done;
2200         }
2201
2202         ret = true;
2203
2204         for (count = 0; count < num_shares; count++) {
2205                 if (strequal(service[count]->name, GLOBAL_NAME)) {
2206                         continue;
2207                 }
2208                 ret = process_smbconf_service(service[count]);
2209                 if (!ret) {
2210                         goto done;
2211                 }
2212         }
2213
2214         /* store the csn */
2215         smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2216
2217 done:
2218         TALLOC_FREE(mem_ctx);
2219         return ret;
2220 }
2221
2222 /**
2223  * reload those shares from registry that are already
2224  * activated in the services array.
2225  */
2226 static bool reload_registry_shares(void)
2227 {
2228         int i;
2229         bool ret = true;
2230
2231         for (i = 0; i < iNumServices; i++) {
2232                 if (!VALID(i)) {
2233                         continue;
2234                 }
2235
2236                 if (ServicePtrs[i]->usershare == USERSHARE_VALID) {
2237                         continue;
2238                 }
2239
2240                 ret = process_registry_service(ServicePtrs[i]->szService);
2241                 if (!ret) {
2242                         goto done;
2243                 }
2244         }
2245
2246 done:
2247         return ret;
2248 }
2249
2250
2251 #define MAX_INCLUDE_DEPTH 100
2252
2253 static uint8_t include_depth;
2254
2255 /**
2256  * Free the file lists
2257  */
2258 static void free_file_list(void)
2259 {
2260         struct file_lists *f;
2261         struct file_lists *next;
2262
2263         f = file_lists;
2264         while( f ) {
2265                 next = f->next;
2266                 TALLOC_FREE( f );
2267                 f = next;
2268         }
2269         file_lists = NULL;
2270 }
2271
2272
2273 /**
2274  * Utility function for outsiders to check if we're running on registry.
2275  */
2276 bool lp_config_backend_is_registry(void)
2277 {
2278         return (lp_config_backend() == CONFIG_BACKEND_REGISTRY);
2279 }
2280
2281 /**
2282  * Utility function to check if the config backend is FILE.
2283  */
2284 bool lp_config_backend_is_file(void)
2285 {
2286         return (lp_config_backend() == CONFIG_BACKEND_FILE);
2287 }
2288
2289 /*******************************************************************
2290  Check if a config file has changed date.
2291 ********************************************************************/
2292
2293 bool lp_file_list_changed(void)
2294 {
2295         struct file_lists *f = file_lists;
2296
2297         DEBUG(6, ("lp_file_list_changed()\n"));
2298
2299         while (f) {
2300                 if (strequal(f->name, INCLUDE_REGISTRY_NAME)) {
2301                         struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2302
2303                         if (conf_ctx == NULL) {
2304                                 return false;
2305                         }
2306                         if (smbconf_changed(conf_ctx, &conf_last_csn, NULL,
2307                                             NULL))
2308                         {
2309                                 DEBUGADD(6, ("registry config changed\n"));
2310                                 return true;
2311                         }
2312                 } else {
2313                         time_t mod_time;
2314                         char *n2 = NULL;
2315
2316                         n2 = talloc_sub_basic(talloc_tos(),
2317                                               get_current_username(),
2318                                               current_user_info.domain,
2319                                               f->name);
2320                         if (!n2) {
2321                                 return false;
2322                         }
2323                         DEBUGADD(6, ("file %s -> %s  last mod_time: %s\n",
2324                                      f->name, n2, ctime(&f->modtime)));
2325
2326                         mod_time = file_modtime(n2);
2327
2328                         if (mod_time &&
2329                             ((f->modtime != mod_time) ||
2330                              (f->subfname == NULL) ||
2331                              (strcmp(n2, f->subfname) != 0)))
2332                         {
2333                                 DEBUGADD(6,
2334                                          ("file %s modified: %s\n", n2,
2335                                           ctime(&mod_time)));
2336                                 f->modtime = mod_time;
2337                                 TALLOC_FREE(f->subfname);
2338                                 f->subfname = talloc_strdup(f, n2);
2339                                 if (f->subfname == NULL) {
2340                                         smb_panic("talloc_strdup failed");
2341                                 }
2342                                 TALLOC_FREE(n2);
2343                                 return true;
2344                         }
2345                         TALLOC_FREE(n2);
2346                 }
2347                 f = f->next;
2348         }
2349         return false;
2350 }
2351
2352
2353 /**
2354  * Initialize iconv conversion descriptors.
2355  *
2356  * This is called the first time it is needed, and also called again
2357  * every time the configuration is reloaded, because the charset or
2358  * codepage might have changed.
2359  **/
2360 static void init_iconv(void)
2361 {
2362         global_iconv_handle = smb_iconv_handle_reinit(NULL, lp_dos_charset(),
2363                                                       lp_unix_charset(),
2364                                                       true, global_iconv_handle);
2365 }
2366
2367 /***************************************************************************
2368  Handle the include operation.
2369 ***************************************************************************/
2370 static bool bAllowIncludeRegistry = true;
2371
2372 bool lp_include(struct loadparm_context *lp_ctx, struct loadparm_service *service,
2373                 const char *pszParmValue, char **ptr)
2374 {
2375         char *fname;
2376
2377         if (include_depth >= MAX_INCLUDE_DEPTH) {
2378                 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
2379                           include_depth));
2380                 return false;
2381         }
2382
2383         if (strequal(pszParmValue, INCLUDE_REGISTRY_NAME)) {
2384                 if (!bAllowIncludeRegistry) {
2385                         return true;
2386                 }
2387                 if (lp_ctx->bInGlobalSection) {
2388                         bool ret;
2389                         include_depth++;
2390                         ret = process_registry_globals();
2391                         include_depth--;
2392                         return ret;
2393                 } else {
2394                         DEBUG(1, ("\"include = registry\" only effective "
2395                                   "in %s section\n", GLOBAL_NAME));
2396                         return false;
2397                 }
2398         }
2399
2400         fname = talloc_sub_basic(talloc_tos(), get_current_username(),
2401                                  current_user_info.domain,
2402                                  pszParmValue);
2403
2404         add_to_file_list(NULL, &file_lists, pszParmValue, fname);
2405
2406         if (service == NULL) {
2407                 lpcfg_string_set(Globals.ctx, ptr, fname);
2408         } else {
2409                 lpcfg_string_set(service, ptr, fname);
2410         }
2411
2412         if (file_exist(fname)) {
2413                 bool ret;
2414                 include_depth++;
2415                 ret = pm_process(fname, lp_do_section, do_parameter, lp_ctx);
2416                 include_depth--;
2417                 TALLOC_FREE(fname);
2418                 return ret;
2419         }
2420
2421         DEBUG(2, ("Can't find include file %s\n", fname));
2422         TALLOC_FREE(fname);
2423         return true;
2424 }
2425
2426 bool lp_idmap_range(const char *domain_name, uint32_t *low, uint32_t *high)
2427 {
2428         char *config_option = NULL;
2429         const char *range = NULL;
2430         bool ret = false;
2431
2432         SMB_ASSERT(low != NULL);
2433         SMB_ASSERT(high != NULL);
2434
2435         if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2436                 domain_name = "*";
2437         }
2438
2439         config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2440                                         domain_name);
2441         if (config_option == NULL) {
2442                 DEBUG(0, ("out of memory\n"));
2443                 return false;
2444         }
2445
2446         range = lp_parm_const_string(-1, config_option, "range", NULL);
2447         if (range == NULL) {
2448                 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name));
2449                 goto done;
2450         }
2451
2452         if (sscanf(range, "%u - %u", low, high) != 2) {
2453                 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2454                           range, domain_name));
2455                 goto done;
2456         }
2457
2458         ret = true;
2459
2460 done:
2461         talloc_free(config_option);
2462         return ret;
2463
2464 }
2465
2466 bool lp_idmap_default_range(uint32_t *low, uint32_t *high)
2467 {
2468         return lp_idmap_range("*", low, high);
2469 }
2470
2471 const char *lp_idmap_backend(const char *domain_name)
2472 {
2473         char *config_option = NULL;
2474         const char *backend = NULL;
2475
2476         if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2477                 domain_name = "*";
2478         }
2479
2480         config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2481                                         domain_name);
2482         if (config_option == NULL) {
2483                 DEBUG(0, ("out of memory\n"));
2484                 return false;
2485         }
2486
2487         backend = lp_parm_const_string(-1, config_option, "backend", NULL);
2488         if (backend == NULL) {
2489                 DEBUG(1, ("idmap backend not specified for domain '%s'\n", domain_name));
2490                 goto done;
2491         }
2492
2493 done:
2494         talloc_free(config_option);
2495         return backend;
2496 }
2497
2498 const char *lp_idmap_default_backend(void)
2499 {
2500         return lp_idmap_backend("*");
2501 }
2502
2503 /***************************************************************************
2504  Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2505 ***************************************************************************/
2506
2507 static const char *append_ldap_suffix(TALLOC_CTX *ctx, const char *str )
2508 {
2509         const char *suffix_string;
2510
2511         suffix_string = talloc_asprintf(ctx, "%s,%s", str,
2512                                         Globals.ldap_suffix );
2513         if ( !suffix_string ) {
2514                 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2515                 return "";
2516         }
2517
2518         return suffix_string;
2519 }
2520
2521 const char *lp_ldap_machine_suffix(TALLOC_CTX *ctx)
2522 {
2523         if (Globals._ldap_machine_suffix[0])
2524                 return append_ldap_suffix(ctx, Globals._ldap_machine_suffix);
2525
2526         return lp_string(ctx, Globals.ldap_suffix);
2527 }
2528
2529 const char *lp_ldap_user_suffix(TALLOC_CTX *ctx)
2530 {
2531         if (Globals._ldap_user_suffix[0])
2532                 return append_ldap_suffix(ctx, Globals._ldap_user_suffix);
2533
2534         return lp_string(ctx, Globals.ldap_suffix);
2535 }
2536
2537 const char *lp_ldap_group_suffix(TALLOC_CTX *ctx)
2538 {
2539         if (Globals._ldap_group_suffix[0])
2540                 return append_ldap_suffix(ctx, Globals._ldap_group_suffix);
2541
2542         return lp_string(ctx, Globals.ldap_suffix);
2543 }
2544
2545 const char *lp_ldap_idmap_suffix(TALLOC_CTX *ctx)
2546 {
2547         if (Globals._ldap_idmap_suffix[0])
2548                 return append_ldap_suffix(ctx, Globals._ldap_idmap_suffix);
2549
2550         return lp_string(ctx, Globals.ldap_suffix);
2551 }
2552
2553 /**
2554   return the parameter pointer for a parameter
2555 */
2556 void *lp_parm_ptr(struct loadparm_service *service, struct parm_struct *parm)
2557 {
2558         if (service == NULL) {
2559                 if (parm->p_class == P_LOCAL)
2560                         return (void *)(((char *)&sDefault)+parm->offset);
2561                 else if (parm->p_class == P_GLOBAL)
2562                         return (void *)(((char *)&Globals)+parm->offset);
2563                 else return NULL;
2564         } else {
2565                 return (void *)(((char *)service) + parm->offset);
2566         }
2567 }
2568
2569 /***************************************************************************
2570  Process a parameter for a particular service number. If snum < 0
2571  then assume we are in the globals.
2572 ***************************************************************************/
2573
2574 bool lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
2575 {
2576         TALLOC_CTX *frame = talloc_stackframe();
2577         struct loadparm_context *lp_ctx;
2578         bool ok;
2579
2580         lp_ctx = setup_lp_context(frame);
2581         if (lp_ctx == NULL) {
2582                 TALLOC_FREE(frame);
2583                 return false;
2584         }
2585
2586         if (snum < 0) {
2587                 ok = lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue);
2588         } else {
2589                 ok = lpcfg_do_service_parameter(lp_ctx, ServicePtrs[snum],
2590                                                 pszParmName, pszParmValue);
2591         }
2592
2593         TALLOC_FREE(frame);
2594
2595         return ok;
2596 }
2597
2598 /***************************************************************************
2599 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
2600 FLAG_CMDLINE won't be overridden by loads from smb.conf.
2601 ***************************************************************************/
2602
2603 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue)
2604 {
2605         int parmnum, i;
2606         parmnum = lpcfg_map_parameter(pszParmName);
2607         if (parmnum >= 0) {
2608                 flags_list[parmnum] &= ~FLAG_CMDLINE;
2609                 if (!lp_do_parameter(-1, pszParmName, pszParmValue)) {
2610                         return false;
2611                 }
2612                 flags_list[parmnum] |= FLAG_CMDLINE;
2613
2614                 /* we have to also set FLAG_CMDLINE on aliases.  Aliases must
2615                  * be grouped in the table, so we don't have to search the
2616                  * whole table */
2617                 for (i=parmnum-1;
2618                      i>=0 && parm_table[i].offset == parm_table[parmnum].offset
2619                              && parm_table[i].p_class == parm_table[parmnum].p_class;
2620                      i--) {
2621                         flags_list[i] |= FLAG_CMDLINE;
2622                 }
2623                 for (i=parmnum+1;i<num_parameters() && parm_table[i].offset == parm_table[parmnum].offset
2624                              && parm_table[i].p_class == parm_table[parmnum].p_class;i++) {
2625                         flags_list[i] |= FLAG_CMDLINE;
2626                 }
2627
2628                 return true;
2629         }
2630
2631         /* it might be parametric */
2632         if (strchr(pszParmName, ':') != NULL) {
2633                 set_param_opt(NULL, &Globals.param_opt, pszParmName, pszParmValue, FLAG_CMDLINE);
2634                 return true;
2635         }
2636
2637         DEBUG(0, ("Ignoring unknown parameter \"%s\"\n",  pszParmName));
2638         return false;
2639 }
2640
2641 bool lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
2642 {
2643         bool ret;
2644         TALLOC_CTX *frame = talloc_stackframe();
2645         struct loadparm_context *lp_ctx;
2646
2647         lp_ctx = setup_lp_context(frame);
2648         if (lp_ctx == NULL) {
2649                 TALLOC_FREE(frame);
2650                 return false;
2651         }
2652
2653         ret = lpcfg_set_cmdline(lp_ctx, pszParmName, pszParmValue);
2654
2655         TALLOC_FREE(frame);
2656         return ret;
2657 }
2658
2659 /***************************************************************************
2660  Process a parameter.
2661 ***************************************************************************/
2662
2663 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
2664                          void *userdata)
2665 {
2666         if (!bInGlobalSection && bGlobalOnly)
2667                 return true;
2668
2669         DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2670
2671         if (bInGlobalSection) {
2672                 return lpcfg_do_global_parameter(userdata, pszParmName, pszParmValue);
2673         } else {
2674                 return lpcfg_do_service_parameter(userdata, ServicePtrs[iServiceIndex],
2675                                                   pszParmName, pszParmValue);
2676         }
2677 }
2678
2679 /***************************************************************************
2680  Initialize any local variables in the sDefault table, after parsing a
2681  [globals] section.
2682 ***************************************************************************/
2683
2684 static void init_locals(void)
2685 {
2686         /*
2687          * We run this check once the [globals] is parsed, to force
2688          * the VFS objects and other per-share settings we need for
2689          * the standard way a AD DC is operated.  We may change these
2690          * as our code evolves, which is why we force these settings.
2691          *
2692          * We can't do this at the end of lp_load_ex(), as by that
2693          * point the services have been loaded and they will already
2694          * have "" as their vfs objects.
2695          */
2696         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
2697                 const char **vfs_objects = lp_vfs_objects(-1);
2698                 if (!vfs_objects || !vfs_objects[0]) {
2699                         if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL)) {
2700                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
2701                         } else if (lp_parm_const_string(-1, "posix", "eadb", NULL)) {
2702                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
2703                         } else {
2704                                 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
2705                         }
2706                 }
2707
2708                 lp_do_parameter(-1, "map hidden", "no");
2709                 lp_do_parameter(-1, "map system", "no");
2710                 lp_do_parameter(-1, "map readonly", "no");
2711                 lp_do_parameter(-1, "map archive", "no");
2712                 lp_do_parameter(-1, "store dos attributes", "yes");
2713         }
2714 }
2715
2716 /***************************************************************************
2717  Process a new section (service). At this stage all sections are services.
2718  Later we'll have special sections that permit server parameters to be set.
2719  Returns true on success, false on failure.
2720 ***************************************************************************/
2721
2722 bool lp_do_section(const char *pszSectionName, void *userdata)
2723 {
2724         struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
2725         bool bRetval;
2726         bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
2727                          (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
2728         bRetval = false;
2729
2730         /* if we were in a global section then do the local inits */
2731         if (bInGlobalSection && !isglobal)
2732                 init_locals();
2733
2734         /* if we've just struck a global section, note the fact. */
2735         bInGlobalSection = isglobal;
2736         if (lp_ctx != NULL) {
2737                 lp_ctx->bInGlobalSection = isglobal;
2738         }
2739
2740         /* check for multiple global sections */
2741         if (bInGlobalSection) {
2742                 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
2743                 return true;
2744         }
2745
2746         if (!bInGlobalSection && bGlobalOnly)
2747                 return true;
2748
2749         /* if we have a current service, tidy it up before moving on */
2750         bRetval = true;
2751
2752         if (iServiceIndex >= 0)
2753                 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2754
2755         /* if all is still well, move to the next record in the services array */
2756         if (bRetval) {
2757                 /* We put this here to avoid an odd message order if messages are */
2758                 /* issued by the post-processing of a previous section. */
2759                 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
2760
2761                 iServiceIndex = add_a_service(&sDefault, pszSectionName);
2762                 if (iServiceIndex < 0) {
2763                         DEBUG(0, ("Failed to add a new service\n"));
2764                         return false;
2765                 }
2766                 /* Clean all parametric options for service */
2767                 /* They will be added during parsing again */
2768                 free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
2769         }
2770
2771         return bRetval;
2772 }
2773
2774 /***************************************************************************
2775  Display the contents of a parameter of a single services record.
2776 ***************************************************************************/
2777
2778 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
2779 {
2780         bool result = false;
2781         struct loadparm_context *lp_ctx;
2782
2783         lp_ctx = setup_lp_context(talloc_tos());
2784         if (lp_ctx == NULL) {
2785                 return false;
2786         }
2787
2788         if (isGlobal) {
2789                 result = lpcfg_dump_a_parameter(lp_ctx, NULL, parm_name, f);
2790         } else {
2791                 result = lpcfg_dump_a_parameter(lp_ctx, ServicePtrs[snum], parm_name, f);
2792         }
2793         TALLOC_FREE(lp_ctx);
2794         return result;
2795 }
2796
2797 #if 0
2798 /***************************************************************************
2799  Display the contents of a single copy structure.
2800 ***************************************************************************/
2801 static void dump_copy_map(bool *pcopymap)
2802 {
2803         int i;
2804         if (!pcopymap)
2805                 return;
2806
2807         printf("\n\tNon-Copied parameters:\n");
2808
2809         for (i = 0; parm_table[i].label; i++)
2810                 if (parm_table[i].p_class == P_LOCAL &&
2811                     parm_table[i].ptr && !pcopymap[i] &&
2812                     (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
2813                 {
2814                         printf("\t\t%s\n", parm_table[i].label);
2815                 }
2816 }
2817 #endif
2818
2819 /***************************************************************************
2820  Return TRUE if the passed service number is within range.
2821 ***************************************************************************/
2822
2823 bool lp_snum_ok(int iService)
2824 {
2825         return (LP_SNUM_OK(iService) && ServicePtrs[iService]->available);
2826 }
2827
2828 /***************************************************************************
2829  Auto-load some home services.
2830 ***************************************************************************/
2831
2832 static void lp_add_auto_services(char *str)
2833 {
2834         char *s;
2835         char *p;
2836         int homes;
2837         char *saveptr;
2838
2839         if (!str)
2840                 return;
2841
2842         s = talloc_strdup(talloc_tos(), str);
2843         if (!s) {
2844                 smb_panic("talloc_strdup failed");
2845                 return;
2846         }
2847
2848         homes = lp_servicenumber(HOMES_NAME);
2849
2850         for (p = strtok_r(s, LIST_SEP, &saveptr); p;
2851              p = strtok_r(NULL, LIST_SEP, &saveptr)) {
2852                 char *home;
2853
2854                 if (lp_servicenumber(p) >= 0)
2855                         continue;
2856
2857                 home = get_user_home_dir(talloc_tos(), p);
2858
2859                 if (home && home[0] && homes >= 0)
2860                         lp_add_home(p, homes, p, home);
2861
2862                 TALLOC_FREE(home);
2863         }
2864         TALLOC_FREE(s);
2865 }
2866
2867 /***************************************************************************
2868  Auto-load one printer.
2869 ***************************************************************************/
2870
2871 void lp_add_one_printer(const char *name, const char *comment,
2872                         const char *location, void *pdata)
2873 {
2874         int printers = lp_servicenumber(PRINTERS_NAME);
2875         int i;
2876
2877         if (lp_servicenumber(name) < 0) {
2878                 lp_add_printer(name, printers);
2879                 if ((i = lp_servicenumber(name)) >= 0) {
2880                         lpcfg_string_set(ServicePtrs[i],
2881                                          &ServicePtrs[i]->comment, comment);
2882                         ServicePtrs[i]->autoloaded = true;
2883                 }
2884         }
2885 }
2886
2887 /***************************************************************************
2888  Have we loaded a services file yet?
2889 ***************************************************************************/
2890
2891 bool lp_loaded(void)
2892 {
2893         return (bLoaded);
2894 }
2895
2896 /***************************************************************************
2897  Unload unused services.
2898 ***************************************************************************/
2899
2900 void lp_killunused(struct smbd_server_connection *sconn,
2901                    bool (*snumused) (struct smbd_server_connection *, int))
2902 {
2903         int i;
2904         for (i = 0; i < iNumServices; i++) {
2905                 if (!VALID(i))
2906                         continue;
2907
2908                 /* don't kill autoloaded or usershare services */
2909                 if ( ServicePtrs[i]->autoloaded ||
2910                                 ServicePtrs[i]->usershare == USERSHARE_VALID) {
2911                         continue;
2912                 }
2913
2914                 if (!snumused || !snumused(sconn, i)) {
2915                         free_service_byindex(i);
2916                 }
2917         }
2918 }
2919
2920 /**
2921  * Kill all except autoloaded and usershare services - convenience wrapper
2922  */
2923 void lp_kill_all_services(void)
2924 {
2925         lp_killunused(NULL, NULL);
2926 }
2927
2928 /***************************************************************************
2929  Unload a service.
2930 ***************************************************************************/
2931
2932 void lp_killservice(int iServiceIn)
2933 {
2934         if (VALID(iServiceIn)) {
2935                 free_service_byindex(iServiceIn);
2936         }
2937 }
2938
2939 /***************************************************************************
2940  Save the curent values of all global and sDefault parameters into the 
2941  defaults union. This allows testparm to show only the
2942  changed (ie. non-default) parameters.
2943 ***************************************************************************/
2944
2945 static void lp_save_defaults(void)
2946 {
2947         int i;
2948         struct parmlist_entry * parm;
2949         for (i = 0; parm_table[i].label; i++) {
2950                 if (!(flags_list[i] & FLAG_CMDLINE)) {
2951                         flags_list[i] |= FLAG_DEFAULT;
2952                 }
2953
2954                 if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
2955                     && parm_table[i].p_class == parm_table[i - 1].p_class)
2956                         continue;
2957                 switch (parm_table[i].type) {
2958                         case P_LIST:
2959                         case P_CMDLIST:
2960                                 parm_table[i].def.lvalue = str_list_copy(
2961                                         NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
2962                                 break;
2963                         case P_STRING:
2964                         case P_USTRING:
2965                                 lpcfg_string_set(
2966                                         Globals.ctx,
2967                                         &parm_table[i].def.svalue,
2968                                         *(char **)lp_parm_ptr(
2969                                                 NULL, &parm_table[i]));
2970                                 if (parm_table[i].def.svalue == NULL) {
2971                                         smb_panic("lpcfg_string_set() failed");
2972                                 }
2973                                 break;
2974                         case P_BOOL:
2975                         case P_BOOLREV:
2976                                 parm_table[i].def.bvalue =
2977                                         *(bool *)lp_parm_ptr(NULL, &parm_table[i]);
2978                                 break;
2979                         case P_CHAR:
2980                                 parm_table[i].def.cvalue =
2981                                         *(char *)lp_parm_ptr(NULL, &parm_table[i]);
2982                                 break;
2983                         case P_INTEGER:
2984                         case P_OCTAL:
2985                         case P_ENUM:
2986                         case P_BYTES:
2987                                 parm_table[i].def.ivalue =
2988                                         *(int *)lp_parm_ptr(NULL, &parm_table[i]);
2989                                 break;
2990                 }
2991         }
2992
2993         for (parm=Globals.param_opt; parm; parm=parm->next) {
2994                 if (!(parm->priority & FLAG_CMDLINE)) {
2995                         parm->priority |= FLAG_DEFAULT;
2996                 }
2997         }
2998
2999         for (parm=sDefault.param_opt; parm; parm=parm->next) {
3000                 if (!(parm->priority & FLAG_CMDLINE)) {
3001                         parm->priority |= FLAG_DEFAULT;
3002                 }
3003         }
3004
3005         defaults_saved = true;
3006 }
3007
3008 /***********************************************************
3009  If we should send plaintext/LANMAN passwords in the clinet
3010 ************************************************************/
3011
3012 static void set_allowed_client_auth(void)
3013 {
3014         if (Globals.client_ntlmv2_auth) {
3015                 Globals.client_lanman_auth = false;
3016         }
3017         if (!Globals.client_lanman_auth) {
3018                 Globals.client_plaintext_auth = false;
3019         }
3020 }
3021
3022 /***************************************************************************
3023  JRA.
3024  The following code allows smbd to read a user defined share file.
3025  Yes, this is my intent. Yes, I'm comfortable with that...
3026
3027  THE FOLLOWING IS SECURITY CRITICAL CODE.
3028
3029  It washes your clothes, it cleans your house, it guards you while you sleep...
3030  Do not f%^k with it....
3031 ***************************************************************************/
3032
3033 #define MAX_USERSHARE_FILE_SIZE (10*1024)
3034
3035 /***************************************************************************
3036  Check allowed stat state of a usershare file.
3037  Ensure we print out who is dicking with us so the admin can
3038  get their sorry ass fired.
3039 ***************************************************************************/
3040
3041 static bool check_usershare_stat(const char *fname,
3042                                  const SMB_STRUCT_STAT *psbuf)
3043 {
3044         if (!S_ISREG(psbuf->st_ex_mode)) {
3045                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3046                         "not a regular file\n",
3047                         fname, (unsigned int)psbuf->st_ex_uid ));
3048                 return false;
3049         }
3050
3051         /* Ensure this doesn't have the other write bit set. */
3052         if (psbuf->st_ex_mode & S_IWOTH) {
3053                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
3054                         "public write. Refusing to allow as a usershare file.\n",
3055                         fname, (unsigned int)psbuf->st_ex_uid ));
3056                 return false;
3057         }
3058
3059         /* Should be 10k or less. */
3060         if (psbuf->st_ex_size > MAX_USERSHARE_FILE_SIZE) {
3061                 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3062                         "too large (%u) to be a user share file.\n",
3063                         fname, (unsigned int)psbuf->st_ex_uid,
3064                         (unsigned int)psbuf->st_ex_size ));
3065                 return false;
3066         }
3067
3068         return true;
3069 }
3070
3071 /***************************************************************************
3072  Parse the contents of a usershare file.
3073 ***************************************************************************/
3074
3075 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
3076                         SMB_STRUCT_STAT *psbuf,
3077                         const char *servicename,
3078                         int snum,
3079                         char **lines,
3080                         int numlines,
3081                         char **pp_sharepath,
3082                         char **pp_comment,
3083                         char **pp_cp_servicename,
3084                         struct security_descriptor **ppsd,
3085                         bool *pallow_guest)
3086 {
3087         const char **prefixallowlist = lp_usershare_prefix_allow_list();
3088         const char **prefixdenylist = lp_usershare_prefix_deny_list();
3089         int us_vers;
3090         DIR *dp;
3091         SMB_STRUCT_STAT sbuf;
3092         char *sharepath = NULL;
3093         char *comment = NULL;
3094
3095         *pp_sharepath = NULL;
3096         *pp_comment = NULL;
3097
3098         *pallow_guest = false;
3099
3100         if (numlines < 4) {
3101                 return USERSHARE_MALFORMED_FILE;
3102         }
3103
3104         if (strcmp(lines[0], "#VERSION 1") == 0) {
3105                 us_vers = 1;
3106         } else if (strcmp(lines[0], "#VERSION 2") == 0) {
3107                 us_vers = 2;
3108                 if (numlines < 5) {
3109                         return USERSHARE_MALFORMED_FILE;
3110                 }
3111         } else {
3112                 return USERSHARE_BAD_VERSION;
3113         }
3114
3115         if (strncmp(lines[1], "path=", 5) != 0) {
3116                 return USERSHARE_MALFORMED_PATH;
3117         }
3118
3119         sharepath = talloc_strdup(ctx, &lines[1][5]);
3120         if (!sharepath) {
3121                 return USERSHARE_POSIX_ERR;
3122         }
3123         trim_string(sharepath, " ", " ");
3124
3125         if (strncmp(lines[2], "comment=", 8) != 0) {
3126                 return USERSHARE_MALFORMED_COMMENT_DEF;
3127         }
3128
3129         comment = talloc_strdup(ctx, &lines[2][8]);
3130         if (!comment) {
3131                 return USERSHARE_POSIX_ERR;
3132         }
3133         trim_string(comment, " ", " ");
3134         trim_char(comment, '"', '"');
3135
3136         if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
3137                 return USERSHARE_MALFORMED_ACL_DEF;
3138         }
3139
3140         if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
3141                 return USERSHARE_ACL_ERR;
3142         }
3143
3144         if (us_vers == 2) {
3145                 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
3146                         return USERSHARE_MALFORMED_ACL_DEF;
3147                 }
3148                 if (lines[4][9] == 'y') {
3149                         *pallow_guest = true;
3150                 }
3151
3152                 /* Backwards compatible extension to file version #2. */
3153                 if (numlines > 5) {
3154                         if (strncmp(lines[5], "sharename=", 10) != 0) {
3155                                 return USERSHARE_MALFORMED_SHARENAME_DEF;
3156                         }
3157                         if (!strequal(&lines[5][10], servicename)) {
3158                                 return USERSHARE_BAD_SHARENAME;
3159                         }
3160                         *pp_cp_servicename = talloc_strdup(ctx, &lines[5][10]);
3161                         if (!*pp_cp_servicename) {
3162                                 return USERSHARE_POSIX_ERR;
3163                         }
3164                 }
3165         }
3166
3167         if (*pp_cp_servicename == NULL) {
3168                 *pp_cp_servicename = talloc_strdup(ctx, servicename);
3169                 if (!*pp_cp_servicename) {
3170                         return USERSHARE_POSIX_ERR;
3171                 }
3172         }
3173
3174         if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->path) == 0)) {
3175                 /* Path didn't change, no checks needed. */
3176                 *pp_sharepath = sharepath;
3177                 *pp_comment = comment;
3178                 return USERSHARE_OK;
3179         }
3180
3181         /* The path *must* be absolute. */
3182         if (sharepath[0] != '/') {
3183                 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
3184                         servicename, sharepath));
3185                 return USERSHARE_PATH_NOT_ABSOLUTE;
3186         }
3187
3188         /* If there is a usershare prefix deny list ensure one of these paths
3189            doesn't match the start of the user given path. */
3190         if (prefixdenylist) {
3191                 int i;
3192                 for ( i=0; prefixdenylist[i]; i++ ) {