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