2 Unix SMB/CIFS implementation.
3 Parameter loading functions
4 Copyright (C) Karl Auer 1993-1998
6 Largely re-written by Andrew Tridgell, September 1994
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
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.
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.
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/>.
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.
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
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
56 #define LOADPARM_SUBSTITUTION_INTERNALS 1
58 #include "system/filesys.h"
60 #include "lib/param/loadparm.h"
61 #include "lib/param/param.h"
63 #include "lib/smbconf/smbconf.h"
64 #include "lib/smbconf/smbconf_init.h"
67 #include "../librpc/gen_ndr/svcctl.h"
69 #include "../libcli/smb/smb_signing.h"
70 #include "dbwrap/dbwrap.h"
71 #include "dbwrap/dbwrap_rbt.h"
72 #include "../lib/util/bitmap.h"
73 #include "librpc/gen_ndr/nbt.h"
74 #include "source4/lib/tls/tls.h"
75 #include "libcli/auth/ntlm_check.h"
77 #ifdef HAVE_SYS_SYSCTL_H
78 #include <sys/sysctl.h>
83 extern userdom_struct current_user_info
;
85 /* the special value for the include parameter
86 * to be interpreted not as a file name but to
87 * trigger loading of the global smb.conf options
89 #ifndef INCLUDE_REGISTRY_NAME
90 #define INCLUDE_REGISTRY_NAME "registry"
93 static bool in_client
= false; /* Not in the client by default */
94 static struct smbconf_csn conf_last_csn
;
96 static int config_backend
= CONFIG_BACKEND_FILE
;
98 /* some helpful bits */
99 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && \
100 (ServicePtrs != NULL) && \
101 (ServicePtrs[(i)] != NULL) && ServicePtrs[(i)]->valid)
102 #define VALID(i) ((ServicePtrs != NULL) && (ServicePtrs[i]!= NULL) && \
103 ServicePtrs[i]->valid)
105 #define USERSHARE_VALID 1
106 #define USERSHARE_PENDING_DELETE 2
108 static bool defaults_saved
= false;
110 #include "lib/param/param_global.h"
112 static struct loadparm_global Globals
;
114 /* This is a default service used to prime a services structure */
115 static const struct loadparm_service _sDefault
=
120 .usershare_last_mod
= {0, 0},
123 .invalid_users
= NULL
,
130 .root_preexec
= NULL
,
131 .root_postexec
= NULL
,
132 .cups_options
= NULL
,
133 .print_command
= NULL
,
135 .lprm_command
= NULL
,
136 .lppause_command
= NULL
,
137 .lpresume_command
= NULL
,
138 .queuepause_command
= NULL
,
139 .queueresume_command
= NULL
,
140 ._printername
= NULL
,
141 .printjob_username
= NULL
,
142 .dont_descend
= NULL
,
145 .magic_script
= NULL
,
146 .magic_output
= NULL
,
149 .veto_oplock_files
= NULL
,
159 .aio_write_behind
= NULL
,
160 .dfree_command
= NULL
,
161 .min_print_space
= 0,
162 .max_print_jobs
= 1000,
163 .max_reported_print_jobs
= 0,
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
,
173 .dfree_cache_time
= 0,
174 .preexec_close
= false,
175 .root_preexec_close
= false,
176 .case_sensitive
= Auto
,
177 .preserve_case
= true,
178 .short_preserve_case
= true,
179 .hide_dot_files
= true,
180 .hide_special_files
= false,
181 .hide_unreadable
= false,
182 .hide_unwriteable_files
= false,
184 .access_based_share_enum
= false,
189 .administrative_share
= false,
192 .print_notify_backchannel
= false,
196 .store_dos_attributes
= true,
197 .dmapi_support
= false,
199 .strict_locking
= Auto
,
200 .posix_locking
= true,
202 .kernel_oplocks
= false,
203 .level2_oplocks
= true,
204 .mangled_names
= MANGLED_NAMES_ILLEGAL
,
206 .follow_symlinks
= true,
207 .sync_always
= false,
208 .strict_allocate
= false,
209 .strict_rename
= false,
211 .mangling_char
= '~',
213 .delete_readonly
= false,
214 .fake_oplocks
= false,
215 .delete_veto_files
= false,
216 .dos_filemode
= false,
217 .dos_filetimes
= true,
218 .dos_filetime_resolution
= false,
219 .fake_directory_create_times
= false,
220 .blocking_locks
= true,
221 .inherit_permissions
= false,
222 .inherit_acls
= false,
223 .inherit_owner
= false,
225 .msdfs_shuffle_referrals
= false,
226 .use_client_driver
= false,
227 .default_devmode
= true,
228 .force_printername
= false,
229 .nt_acl_support
= true,
230 .force_unknown_acl_user
= false,
231 ._use_sendfile
= false,
232 .map_acl_inherit
= false,
235 .acl_check_permissions
= true,
236 .acl_map_full_control
= true,
237 .acl_group_control
= false,
238 .acl_allow_execute_always
= false,
241 .map_readonly
= MAP_READONLY_NO
,
242 .directory_name_cache_size
= 100,
243 .smb_encrypt
= SMB_SIGNING_DEFAULT
,
244 .kernel_share_modes
= true,
245 .durable_handles
= true,
246 .check_parent_directory_delete_on_close
= false,
248 .smbd_search_ask_sharemode
= true,
249 .smbd_getinfo_ask_sharemode
= true,
250 .spotlight_backend
= SPOTLIGHT_BACKEND_NOINDEX
,
255 * This is a copy of the default service structure. Service options in the
256 * global section would otherwise overwrite the initial default values.
258 static struct loadparm_service sDefault
;
260 /* local variables */
261 static struct loadparm_service
**ServicePtrs
= NULL
;
262 static int iNumServices
= 0;
263 static int iServiceIndex
= 0;
264 static struct db_context
*ServiceHash
;
265 static bool bInGlobalSection
= true;
266 static bool bGlobalOnly
= false;
267 static struct file_lists
*file_lists
= NULL
;
268 static unsigned int *flags_list
= NULL
;
270 static void set_allowed_client_auth(void);
272 static bool lp_set_cmdline_helper(const char *pszParmName
, const char *pszParmValue
);
273 static void free_param_opts(struct parmlist_entry
**popts
);
276 * Function to return the default value for the maximum number of open
277 * file descriptors permitted. This function tries to consult the
278 * kernel-level (sysctl) and ulimit (getrlimit()) values and goes
279 * the smaller of those.
281 static int max_open_files(void)
283 int sysctl_max
= MAX_OPEN_FILES
;
284 int rlimit_max
= MAX_OPEN_FILES
;
286 #ifdef HAVE_SYSCTLBYNAME
288 size_t size
= sizeof(sysctl_max
);
289 sysctlbyname("kern.maxfilesperproc", &sysctl_max
, &size
, NULL
,
294 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
300 if (getrlimit(RLIMIT_NOFILE
, &rl
) == 0)
301 rlimit_max
= rl
.rlim_cur
;
303 #if defined(RLIM_INFINITY)
304 if(rl
.rlim_cur
== RLIM_INFINITY
)
305 rlimit_max
= MAX_OPEN_FILES
;
310 if (sysctl_max
< MIN_OPEN_FILES_WINDOWS
) {
311 DEBUG(2,("max_open_files: increasing sysctl_max (%d) to "
312 "minimum Windows limit (%d)\n",
314 MIN_OPEN_FILES_WINDOWS
));
315 sysctl_max
= MIN_OPEN_FILES_WINDOWS
;
318 if (rlimit_max
< MIN_OPEN_FILES_WINDOWS
) {
319 DEBUG(2,("rlimit_max: increasing rlimit_max (%d) to "
320 "minimum Windows limit (%d)\n",
322 MIN_OPEN_FILES_WINDOWS
));
323 rlimit_max
= MIN_OPEN_FILES_WINDOWS
;
326 return MIN(sysctl_max
, rlimit_max
);
330 * Common part of freeing allocated data for one parameter.
332 static void free_one_parameter_common(void *parm_ptr
,
333 struct parm_struct parm
)
335 if ((parm
.type
== P_STRING
) ||
336 (parm
.type
== P_USTRING
))
338 lpcfg_string_free((char**)parm_ptr
);
339 } else if (parm
.type
== P_LIST
|| parm
.type
== P_CMDLIST
) {
340 TALLOC_FREE(*((char***)parm_ptr
));
345 * Free the allocated data for one parameter for a share
346 * given as a service struct.
348 static void free_one_parameter(struct loadparm_service
*service
,
349 struct parm_struct parm
)
353 if (parm
.p_class
!= P_LOCAL
) {
357 parm_ptr
= lp_parm_ptr(service
, &parm
);
359 free_one_parameter_common(parm_ptr
, parm
);
363 * Free the allocated parameter data of a share given
364 * as a service struct.
366 static void free_parameters(struct loadparm_service
*service
)
370 for (i
=0; parm_table
[i
].label
; i
++) {
371 free_one_parameter(service
, parm_table
[i
]);
376 * Free the allocated data for one parameter for a given share
377 * specified by an snum.
379 static void free_one_parameter_by_snum(int snum
, struct parm_struct parm
)
384 parm_ptr
= lp_parm_ptr(NULL
, &parm
);
385 } else if (parm
.p_class
!= P_LOCAL
) {
388 parm_ptr
= lp_parm_ptr(ServicePtrs
[snum
], &parm
);
391 free_one_parameter_common(parm_ptr
, parm
);
395 * Free the allocated parameter data for a share specified
398 static void free_parameters_by_snum(int snum
)
402 for (i
=0; parm_table
[i
].label
; i
++) {
403 free_one_parameter_by_snum(snum
, parm_table
[i
]);
408 * Free the allocated global parameters.
410 static void free_global_parameters(void)
413 struct parm_struct
*parm
;
415 free_param_opts(&Globals
.param_opt
);
416 free_parameters_by_snum(GLOBAL_SECTION_SNUM
);
418 /* Reset references in the defaults because the context is going to be freed */
419 for (i
=0; parm_table
[i
].label
; i
++) {
420 parm
= &parm_table
[i
];
421 if ((parm
->type
== P_STRING
) ||
422 (parm
->type
== P_USTRING
)) {
423 if ((parm
->def
.svalue
!= NULL
) &&
424 (*(parm
->def
.svalue
) != '\0')) {
425 if (talloc_parent(parm
->def
.svalue
) == Globals
.ctx
) {
426 parm
->def
.svalue
= NULL
;
431 TALLOC_FREE(Globals
.ctx
);
434 struct lp_stored_option
{
435 struct lp_stored_option
*prev
, *next
;
440 static struct lp_stored_option
*stored_options
;
443 save options set by lp_set_cmdline() into a list. This list is
444 re-applied when we do a globals reset, so that cmdline set options
445 are sticky across reloads of smb.conf
447 bool store_lp_set_cmdline(const char *pszParmName
, const char *pszParmValue
)
449 struct lp_stored_option
*entry
, *entry_next
;
450 for (entry
= stored_options
; entry
!= NULL
; entry
= entry_next
) {
451 entry_next
= entry
->next
;
452 if (strcmp(pszParmName
, entry
->label
) == 0) {
453 DLIST_REMOVE(stored_options
, entry
);
459 entry
= talloc(NULL
, struct lp_stored_option
);
464 entry
->label
= talloc_strdup(entry
, pszParmName
);
470 entry
->value
= talloc_strdup(entry
, pszParmValue
);
476 DLIST_ADD_END(stored_options
, entry
);
481 static bool apply_lp_set_cmdline(void)
483 struct lp_stored_option
*entry
= NULL
;
484 for (entry
= stored_options
; entry
!= NULL
; entry
= entry
->next
) {
485 if (!lp_set_cmdline_helper(entry
->label
, entry
->value
)) {
486 DEBUG(0, ("Failed to re-apply cmdline parameter %s = %s\n",
487 entry
->label
, entry
->value
));
494 /***************************************************************************
495 Initialise the global parameter structure.
496 ***************************************************************************/
498 static void init_globals(struct loadparm_context
*lp_ctx
, bool reinit_globals
)
500 static bool done_init
= false;
504 /* If requested to initialize only once and we've already done it... */
505 if (!reinit_globals
&& done_init
) {
506 /* ... then we have nothing more to do */
511 /* The logfile can be set before this is invoked. Free it if so. */
512 lpcfg_string_free(&Globals
.logfile
);
515 free_global_parameters();
518 /* This memset and the free_global_parameters() above will
519 * wipe out smb.conf options set with lp_set_cmdline(). The
520 * apply_lp_set_cmdline() call puts these values back in the
521 * table once the defaults are set */
522 ZERO_STRUCT(Globals
);
524 Globals
.ctx
= talloc_pooled_object(NULL
, char, 272, 2048);
526 /* Initialize the flags list if necessary */
527 if (flags_list
== NULL
) {
531 for (i
= 0; parm_table
[i
].label
; i
++) {
532 if ((parm_table
[i
].type
== P_STRING
||
533 parm_table
[i
].type
== P_USTRING
))
537 (char **)lp_parm_ptr(NULL
, &parm_table
[i
]),
543 lpcfg_string_set(Globals
.ctx
, &sDefault
.fstype
, FSTYPE_STRING
);
544 lpcfg_string_set(Globals
.ctx
, &sDefault
.printjob_username
, "%U");
546 init_printer_values(lp_ctx
, Globals
.ctx
, &sDefault
);
548 sDefault
.ntvfs_handler
= str_list_make_v3_const(Globals
.ctx
, "unixuid default", NULL
);
550 DEBUG(3, ("Initialising global parameters\n"));
552 /* Must manually force to upper case here, as this does not go via the handler */
553 lpcfg_string_set(Globals
.ctx
, &Globals
.netbios_name
,
556 lpcfg_string_set(Globals
.ctx
, &Globals
.smb_passwd_file
,
557 get_dyn_SMB_PASSWD_FILE());
558 lpcfg_string_set(Globals
.ctx
, &Globals
.private_dir
,
559 get_dyn_PRIVATE_DIR());
560 lpcfg_string_set(Globals
.ctx
, &Globals
.binddns_dir
,
561 get_dyn_BINDDNS_DIR());
563 /* use the new 'hash2' method by default, with a prefix of 1 */
564 lpcfg_string_set(Globals
.ctx
, &Globals
.mangling_method
, "hash2");
565 Globals
.mangle_prefix
= 1;
567 lpcfg_string_set(Globals
.ctx
, &Globals
.guest_account
, GUEST_ACCOUNT
);
569 /* using UTF8 by default allows us to support all chars */
570 lpcfg_string_set(Globals
.ctx
, &Globals
.unix_charset
,
571 DEFAULT_UNIX_CHARSET
);
573 /* Use codepage 850 as a default for the dos character set */
574 lpcfg_string_set(Globals
.ctx
, &Globals
.dos_charset
,
575 DEFAULT_DOS_CHARSET
);
578 * Allow the default PASSWD_CHAT to be overridden in local.h.
580 lpcfg_string_set(Globals
.ctx
, &Globals
.passwd_chat
,
581 DEFAULT_PASSWD_CHAT
);
583 lpcfg_string_set(Globals
.ctx
, &Globals
.workgroup
, DEFAULT_WORKGROUP
);
585 lpcfg_string_set(Globals
.ctx
, &Globals
.passwd_program
, "");
586 lpcfg_string_set(Globals
.ctx
, &Globals
.lock_directory
,
588 lpcfg_string_set(Globals
.ctx
, &Globals
.state_directory
,
590 lpcfg_string_set(Globals
.ctx
, &Globals
.cache_directory
,
592 lpcfg_string_set(Globals
.ctx
, &Globals
.pid_directory
,
594 lpcfg_string_set(Globals
.ctx
, &Globals
.nbt_client_socket_address
,
597 * By default support explicit binding to broadcast
600 Globals
.nmbd_bind_explicit_broadcast
= true;
602 s
= talloc_asprintf(talloc_tos(), "Samba %s", samba_version_string());
604 smb_panic("init_globals: ENOMEM");
606 lpcfg_string_set(Globals
.ctx
, &Globals
.server_string
, s
);
609 lpcfg_string_set(Globals
.ctx
, &Globals
.panic_action
,
610 "/bin/sleep 999999999");
613 lpcfg_string_set(Globals
.ctx
, &Globals
.socket_options
,
614 DEFAULT_SOCKET_OPTIONS
);
616 lpcfg_string_set(Globals
.ctx
, &Globals
.logon_drive
, "");
617 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
618 lpcfg_string_set(Globals
.ctx
, &Globals
.logon_home
, "\\\\%N\\%U");
619 lpcfg_string_set(Globals
.ctx
, &Globals
.logon_path
,
620 "\\\\%N\\%U\\profile");
622 Globals
.name_resolve_order
=
623 str_list_make_v3_const(Globals
.ctx
,
624 DEFAULT_NAME_RESOLVE_ORDER
,
626 lpcfg_string_set(Globals
.ctx
, &Globals
.password_server
, "*");
628 Globals
.algorithmic_rid_base
= BASE_RID
;
630 Globals
.load_printers
= true;
631 Globals
.printcap_cache_time
= 750; /* 12.5 minutes */
633 Globals
.config_backend
= config_backend
;
634 Globals
._server_role
= ROLE_AUTO
;
636 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
637 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
638 Globals
.max_xmit
= 0x4104;
639 Globals
.max_mux
= 50; /* This is *needed* for profile support. */
640 Globals
.lpq_cache_time
= 30; /* changed to handle large print servers better -- jerry */
641 Globals
._disable_spoolss
= false;
642 Globals
.max_smbd_processes
= 0;/* no limit specified */
643 Globals
.username_level
= 0;
644 Globals
.deadtime
= 10080;
645 Globals
.getwd_cache
= true;
646 Globals
.large_readwrite
= true;
647 Globals
.max_log_size
= 5000;
648 Globals
.max_open_files
= max_open_files();
649 Globals
.server_max_protocol
= PROTOCOL_SMB3_11
;
650 Globals
.server_min_protocol
= PROTOCOL_SMB2_02
;
651 Globals
._client_max_protocol
= PROTOCOL_DEFAULT
;
652 Globals
.client_min_protocol
= PROTOCOL_SMB2_02
;
653 Globals
._client_ipc_max_protocol
= PROTOCOL_DEFAULT
;
654 Globals
._client_ipc_min_protocol
= PROTOCOL_DEFAULT
;
655 Globals
._security
= SEC_AUTO
;
656 Globals
.encrypt_passwords
= true;
657 Globals
.client_schannel
= true;
658 Globals
.winbind_sealed_pipes
= true;
659 Globals
.require_strong_key
= true;
660 Globals
.server_schannel
= true;
661 Globals
.read_raw
= true;
662 Globals
.write_raw
= true;
663 Globals
.null_passwords
= false;
664 Globals
.old_password_allowed_period
= 60;
665 Globals
.obey_pam_restrictions
= false;
667 Globals
.syslog_only
= false;
668 Globals
.timestamp_logs
= true;
669 lpcfg_string_set(Globals
.ctx
, &Globals
.log_level
, "0");
670 Globals
.debug_prefix_timestamp
= false;
671 Globals
.debug_hires_timestamp
= true;
672 Globals
.debug_pid
= false;
673 Globals
.debug_uid
= false;
674 Globals
.debug_class
= false;
675 Globals
.enable_core_files
= true;
676 Globals
.max_ttl
= 60 * 60 * 24 * 3; /* 3 days default. */
677 Globals
.max_wins_ttl
= 60 * 60 * 24 * 6; /* 6 days default. */
678 Globals
.min_wins_ttl
= 60 * 60 * 6; /* 6 hours default. */
679 Globals
.machine_password_timeout
= 60 * 60 * 24 * 7; /* 7 days default. */
680 Globals
.lm_announce
= Auto
; /* = Auto: send only if LM clients found */
681 Globals
.lm_interval
= 60;
682 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
683 Globals
.nis_homedir
= false;
684 #ifdef WITH_NISPLUS_HOME
685 lpcfg_string_set(Globals
.ctx
, &Globals
.homedir_map
,
686 "auto_home.org_dir");
688 lpcfg_string_set(Globals
.ctx
, &Globals
.homedir_map
, "auto.home");
691 Globals
.time_server
= false;
692 Globals
.bind_interfaces_only
= false;
693 Globals
.unix_password_sync
= false;
694 Globals
.pam_password_change
= false;
695 Globals
.passwd_chat_debug
= false;
696 Globals
.passwd_chat_timeout
= 2; /* 2 second default. */
697 Globals
.nt_pipe_support
= true; /* Do NT pipes by default. */
698 Globals
.nt_status_support
= true; /* Use NT status by default. */
699 Globals
.smbd_profiling_level
= 0;
700 Globals
.stat_cache
= true; /* use stat cache by default */
701 Globals
.max_stat_cache_size
= 512; /* 512k by default */
702 Globals
.restrict_anonymous
= 0;
703 Globals
.client_lanman_auth
= false; /* Do NOT use the LanMan hash if it is available */
704 Globals
.client_plaintext_auth
= false; /* Do NOT use a plaintext password even if is requested by the server */
705 Globals
._lanman_auth
= false; /* Do NOT use the LanMan hash, even if it is supplied */
706 Globals
.ntlm_auth
= NTLM_AUTH_NTLMV2_ONLY
; /* Do NOT use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
707 Globals
.raw_ntlmv2_auth
= false; /* Reject NTLMv2 without NTLMSSP */
708 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 */
709 /* Note, that we will also use NTLM2 session security (which is different), if it is available */
711 Globals
.allow_dcerpc_auth_level_connect
= false; /* we don't allow this by default */
713 Globals
.map_to_guest
= 0; /* By Default, "Never" */
714 Globals
.oplock_break_wait_time
= 0; /* By Default, 0 msecs. */
715 Globals
.enhanced_browsing
= true;
716 Globals
.lock_spin_time
= WINDOWS_MINIMUM_LOCK_TIMEOUT_MS
; /* msec. */
717 Globals
.use_mmap
= true;
718 Globals
.unicode
= true;
719 Globals
.unix_extensions
= true;
720 Globals
.reset_on_zero_vc
= false;
721 Globals
.log_writeable_files_on_exit
= false;
722 Globals
.create_krb5_conf
= true;
723 Globals
.include_system_krb5_conf
= true;
724 Globals
._winbind_max_domain_connections
= 1;
726 /* hostname lookups can be very expensive and are broken on
727 a large number of sites (tridge) */
728 Globals
.hostname_lookups
= false;
730 Globals
.change_notify
= true,
731 Globals
.kernel_change_notify
= true,
733 lpcfg_string_set(Globals
.ctx
, &Globals
.passdb_backend
, "tdbsam");
734 lpcfg_string_set(Globals
.ctx
, &Globals
.ldap_suffix
, "");
735 lpcfg_string_set(Globals
.ctx
, &Globals
._ldap_machine_suffix
, "");
736 lpcfg_string_set(Globals
.ctx
, &Globals
._ldap_user_suffix
, "");
737 lpcfg_string_set(Globals
.ctx
, &Globals
._ldap_group_suffix
, "");
738 lpcfg_string_set(Globals
.ctx
, &Globals
._ldap_idmap_suffix
, "");
740 lpcfg_string_set(Globals
.ctx
, &Globals
.ldap_admin_dn
, "");
741 Globals
.ldap_ssl
= LDAP_SSL_START_TLS
;
742 Globals
.ldap_ssl_ads
= false;
743 Globals
.ldap_deref
= -1;
744 Globals
.ldap_passwd_sync
= LDAP_PASSWD_SYNC_OFF
;
745 Globals
.ldap_delete_dn
= false;
746 Globals
.ldap_replication_sleep
= 1000; /* wait 1 sec for replication */
747 Globals
.ldap_follow_referral
= Auto
;
748 Globals
.ldap_timeout
= LDAP_DEFAULT_TIMEOUT
;
749 Globals
.ldap_connection_timeout
= LDAP_CONNECTION_DEFAULT_TIMEOUT
;
750 Globals
.ldap_page_size
= LDAP_PAGE_SIZE
;
752 Globals
.ldap_debug_level
= 0;
753 Globals
.ldap_debug_threshold
= 10;
755 Globals
.client_ldap_sasl_wrapping
= ADS_AUTH_SASL_SIGN
;
757 Globals
.ldap_server_require_strong_auth
=
758 LDAP_SERVER_REQUIRE_STRONG_AUTH_YES
;
760 /* This is what we tell the afs client. in reality we set the token
761 * to never expire, though, when this runs out the afs client will
762 * forget the token. Set to 0 to get NEVERDATE.*/
763 Globals
.afs_token_lifetime
= 604800;
764 Globals
.cups_connection_timeout
= CUPS_DEFAULT_CONNECTION_TIMEOUT
;
766 /* these parameters are set to defaults that are more appropriate
767 for the increasing samba install base:
769 as a member of the workgroup, that will possibly become a
770 _local_ master browser (lm = true). this is opposed to a forced
771 local master browser startup (pm = true).
773 doesn't provide WINS server service by default (wsupp = false),
774 and doesn't provide domain master browser services by default, either.
778 Globals
.show_add_printer_wizard
= true;
779 Globals
.os_level
= 20;
780 Globals
.local_master
= true;
781 Globals
._domain_master
= Auto
; /* depending on _domain_logons */
782 Globals
._domain_logons
= false;
783 Globals
.browse_list
= true;
784 Globals
.we_are_a_wins_server
= false;
785 Globals
.wins_proxy
= false;
787 TALLOC_FREE(Globals
.init_logon_delayed_hosts
);
788 Globals
.init_logon_delay
= 100; /* 100 ms default delay */
790 Globals
.wins_dns_proxy
= true;
792 Globals
.allow_trusted_domains
= true;
793 lpcfg_string_set(Globals
.ctx
, &Globals
.idmap_backend
, "tdb");
795 lpcfg_string_set(Globals
.ctx
, &Globals
.template_shell
, "/bin/false");
796 lpcfg_string_set(Globals
.ctx
, &Globals
.template_homedir
,
798 lpcfg_string_set(Globals
.ctx
, &Globals
.winbind_separator
, "\\");
799 lpcfg_string_set(Globals
.ctx
, &Globals
.winbindd_socket_directory
,
800 dyn_WINBINDD_SOCKET_DIR
);
802 lpcfg_string_set(Globals
.ctx
, &Globals
.cups_server
, "");
803 lpcfg_string_set(Globals
.ctx
, &Globals
.iprint_server
, "");
805 lpcfg_string_set(Globals
.ctx
, &Globals
._ctdbd_socket
, "");
807 Globals
.cluster_addresses
= NULL
;
808 Globals
.clustering
= false;
809 Globals
.ctdb_timeout
= 0;
810 Globals
.ctdb_locktime_warn_threshold
= 0;
812 Globals
.winbind_cache_time
= 300; /* 5 minutes */
813 Globals
.winbind_reconnect_delay
= 30; /* 30 seconds */
814 Globals
.winbind_request_timeout
= 60; /* 60 seconds */
815 Globals
.winbind_max_clients
= 200;
816 Globals
.winbind_enum_users
= false;
817 Globals
.winbind_enum_groups
= false;
818 Globals
.winbind_use_default_domain
= false;
819 Globals
.winbind_nested_groups
= true;
820 Globals
.winbind_expand_groups
= 0;
821 Globals
.winbind_nss_info
= str_list_make_v3_const(NULL
, "template", NULL
);
822 Globals
.winbind_refresh_tickets
= false;
823 Globals
.winbind_offline_logon
= false;
824 Globals
.winbind_scan_trusted_domains
= true;
826 Globals
.idmap_cache_time
= 86400 * 7; /* a week by default */
827 Globals
.idmap_negative_cache_time
= 120; /* 2 minutes by default */
829 Globals
.passdb_expand_explicit
= false;
831 Globals
.name_cache_timeout
= 660; /* In seconds */
833 Globals
.client_use_spnego
= true;
835 Globals
.client_signing
= SMB_SIGNING_DEFAULT
;
836 Globals
._client_ipc_signing
= SMB_SIGNING_DEFAULT
;
837 Globals
.server_signing
= SMB_SIGNING_DEFAULT
;
839 Globals
.defer_sharing_violations
= true;
840 Globals
.smb_ports
= str_list_make_v3_const(NULL
, SMB_PORTS
, NULL
);
842 Globals
.enable_privileges
= true;
843 Globals
.host_msdfs
= true;
844 Globals
.enable_asu_support
= false;
846 /* User defined shares. */
847 s
= talloc_asprintf(talloc_tos(), "%s/usershares", get_dyn_STATEDIR());
849 smb_panic("init_globals: ENOMEM");
851 lpcfg_string_set(Globals
.ctx
, &Globals
.usershare_path
, s
);
853 lpcfg_string_set(Globals
.ctx
, &Globals
.usershare_template_share
, "");
854 Globals
.usershare_max_shares
= 0;
855 /* By default disallow sharing of directories not owned by the sharer. */
856 Globals
.usershare_owner_only
= true;
857 /* By default disallow guest access to usershares. */
858 Globals
.usershare_allow_guests
= false;
860 Globals
.keepalive
= DEFAULT_KEEPALIVE
;
862 /* By default no shares out of the registry */
863 Globals
.registry_shares
= false;
865 Globals
.min_receivefile_size
= 0;
867 Globals
.multicast_dns_register
= true;
869 Globals
.smb2_max_read
= DEFAULT_SMB2_MAX_READ
;
870 Globals
.smb2_max_write
= DEFAULT_SMB2_MAX_WRITE
;
871 Globals
.smb2_max_trans
= DEFAULT_SMB2_MAX_TRANSACT
;
872 Globals
.smb2_max_credits
= DEFAULT_SMB2_MAX_CREDITS
;
873 Globals
.smb2_leases
= true;
875 lpcfg_string_set(Globals
.ctx
, &Globals
.ncalrpc_dir
,
876 get_dyn_NCALRPCDIR());
878 Globals
.server_services
= str_list_make_v3_const(NULL
, "s3fs rpc nbt wrepl ldap cldap kdc drepl winbindd ntp_signd kcc dnsupdate dns", NULL
);
880 Globals
.dcerpc_endpoint_servers
= str_list_make_v3_const(NULL
, "epmapper wkssvc rpcecho samr netlogon lsarpc drsuapi dssetup unixinfo browser eventlog6 backupkey dnsserver", NULL
);
882 Globals
.tls_enabled
= true;
883 Globals
.tls_verify_peer
= TLS_VERIFY_PEER_AS_STRICT_AS_POSSIBLE
;
885 lpcfg_string_set(Globals
.ctx
, &Globals
._tls_keyfile
, "tls/key.pem");
886 lpcfg_string_set(Globals
.ctx
, &Globals
._tls_certfile
, "tls/cert.pem");
887 lpcfg_string_set(Globals
.ctx
, &Globals
._tls_cafile
, "tls/ca.pem");
888 lpcfg_string_set(Globals
.ctx
, &Globals
.tls_priority
,
889 "NORMAL:-VERS-SSL3.0");
891 lpcfg_string_set(Globals
.ctx
, &Globals
.share_backend
, "classic");
893 Globals
._preferred_master
= Auto
;
895 Globals
.allow_dns_updates
= DNS_UPDATE_SIGNED
;
896 Globals
.dns_zone_scavenging
= false;
898 lpcfg_string_set(Globals
.ctx
, &Globals
.ntp_signd_socket_directory
,
899 get_dyn_NTP_SIGND_SOCKET_DIR());
901 s
= talloc_asprintf(talloc_tos(), "%s/samba_kcc", get_dyn_SCRIPTSBINDIR());
903 smb_panic("init_globals: ENOMEM");
905 Globals
.samba_kcc_command
= str_list_make_v3_const(NULL
, s
, NULL
);
909 Globals
.mit_kdc_command
= str_list_make_v3_const(NULL
, MIT_KDC_PATH
, NULL
);
912 s
= talloc_asprintf(talloc_tos(), "%s/samba_dnsupdate", get_dyn_SCRIPTSBINDIR());
914 smb_panic("init_globals: ENOMEM");
916 Globals
.dns_update_command
= str_list_make_v3_const(NULL
, s
, NULL
);
919 s
= talloc_asprintf(talloc_tos(), "%s/samba-gpupdate", get_dyn_SCRIPTSBINDIR());
921 smb_panic("init_globals: ENOMEM");
923 Globals
.gpo_update_command
= str_list_make_v3_const(NULL
, s
, NULL
);
926 Globals
.apply_group_policies
= false;
928 s
= talloc_asprintf(talloc_tos(), "%s/samba_spnupdate", get_dyn_SCRIPTSBINDIR());
930 smb_panic("init_globals: ENOMEM");
932 Globals
.spn_update_command
= str_list_make_v3_const(NULL
, s
, NULL
);
935 Globals
.nsupdate_command
= str_list_make_v3_const(NULL
, "/usr/bin/nsupdate -g", NULL
);
937 Globals
.cldap_port
= 389;
939 Globals
.dgram_port
= NBT_DGRAM_SERVICE_PORT
;
941 Globals
.nbt_port
= NBT_NAME_SERVICE_PORT
;
943 Globals
.krb5_port
= 88;
945 Globals
.kpasswd_port
= 464;
947 Globals
.aio_max_threads
= 100;
949 lpcfg_string_set(Globals
.ctx
,
950 &Globals
.rpc_server_dynamic_port_range
,
952 Globals
.rpc_low_port
= SERVER_TCP_LOW_PORT
;
953 Globals
.rpc_high_port
= SERVER_TCP_HIGH_PORT
;
954 Globals
.prefork_children
= 4;
955 Globals
.prefork_backoff_increment
= 10;
956 Globals
.prefork_maximum_backoff
= 120;
958 /* Now put back the settings that were set with lp_set_cmdline() */
959 apply_lp_set_cmdline();
962 /* Convenience routine to setup an lp_context with additional s3 variables */
963 static struct loadparm_context
*setup_lp_context(TALLOC_CTX
*mem_ctx
)
965 struct loadparm_context
*lp_ctx
;
967 lp_ctx
= loadparm_init_s3(mem_ctx
,
968 loadparm_s3_helpers());
969 if (lp_ctx
== NULL
) {
970 DEBUG(0, ("loadparm_init_s3 failed\n"));
974 lp_ctx
->sDefault
= talloc_zero(lp_ctx
, struct loadparm_service
);
975 if (lp_ctx
->sDefault
== NULL
) {
976 DBG_ERR("talloc_zero failed\n");
981 *lp_ctx
->sDefault
= _sDefault
;
982 lp_ctx
->services
= NULL
; /* We do not want to access this directly */
983 lp_ctx
->bInGlobalSection
= bInGlobalSection
;
984 lp_ctx
->flags
= flags_list
;
989 /*******************************************************************
990 Convenience routine to grab string parameters into talloced memory
991 and run standard_sub_basic on them. The buffers can be written to by
992 callers without affecting the source string.
993 ********************************************************************/
995 static char *loadparm_s3_global_substitution_fn(
997 const struct loadparm_substitution
*lp_sub
,
1003 /* The follow debug is useful for tracking down memory problems
1004 especially if you have an inner loop that is calling a lp_*()
1005 function that returns a string. Perhaps this debug should be
1006 present all the time? */
1009 DEBUG(10, ("lp_string(%s)\n", s
));
1015 ret
= talloc_sub_basic(mem_ctx
,
1016 get_current_username(),
1017 current_user_info
.domain
,
1019 if (trim_char(ret
, '\"', '\"')) {
1020 if (strchr(ret
,'\"') != NULL
) {
1022 ret
= talloc_sub_basic(mem_ctx
,
1023 get_current_username(),
1024 current_user_info
.domain
,
1031 static const struct loadparm_substitution s3_global_substitution
= {
1032 .substituted_string_fn
= loadparm_s3_global_substitution_fn
,
1035 const struct loadparm_substitution
*loadparm_s3_global_substitution(void)
1037 return &s3_global_substitution
;
1041 In this section all the functions that are used to access the
1042 parameters from the rest of the program are defined
1045 #define FN_GLOBAL_SUBSTITUTED_STRING(fn_name,ptr) \
1046 char *lp_ ## fn_name(TALLOC_CTX *ctx, const struct loadparm_substitution *lp_sub) \
1047 {return lpcfg_substituted_string(ctx, lp_sub, *(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : "");}
1048 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1049 const char *lp_ ## fn_name(void) {return(*(const char * const *)(&Globals.ptr) ? *(const char * const *)(&Globals.ptr) : "");}
1050 #define FN_GLOBAL_LIST(fn_name,ptr) \
1051 const char **lp_ ## fn_name(void) {return(*(const char ***)(&Globals.ptr));}
1052 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1053 bool lp_ ## fn_name(void) {return(*(bool *)(&Globals.ptr));}
1054 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1055 char lp_ ## fn_name(void) {return(*(char *)(&Globals.ptr));}
1056 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1057 int lp_ ## fn_name(void) {return(*(int *)(&Globals.ptr));}
1059 #define FN_LOCAL_SUBSTITUTED_STRING(fn_name,val) \
1060 char *lp_ ## fn_name(TALLOC_CTX *ctx, const struct loadparm_substitution *lp_sub, int i) \
1061 {return lpcfg_substituted_string((ctx), lp_sub, (LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1062 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1063 const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1064 #define FN_LOCAL_LIST(fn_name,val) \
1065 const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1066 #define FN_LOCAL_BOOL(fn_name,val) \
1067 bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1068 #define FN_LOCAL_INTEGER(fn_name,val) \
1069 int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1071 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1072 bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1073 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1074 int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1075 #define FN_LOCAL_PARM_CHAR(fn_name,val) \
1076 char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1078 int lp_winbind_max_domain_connections(void)
1080 if (lp_winbind_offline_logon() &&
1081 lp__winbind_max_domain_connections() > 1) {
1082 DEBUG(1, ("offline logons active, restricting max domain "
1083 "connections to 1\n"));
1086 return MAX(1, lp__winbind_max_domain_connections());
1089 /* These functions remain in source3/param for now */
1091 #include "lib/param/param_functions.c"
1093 FN_LOCAL_SUBSTITUTED_STRING(servicename
, szService
)
1094 FN_LOCAL_CONST_STRING(const_servicename
, szService
)
1096 /* These functions cannot be auto-generated */
1097 FN_LOCAL_BOOL(autoloaded
, autoloaded
)
1098 FN_GLOBAL_CONST_STRING(dnsdomain
, dnsdomain
)
1100 /* local prototypes */
1102 static int map_parameter_canonical(const char *pszParmName
, bool *inverse
);
1103 static const char *get_boolean(bool bool_value
);
1104 static bool do_parameter(const char *pszParmName
, const char *pszParmValue
,
1106 static bool hash_a_service(const char *name
, int number
);
1107 static void free_service_byindex(int iService
);
1108 static void show_parameter(int parmIndex
);
1109 static bool is_synonym_of(int parm1
, int parm2
, bool *inverse
);
1110 static bool lp_parameter_value_is_valid(const char *parm_name
, const char *val
);
1113 * This is a helper function for parametrical options support. It returns a
1114 * pointer to parametrical option value if it exists or NULL otherwise. Actual
1115 * parametrical functions are quite simple
1117 static struct parmlist_entry
*get_parametrics(int snum
, const char *type
,
1120 if (snum
>= iNumServices
) return NULL
;
1123 return get_parametric_helper(NULL
, type
, option
, Globals
.param_opt
);
1125 return get_parametric_helper(ServicePtrs
[snum
],
1126 type
, option
, Globals
.param_opt
);
1130 static void discard_whitespace(char *str
)
1132 size_t len
= strlen(str
);
1136 if (isspace(str
[i
])) {
1137 memmove(&str
[i
], &str
[i
+1], len
-i
);
1146 * @brief Go through all global parametric parameters
1148 * @param regex_str A regular expression to scan param for
1149 * @param max_matches Max number of submatches the regexp expects
1150 * @param cb Function to call on match. Should return true
1151 * when it wants wi_scan_global_parametrics to stop
1153 * @param private_data Anonymous pointer passed to cb
1155 * @return 0: success, regcomp/regexec return value on error.
1156 * See "man regexec" for possible errors
1159 int lp_wi_scan_global_parametrics(
1160 const char *regex_str
, size_t max_matches
,
1161 bool (*cb
)(const char *string
, regmatch_t matches
[],
1162 void *private_data
),
1165 struct parmlist_entry
*data
;
1169 ret
= regcomp(®ex
, regex_str
, REG_ICASE
);
1174 for (data
= Globals
.param_opt
; data
!= NULL
; data
= data
->next
) {
1175 size_t keylen
= strlen(data
->key
);
1177 regmatch_t matches
[max_matches
];
1180 memcpy(key
, data
->key
, sizeof(key
));
1181 discard_whitespace(key
);
1183 ret
= regexec(®ex
, key
, max_matches
, matches
, 0);
1184 if (ret
== REG_NOMATCH
) {
1191 stop
= cb(key
, matches
, private_data
);
1204 #define MISSING_PARAMETER(name) \
1205 DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
1207 /*******************************************************************
1208 convenience routine to return enum parameters.
1209 ********************************************************************/
1210 static int lp_enum(const char *s
,const struct enum_list
*_enum
)
1214 if (!s
|| !*s
|| !_enum
) {
1215 MISSING_PARAMETER(lp_enum
);
1219 for (i
=0; _enum
[i
].name
; i
++) {
1220 if (strequal(_enum
[i
].name
,s
))
1221 return _enum
[i
].value
;
1224 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s
));
1228 #undef MISSING_PARAMETER
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 char *lp_parm_substituted_string(TALLOC_CTX
*mem_ctx
,
1233 const struct loadparm_substitution
*lp_sub
,
1239 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1241 SMB_ASSERT(lp_sub
!= NULL
);
1243 if (data
== NULL
||data
->value
==NULL
) {
1245 return lpcfg_substituted_string(mem_ctx
, lp_sub
, def
);
1251 return lpcfg_substituted_string(mem_ctx
, lp_sub
, data
->value
);
1254 /* Return parametric option from a given service. Type is a part of option before ':' */
1255 /* Parametric option has following syntax: 'Type: option = value' */
1256 const char *lp_parm_const_string(int snum
, const char *type
, const char *option
, const char *def
)
1258 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1260 if (data
== NULL
||data
->value
==NULL
)
1267 /* Return parametric option from a given service. Type is a part of option before ':' */
1268 /* Parametric option has following syntax: 'Type: option = value' */
1270 const char **lp_parm_string_list(int snum
, const char *type
, const char *option
, const char **def
)
1272 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1274 if (data
== NULL
||data
->value
==NULL
)
1275 return (const char **)def
;
1277 if (data
->list
==NULL
) {
1278 data
->list
= str_list_make_v3(NULL
, data
->value
, NULL
);
1281 return discard_const_p(const char *, data
->list
);
1284 /* Return parametric option from a given service. Type is a part of option before ':' */
1285 /* Parametric option has following syntax: 'Type: option = value' */
1287 int lp_parm_int(int snum
, const char *type
, const char *option
, int def
)
1289 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1291 if (data
&& data
->value
&& *data
->value
)
1292 return lp_int(data
->value
);
1297 /* Return parametric option from a given service. Type is a part of option before ':' */
1298 /* Parametric option has following syntax: 'Type: option = value' */
1300 unsigned long lp_parm_ulong(int snum
, const char *type
, const char *option
, unsigned long def
)
1302 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1304 if (data
&& data
->value
&& *data
->value
)
1305 return lp_ulong(data
->value
);
1310 /* Return parametric option from a given service. Type is a part of option before ':' */
1311 /* Parametric option has following syntax: 'Type: option = value' */
1313 unsigned long long lp_parm_ulonglong(int snum
, const char *type
,
1314 const char *option
, unsigned long long def
)
1316 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1318 if (data
&& data
->value
&& *data
->value
) {
1319 return lp_ulonglong(data
->value
);
1325 /* Return parametric option from a given service. Type is a part of option
1327 /* Parametric option has following syntax: 'Type: option = value' */
1329 bool lp_parm_bool(int snum
, const char *type
, const char *option
, bool def
)
1331 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1333 if (data
&& data
->value
&& *data
->value
)
1334 return lp_bool(data
->value
);
1339 /* Return parametric option from a given service. Type is a part of option before ':' */
1340 /* Parametric option has following syntax: 'Type: option = value' */
1342 int lp_parm_enum(int snum
, const char *type
, const char *option
,
1343 const struct enum_list
*_enum
, int def
)
1345 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1347 if (data
&& data
->value
&& *data
->value
&& _enum
)
1348 return lp_enum(data
->value
, _enum
);
1354 * free a param_opts structure.
1355 * param_opts handling should be moved to talloc;
1356 * then this whole functions reduces to a TALLOC_FREE().
1359 static void free_param_opts(struct parmlist_entry
**popts
)
1361 struct parmlist_entry
*opt
, *next_opt
;
1363 if (*popts
!= NULL
) {
1364 DEBUG(5, ("Freeing parametrics:\n"));
1367 while (opt
!= NULL
) {
1368 lpcfg_string_free(&opt
->key
);
1369 lpcfg_string_free(&opt
->value
);
1370 TALLOC_FREE(opt
->list
);
1371 next_opt
= opt
->next
;
1378 /***************************************************************************
1379 Free the dynamically allocated parts of a service struct.
1380 ***************************************************************************/
1382 static void free_service(struct loadparm_service
*pservice
)
1387 if (pservice
->szService
)
1388 DEBUG(5, ("free_service: Freeing service %s\n",
1389 pservice
->szService
));
1391 free_parameters(pservice
);
1393 lpcfg_string_free(&pservice
->szService
);
1394 TALLOC_FREE(pservice
->copymap
);
1396 free_param_opts(&pservice
->param_opt
);
1398 ZERO_STRUCTP(pservice
);
1402 /***************************************************************************
1403 remove a service indexed in the ServicePtrs array from the ServiceHash
1404 and free the dynamically allocated parts
1405 ***************************************************************************/
1407 static void free_service_byindex(int idx
)
1409 if ( !LP_SNUM_OK(idx
) )
1412 ServicePtrs
[idx
]->valid
= false;
1414 /* we have to cleanup the hash record */
1416 if (ServicePtrs
[idx
]->szService
) {
1417 char *canon_name
= canonicalize_servicename(
1419 ServicePtrs
[idx
]->szService
);
1421 dbwrap_delete_bystring(ServiceHash
, canon_name
);
1422 TALLOC_FREE(canon_name
);
1425 free_service(ServicePtrs
[idx
]);
1426 TALLOC_FREE(ServicePtrs
[idx
]);
1429 /***************************************************************************
1430 Add a new service to the services array initialising it with the given
1432 ***************************************************************************/
1434 static int add_a_service(const struct loadparm_service
*pservice
, const char *name
)
1437 struct loadparm_service
**tsp
= NULL
;
1439 /* it might already exist */
1441 i
= getservicebyname(name
, NULL
);
1447 /* Re use empty slots if any before allocating new one.*/
1448 for (i
=0; i
< iNumServices
; i
++) {
1449 if (ServicePtrs
[i
] == NULL
) {
1453 if (i
== iNumServices
) {
1454 /* if not, then create one */
1455 tsp
= talloc_realloc(NULL
, ServicePtrs
,
1456 struct loadparm_service
*,
1459 DEBUG(0, ("add_a_service: failed to enlarge "
1466 ServicePtrs
[i
] = talloc_zero(ServicePtrs
, struct loadparm_service
);
1467 if (!ServicePtrs
[i
]) {
1468 DEBUG(0,("add_a_service: out of memory!\n"));
1472 ServicePtrs
[i
]->valid
= true;
1474 copy_service(ServicePtrs
[i
], pservice
, NULL
);
1476 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->szService
,
1479 DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
1480 i
, ServicePtrs
[i
]->szService
));
1482 if (!hash_a_service(ServicePtrs
[i
]->szService
, i
)) {
1489 /***************************************************************************
1490 Convert a string to uppercase and remove whitespaces.
1491 ***************************************************************************/
1493 char *canonicalize_servicename(TALLOC_CTX
*ctx
, const char *src
)
1498 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
1502 result
= talloc_strdup(ctx
, src
);
1503 SMB_ASSERT(result
!= NULL
);
1505 if (!strlower_m(result
)) {
1506 TALLOC_FREE(result
);
1512 /***************************************************************************
1513 Add a name/index pair for the services array to the hash table.
1514 ***************************************************************************/
1516 static bool hash_a_service(const char *name
, int idx
)
1520 if ( !ServiceHash
) {
1521 DEBUG(10,("hash_a_service: creating servicehash\n"));
1522 ServiceHash
= db_open_rbt(NULL
);
1523 if ( !ServiceHash
) {
1524 DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
1529 DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
1532 canon_name
= canonicalize_servicename(talloc_tos(), name
);
1534 dbwrap_store_bystring(ServiceHash
, canon_name
,
1535 make_tdb_data((uint8_t *)&idx
, sizeof(idx
)),
1538 TALLOC_FREE(canon_name
);
1543 /***************************************************************************
1544 Add a new home service, with the specified home directory, defaults coming
1546 ***************************************************************************/
1548 bool lp_add_home(const char *pszHomename
, int iDefaultService
,
1549 const char *user
, const char *pszHomedir
)
1551 const struct loadparm_substitution
*lp_sub
=
1552 loadparm_s3_global_substitution();
1556 if (pszHomename
== NULL
|| user
== NULL
|| pszHomedir
== NULL
||
1557 pszHomedir
[0] == '\0') {
1561 i
= add_a_service(ServicePtrs
[iDefaultService
], pszHomename
);
1566 global_path
= lp_path(talloc_tos(), lp_sub
, GLOBAL_SECTION_SNUM
);
1567 if (!(*(ServicePtrs
[iDefaultService
]->path
))
1568 || strequal(ServicePtrs
[iDefaultService
]->path
, global_path
)) {
1569 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->path
,
1572 TALLOC_FREE(global_path
);
1574 if (!(*(ServicePtrs
[i
]->comment
))) {
1575 char *comment
= talloc_asprintf(talloc_tos(), "Home directory of %s", user
);
1576 if (comment
== NULL
) {
1579 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->comment
,
1581 TALLOC_FREE(comment
);
1584 /* set the browseable flag from the global default */
1586 ServicePtrs
[i
]->browseable
= sDefault
.browseable
;
1587 ServicePtrs
[i
]->access_based_share_enum
= sDefault
.access_based_share_enum
;
1589 ServicePtrs
[i
]->autoloaded
= true;
1591 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename
,
1592 user
, ServicePtrs
[i
]->path
));
1597 /***************************************************************************
1598 Add a new service, based on an old one.
1599 ***************************************************************************/
1601 int lp_add_service(const char *pszService
, int iDefaultService
)
1603 if (iDefaultService
< 0) {
1604 return add_a_service(&sDefault
, pszService
);
1607 return (add_a_service(ServicePtrs
[iDefaultService
], pszService
));
1610 /***************************************************************************
1611 Add the IPC service.
1612 ***************************************************************************/
1614 static bool lp_add_ipc(const char *ipc_name
, bool guest_ok
)
1616 char *comment
= NULL
;
1617 int i
= add_a_service(&sDefault
, ipc_name
);
1622 comment
= talloc_asprintf(talloc_tos(), "IPC Service (%s)",
1623 Globals
.server_string
);
1624 if (comment
== NULL
) {
1628 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->path
, tmpdir());
1629 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->comment
, comment
);
1630 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->fstype
, "IPC");
1631 ServicePtrs
[i
]->max_connections
= 0;
1632 ServicePtrs
[i
]->available
= true;
1633 ServicePtrs
[i
]->read_only
= true;
1634 ServicePtrs
[i
]->guest_only
= false;
1635 ServicePtrs
[i
]->administrative_share
= true;
1636 ServicePtrs
[i
]->guest_ok
= guest_ok
;
1637 ServicePtrs
[i
]->printable
= false;
1638 ServicePtrs
[i
]->browseable
= sDefault
.browseable
;
1639 ServicePtrs
[i
]->autoloaded
= false;
1641 DEBUG(3, ("adding IPC service\n"));
1643 TALLOC_FREE(comment
);
1647 /***************************************************************************
1648 Add a new printer service, with defaults coming from service iFrom.
1649 ***************************************************************************/
1651 bool lp_add_printer(const char *pszPrintername
, int iDefaultService
)
1653 const char *comment
= "From Printcap";
1654 int i
= add_a_service(ServicePtrs
[iDefaultService
], pszPrintername
);
1659 /* note that we do NOT default the availability flag to true - */
1660 /* we take it from the default service passed. This allows all */
1661 /* dynamic printers to be disabled by disabling the [printers] */
1662 /* entry (if/when the 'available' keyword is implemented!). */
1664 /* the printer name is set to the service name. */
1665 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->_printername
,
1667 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->comment
, comment
);
1669 /* set the browseable flag from the gloabl default */
1670 ServicePtrs
[i
]->browseable
= sDefault
.browseable
;
1672 /* Printers cannot be read_only. */
1673 ServicePtrs
[i
]->read_only
= false;
1674 /* No oplocks on printer services. */
1675 ServicePtrs
[i
]->oplocks
= false;
1676 /* Printer services must be printable. */
1677 ServicePtrs
[i
]->printable
= true;
1679 DEBUG(3, ("adding printer service %s\n", pszPrintername
));
1685 /***************************************************************************
1686 Check whether the given parameter name is valid.
1687 Parametric options (names containing a colon) are considered valid.
1688 ***************************************************************************/
1690 bool lp_parameter_is_valid(const char *pszParmName
)
1692 return ((lpcfg_map_parameter(pszParmName
) != -1) ||
1693 (strchr(pszParmName
, ':') != NULL
));
1696 /***************************************************************************
1697 Check whether the given name is the name of a global parameter.
1698 Returns true for strings belonging to parameters of class
1699 P_GLOBAL, false for all other strings, also for parametric options
1700 and strings not belonging to any option.
1701 ***************************************************************************/
1703 bool lp_parameter_is_global(const char *pszParmName
)
1705 int num
= lpcfg_map_parameter(pszParmName
);
1708 return (parm_table
[num
].p_class
== P_GLOBAL
);
1714 /**************************************************************************
1715 Determine the canonical name for a parameter.
1716 Indicate when it is an inverse (boolean) synonym instead of a
1718 **************************************************************************/
1720 bool lp_canonicalize_parameter(const char *parm_name
, const char **canon_parm
,
1725 if (!lp_parameter_is_valid(parm_name
)) {
1730 num
= map_parameter_canonical(parm_name
, inverse
);
1732 /* parametric option */
1733 *canon_parm
= parm_name
;
1735 *canon_parm
= parm_table
[num
].label
;
1742 /**************************************************************************
1743 Determine the canonical name for a parameter.
1744 Turn the value given into the inverse boolean expression when
1745 the synonym is an invers boolean synonym.
1748 - parm_name is a valid parameter name and
1749 - val is a valid value for this parameter and
1750 - in case the parameter is an inverse boolean synonym, if the val
1751 string could successfully be converted to the reverse bool.
1752 Return false in all other cases.
1753 **************************************************************************/
1755 bool lp_canonicalize_parameter_with_value(const char *parm_name
,
1757 const char **canon_parm
,
1758 const char **canon_val
)
1764 if (!lp_parameter_is_valid(parm_name
)) {
1770 num
= map_parameter_canonical(parm_name
, &inverse
);
1772 /* parametric option */
1773 *canon_parm
= parm_name
;
1778 *canon_parm
= parm_table
[num
].label
;
1780 if (!lp_invert_boolean(val
, canon_val
)) {
1788 ret
= lp_parameter_value_is_valid(*canon_parm
, *canon_val
);
1793 /***************************************************************************
1794 Map a parameter's string representation to the index of the canonical
1795 form of the parameter (it might be a synonym).
1796 Returns -1 if the parameter string is not recognised.
1797 ***************************************************************************/
1799 static int map_parameter_canonical(const char *pszParmName
, bool *inverse
)
1801 int parm_num
, canon_num
;
1802 bool loc_inverse
= false;
1804 parm_num
= lpcfg_map_parameter(pszParmName
);
1805 if ((parm_num
< 0) || !(parm_table
[parm_num
].flags
& FLAG_SYNONYM
)) {
1806 /* invalid, parametric or no canidate for synonyms ... */
1810 for (canon_num
= 0; parm_table
[canon_num
].label
; canon_num
++) {
1811 if (is_synonym_of(parm_num
, canon_num
, &loc_inverse
)) {
1812 parm_num
= canon_num
;
1818 if (inverse
!= NULL
) {
1819 *inverse
= loc_inverse
;
1824 /***************************************************************************
1825 return true if parameter number parm1 is a synonym of parameter
1826 number parm2 (parm2 being the principal name).
1827 set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
1829 ***************************************************************************/
1831 static bool is_synonym_of(int parm1
, int parm2
, bool *inverse
)
1833 if ((parm_table
[parm1
].offset
== parm_table
[parm2
].offset
) &&
1834 (parm_table
[parm1
].p_class
== parm_table
[parm2
].p_class
) &&
1835 (parm_table
[parm1
].flags
& FLAG_SYNONYM
) &&
1836 !(parm_table
[parm2
].flags
& FLAG_SYNONYM
))
1838 if (inverse
!= NULL
) {
1839 if ((parm_table
[parm1
].type
== P_BOOLREV
) &&
1840 (parm_table
[parm2
].type
== P_BOOL
))
1852 /***************************************************************************
1853 Show one parameter's name, type, [values,] and flags.
1854 (helper functions for show_parameter_list)
1855 ***************************************************************************/
1857 static void show_parameter(int parmIndex
)
1859 size_t enumIndex
, flagIndex
;
1864 const char *type
[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
1865 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
1866 "P_ENUM", "P_BYTES", "P_CMDLIST" };
1867 unsigned flags
[] = { FLAG_DEPRECATED
, FLAG_SYNONYM
};
1868 const char *flag_names
[] = { "FLAG_DEPRECATED", "FLAG_SYNONYM", NULL
};
1870 printf("%s=%s", parm_table
[parmIndex
].label
,
1871 type
[parm_table
[parmIndex
].type
]);
1872 if (parm_table
[parmIndex
].type
== P_ENUM
) {
1875 parm_table
[parmIndex
].enum_list
[enumIndex
].name
;
1879 enumIndex
? "|" : "",
1880 parm_table
[parmIndex
].enum_list
[enumIndex
].name
);
1885 for (flagIndex
=0; flag_names
[flagIndex
]; flagIndex
++) {
1886 if (parm_table
[parmIndex
].flags
& flags
[flagIndex
]) {
1889 flag_names
[flagIndex
]);
1894 /* output synonyms */
1896 for (parmIndex2
=0; parm_table
[parmIndex2
].label
; parmIndex2
++) {
1897 if (is_synonym_of(parmIndex
, parmIndex2
, &inverse
)) {
1898 printf(" (%ssynonym of %s)", inverse
? "inverse " : "",
1899 parm_table
[parmIndex2
].label
);
1900 } else if (is_synonym_of(parmIndex2
, parmIndex
, &inverse
)) {
1902 printf(" (synonyms: ");
1907 printf("%s%s", parm_table
[parmIndex2
].label
,
1908 inverse
? "[i]" : "");
1919 * Check the value for a P_ENUM
1921 static bool check_enum_parameter(struct parm_struct
*parm
, const char *value
)
1925 for (i
= 0; parm
->enum_list
[i
].name
; i
++) {
1926 if (strwicmp(value
, parm
->enum_list
[i
].name
) == 0) {
1933 /**************************************************************************
1934 Check whether the given value is valid for the given parameter name.
1935 **************************************************************************/
1937 static bool lp_parameter_value_is_valid(const char *parm_name
, const char *val
)
1939 bool ret
= false, tmp_bool
;
1940 int num
= lpcfg_map_parameter(parm_name
), tmp_int
;
1941 uint64_t tmp_int64
= 0;
1942 struct parm_struct
*parm
;
1944 /* parametric options (parameter names containing a colon) cannot
1945 be checked and are therefore considered valid. */
1946 if (strchr(parm_name
, ':') != NULL
) {
1951 parm
= &parm_table
[num
];
1952 switch (parm
->type
) {
1955 ret
= set_boolean(val
, &tmp_bool
);
1959 ret
= (sscanf(val
, "%d", &tmp_int
) == 1);
1963 ret
= (sscanf(val
, "%o", &tmp_int
) == 1);
1967 ret
= check_enum_parameter(parm
, val
);
1971 if (conv_str_size_error(val
, &tmp_int64
) &&
1972 tmp_int64
<= INT_MAX
) {
1989 /***************************************************************************
1990 Show all parameter's name, type, [values,] and flags.
1991 ***************************************************************************/
1993 void show_parameter_list(void)
1995 int classIndex
, parmIndex
;
1996 const char *section_names
[] = { "local", "global", NULL
};
1998 for (classIndex
=0; section_names
[classIndex
]; classIndex
++) {
1999 printf("[%s]\n", section_names
[classIndex
]);
2000 for (parmIndex
= 0; parm_table
[parmIndex
].label
; parmIndex
++) {
2001 if (parm_table
[parmIndex
].p_class
== classIndex
) {
2002 show_parameter(parmIndex
);
2008 /***************************************************************************
2009 Get the standard string representation of a boolean value ("yes" or "no")
2010 ***************************************************************************/
2012 static const char *get_boolean(bool bool_value
)
2014 static const char *yes_str
= "yes";
2015 static const char *no_str
= "no";
2017 return (bool_value
? yes_str
: no_str
);
2020 /***************************************************************************
2021 Provide the string of the negated boolean value associated to the boolean
2022 given as a string. Returns false if the passed string does not correctly
2023 represent a boolean.
2024 ***************************************************************************/
2026 bool lp_invert_boolean(const char *str
, const char **inverse_str
)
2030 if (!set_boolean(str
, &val
)) {
2034 *inverse_str
= get_boolean(!val
);
2038 /***************************************************************************
2039 Provide the canonical string representation of a boolean value given
2040 as a string. Return true on success, false if the string given does
2041 not correctly represent a boolean.
2042 ***************************************************************************/
2044 bool lp_canonicalize_boolean(const char *str
, const char**canon_str
)
2048 if (!set_boolean(str
, &val
)) {
2052 *canon_str
= get_boolean(val
);
2056 /***************************************************************************
2057 Find a service by name. Otherwise works like get_service.
2058 ***************************************************************************/
2060 int getservicebyname(const char *pszServiceName
, struct loadparm_service
*pserviceDest
)
2067 if (ServiceHash
== NULL
) {
2071 canon_name
= canonicalize_servicename(talloc_tos(), pszServiceName
);
2073 status
= dbwrap_fetch_bystring(ServiceHash
, canon_name
, canon_name
,
2076 if (NT_STATUS_IS_OK(status
) &&
2077 (data
.dptr
!= NULL
) &&
2078 (data
.dsize
== sizeof(iService
)))
2080 memcpy(&iService
, data
.dptr
, sizeof(iService
));
2083 TALLOC_FREE(canon_name
);
2085 if ((iService
!= -1) && (LP_SNUM_OK(iService
))
2086 && (pserviceDest
!= NULL
)) {
2087 copy_service(pserviceDest
, ServicePtrs
[iService
], NULL
);
2093 /* Return a pointer to a service by name. Unlike getservicebyname, it does not copy the service */
2094 struct loadparm_service
*lp_service(const char *pszServiceName
)
2096 int iService
= getservicebyname(pszServiceName
, NULL
);
2097 if (iService
== -1 || !LP_SNUM_OK(iService
)) {
2100 return ServicePtrs
[iService
];
2103 struct loadparm_service
*lp_servicebynum(int snum
)
2105 if ((snum
== -1) || !LP_SNUM_OK(snum
)) {
2108 return ServicePtrs
[snum
];
2111 struct loadparm_service
*lp_default_loadparm_service()
2116 static struct smbconf_ctx
*lp_smbconf_ctx(void)
2119 static struct smbconf_ctx
*conf_ctx
= NULL
;
2121 if (conf_ctx
== NULL
) {
2122 err
= smbconf_init(NULL
, &conf_ctx
, "registry:");
2123 if (!SBC_ERROR_IS_OK(err
)) {
2124 DEBUG(1, ("error initializing registry configuration: "
2125 "%s\n", sbcErrorString(err
)));
2133 static bool process_smbconf_service(struct smbconf_service
*service
)
2138 if (service
== NULL
) {
2142 ret
= lp_do_section(service
->name
, NULL
);
2146 for (count
= 0; count
< service
->num_params
; count
++) {
2148 if (!bInGlobalSection
&& bGlobalOnly
) {
2151 const char *pszParmName
= service
->param_names
[count
];
2152 const char *pszParmValue
= service
->param_values
[count
];
2154 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName
, pszParmValue
));
2156 ret
= lp_do_parameter(bInGlobalSection
? -2 : iServiceIndex
,
2157 pszParmName
, pszParmValue
);
2164 if (iServiceIndex
>= 0) {
2165 return lpcfg_service_ok(ServicePtrs
[iServiceIndex
]);
2171 * load a service from registry and activate it
2173 bool process_registry_service(const char *service_name
)
2176 struct smbconf_service
*service
= NULL
;
2177 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
2178 struct smbconf_ctx
*conf_ctx
= lp_smbconf_ctx();
2181 if (conf_ctx
== NULL
) {
2185 DEBUG(5, ("process_registry_service: service name %s\n", service_name
));
2187 if (!smbconf_share_exists(conf_ctx
, service_name
)) {
2189 * Registry does not contain data for this service (yet),
2190 * but make sure lp_load doesn't return false.
2196 err
= smbconf_get_share(conf_ctx
, mem_ctx
, service_name
, &service
);
2197 if (!SBC_ERROR_IS_OK(err
)) {
2201 ret
= process_smbconf_service(service
);
2207 smbconf_changed(conf_ctx
, &conf_last_csn
, NULL
, NULL
);
2210 TALLOC_FREE(mem_ctx
);
2215 * process_registry_globals
2217 static bool process_registry_globals(void)
2221 add_to_file_list(NULL
, &file_lists
, INCLUDE_REGISTRY_NAME
, INCLUDE_REGISTRY_NAME
);
2223 if (!bInGlobalSection
&& bGlobalOnly
) {
2226 const char *pszParmName
= "registry shares";
2227 const char *pszParmValue
= "yes";
2229 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName
, pszParmValue
));
2231 ret
= lp_do_parameter(bInGlobalSection
? -2 : iServiceIndex
,
2232 pszParmName
, pszParmValue
);
2239 return process_registry_service(GLOBAL_NAME
);
2242 bool process_registry_shares(void)
2246 struct smbconf_service
**service
= NULL
;
2247 uint32_t num_shares
= 0;
2248 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
2249 struct smbconf_ctx
*conf_ctx
= lp_smbconf_ctx();
2252 if (conf_ctx
== NULL
) {
2256 err
= smbconf_get_config(conf_ctx
, mem_ctx
, &num_shares
, &service
);
2257 if (!SBC_ERROR_IS_OK(err
)) {
2263 for (count
= 0; count
< num_shares
; count
++) {
2264 if (strequal(service
[count
]->name
, GLOBAL_NAME
)) {
2267 ret
= process_smbconf_service(service
[count
]);
2274 smbconf_changed(conf_ctx
, &conf_last_csn
, NULL
, NULL
);
2277 TALLOC_FREE(mem_ctx
);
2282 * reload those shares from registry that are already
2283 * activated in the services array.
2285 static bool reload_registry_shares(void)
2290 for (i
= 0; i
< iNumServices
; i
++) {
2295 if (ServicePtrs
[i
]->usershare
== USERSHARE_VALID
) {
2299 ret
= process_registry_service(ServicePtrs
[i
]->szService
);
2310 #define MAX_INCLUDE_DEPTH 100
2312 static uint8_t include_depth
;
2315 * Free the file lists
2317 static void free_file_list(void)
2319 struct file_lists
*f
;
2320 struct file_lists
*next
;
2333 * Utility function for outsiders to check if we're running on registry.
2335 bool lp_config_backend_is_registry(void)
2337 return (lp_config_backend() == CONFIG_BACKEND_REGISTRY
);
2341 * Utility function to check if the config backend is FILE.
2343 bool lp_config_backend_is_file(void)
2345 return (lp_config_backend() == CONFIG_BACKEND_FILE
);
2348 /*******************************************************************
2349 Check if a config file has changed date.
2350 ********************************************************************/
2352 bool lp_file_list_changed(void)
2354 struct file_lists
*f
= file_lists
;
2356 DEBUG(6, ("lp_file_list_changed()\n"));
2359 if (strequal(f
->name
, INCLUDE_REGISTRY_NAME
)) {
2360 struct smbconf_ctx
*conf_ctx
= lp_smbconf_ctx();
2362 if (conf_ctx
== NULL
) {
2365 if (smbconf_changed(conf_ctx
, &conf_last_csn
, NULL
,
2368 DEBUGADD(6, ("registry config changed\n"));
2375 n2
= talloc_sub_basic(talloc_tos(),
2376 get_current_username(),
2377 current_user_info
.domain
,
2382 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
2383 f
->name
, n2
, ctime(&f
->modtime
)));
2385 mod_time
= file_modtime(n2
);
2388 ((f
->modtime
!= mod_time
) ||
2389 (f
->subfname
== NULL
) ||
2390 (strcmp(n2
, f
->subfname
) != 0)))
2393 ("file %s modified: %s\n", n2
,
2395 f
->modtime
= mod_time
;
2396 TALLOC_FREE(f
->subfname
);
2397 f
->subfname
= talloc_strdup(f
, n2
);
2398 if (f
->subfname
== NULL
) {
2399 smb_panic("talloc_strdup failed");
2413 * Initialize iconv conversion descriptors.
2415 * This is called the first time it is needed, and also called again
2416 * every time the configuration is reloaded, because the charset or
2417 * codepage might have changed.
2419 static void init_iconv(void)
2421 struct smb_iconv_handle
*ret
= NULL
;
2423 ret
= reinit_iconv_handle(NULL
,
2427 smb_panic("reinit_iconv_handle failed");
2431 /***************************************************************************
2432 Handle the include operation.
2433 ***************************************************************************/
2434 static bool bAllowIncludeRegistry
= true;
2436 bool lp_include(struct loadparm_context
*lp_ctx
, struct loadparm_service
*service
,
2437 const char *pszParmValue
, char **ptr
)
2441 if (include_depth
>= MAX_INCLUDE_DEPTH
) {
2442 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
2447 if (strequal(pszParmValue
, INCLUDE_REGISTRY_NAME
)) {
2448 if (!bAllowIncludeRegistry
) {
2451 if (lp_ctx
->bInGlobalSection
) {
2454 ret
= process_registry_globals();
2458 DEBUG(1, ("\"include = registry\" only effective "
2459 "in %s section\n", GLOBAL_NAME
));
2464 fname
= talloc_sub_basic(talloc_tos(), get_current_username(),
2465 current_user_info
.domain
,
2468 add_to_file_list(NULL
, &file_lists
, pszParmValue
, fname
);
2470 if (service
== NULL
) {
2471 lpcfg_string_set(Globals
.ctx
, ptr
, fname
);
2473 lpcfg_string_set(service
, ptr
, fname
);
2476 if (file_exist(fname
)) {
2479 ret
= pm_process(fname
, lp_do_section
, do_parameter
, lp_ctx
);
2485 DEBUG(2, ("Can't find include file %s\n", fname
));
2490 bool lp_idmap_range(const char *domain_name
, uint32_t *low
, uint32_t *high
)
2492 char *config_option
= NULL
;
2493 const char *range
= NULL
;
2496 SMB_ASSERT(low
!= NULL
);
2497 SMB_ASSERT(high
!= NULL
);
2499 if ((domain_name
== NULL
) || (domain_name
[0] == '\0')) {
2503 config_option
= talloc_asprintf(talloc_tos(), "idmap config %s",
2505 if (config_option
== NULL
) {
2506 DEBUG(0, ("out of memory\n"));
2510 range
= lp_parm_const_string(-1, config_option
, "range", NULL
);
2511 if (range
== NULL
) {
2512 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name
));
2516 if (sscanf(range
, "%u - %u", low
, high
) != 2) {
2517 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2518 range
, domain_name
));
2525 talloc_free(config_option
);
2530 bool lp_idmap_default_range(uint32_t *low
, uint32_t *high
)
2532 return lp_idmap_range("*", low
, high
);
2535 const char *lp_idmap_backend(const char *domain_name
)
2537 char *config_option
= NULL
;
2538 const char *backend
= NULL
;
2540 if ((domain_name
== NULL
) || (domain_name
[0] == '\0')) {
2544 config_option
= talloc_asprintf(talloc_tos(), "idmap config %s",
2546 if (config_option
== NULL
) {
2547 DEBUG(0, ("out of memory\n"));
2551 backend
= lp_parm_const_string(-1, config_option
, "backend", NULL
);
2552 if (backend
== NULL
) {
2553 DEBUG(1, ("idmap backend not specified for domain '%s'\n", domain_name
));
2558 talloc_free(config_option
);
2562 const char *lp_idmap_default_backend(void)
2564 return lp_idmap_backend("*");
2567 /***************************************************************************
2568 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2569 ***************************************************************************/
2571 static const char *append_ldap_suffix(TALLOC_CTX
*ctx
, const char *str
)
2573 const char *suffix_string
;
2575 suffix_string
= talloc_asprintf(ctx
, "%s,%s", str
,
2576 Globals
.ldap_suffix
);
2577 if ( !suffix_string
) {
2578 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2582 return suffix_string
;
2585 const char *lp_ldap_machine_suffix(TALLOC_CTX
*ctx
)
2587 if (Globals
._ldap_machine_suffix
[0])
2588 return append_ldap_suffix(ctx
, Globals
._ldap_machine_suffix
);
2590 return talloc_strdup(ctx
, Globals
.ldap_suffix
);
2593 const char *lp_ldap_user_suffix(TALLOC_CTX
*ctx
)
2595 if (Globals
._ldap_user_suffix
[0])
2596 return append_ldap_suffix(ctx
, Globals
._ldap_user_suffix
);
2598 return talloc_strdup(ctx
, Globals
.ldap_suffix
);
2601 const char *lp_ldap_group_suffix(TALLOC_CTX
*ctx
)
2603 if (Globals
._ldap_group_suffix
[0])
2604 return append_ldap_suffix(ctx
, Globals
._ldap_group_suffix
);
2606 return talloc_strdup(ctx
, Globals
.ldap_suffix
);
2609 const char *lp_ldap_idmap_suffix(TALLOC_CTX
*ctx
)
2611 if (Globals
._ldap_idmap_suffix
[0])
2612 return append_ldap_suffix(ctx
, Globals
._ldap_idmap_suffix
);
2614 return talloc_strdup(ctx
, Globals
.ldap_suffix
);
2618 return the parameter pointer for a parameter
2620 void *lp_parm_ptr(struct loadparm_service
*service
, struct parm_struct
*parm
)
2622 if (service
== NULL
) {
2623 if (parm
->p_class
== P_LOCAL
)
2624 return (void *)(((char *)&sDefault
)+parm
->offset
);
2625 else if (parm
->p_class
== P_GLOBAL
)
2626 return (void *)(((char *)&Globals
)+parm
->offset
);
2629 return (void *)(((char *)service
) + parm
->offset
);
2633 /***************************************************************************
2634 Process a parameter for a particular service number. If snum < 0
2635 then assume we are in the globals.
2636 ***************************************************************************/
2638 bool lp_do_parameter(int snum
, const char *pszParmName
, const char *pszParmValue
)
2640 TALLOC_CTX
*frame
= talloc_stackframe();
2641 struct loadparm_context
*lp_ctx
;
2644 lp_ctx
= setup_lp_context(frame
);
2645 if (lp_ctx
== NULL
) {
2651 ok
= lpcfg_do_global_parameter(lp_ctx
, pszParmName
, pszParmValue
);
2653 ok
= lpcfg_do_service_parameter(lp_ctx
, ServicePtrs
[snum
],
2654 pszParmName
, pszParmValue
);
2662 /***************************************************************************
2663 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
2664 FLAG_CMDLINE won't be overridden by loads from smb.conf.
2665 ***************************************************************************/
2667 static bool lp_set_cmdline_helper(const char *pszParmName
, const char *pszParmValue
)
2670 parmnum
= lpcfg_map_parameter(pszParmName
);
2672 flags_list
[parmnum
] &= ~FLAG_CMDLINE
;
2673 if (!lp_do_parameter(-1, pszParmName
, pszParmValue
)) {
2676 flags_list
[parmnum
] |= FLAG_CMDLINE
;
2678 /* we have to also set FLAG_CMDLINE on aliases. Aliases must
2679 * be grouped in the table, so we don't have to search the
2682 i
>=0 && parm_table
[i
].offset
== parm_table
[parmnum
].offset
2683 && parm_table
[i
].p_class
== parm_table
[parmnum
].p_class
;
2685 flags_list
[i
] |= FLAG_CMDLINE
;
2687 for (i
=parmnum
+1;i
<num_parameters() && parm_table
[i
].offset
== parm_table
[parmnum
].offset
2688 && parm_table
[i
].p_class
== parm_table
[parmnum
].p_class
;i
++) {
2689 flags_list
[i
] |= FLAG_CMDLINE
;
2695 /* it might be parametric */
2696 if (strchr(pszParmName
, ':') != NULL
) {
2697 set_param_opt(NULL
, &Globals
.param_opt
, pszParmName
, pszParmValue
, FLAG_CMDLINE
);
2701 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName
));
2705 bool lp_set_cmdline(const char *pszParmName
, const char *pszParmValue
)
2708 TALLOC_CTX
*frame
= talloc_stackframe();
2709 struct loadparm_context
*lp_ctx
;
2711 lp_ctx
= setup_lp_context(frame
);
2712 if (lp_ctx
== NULL
) {
2717 ret
= lpcfg_set_cmdline(lp_ctx
, pszParmName
, pszParmValue
);
2723 /***************************************************************************
2724 Process a parameter.
2725 ***************************************************************************/
2727 static bool do_parameter(const char *pszParmName
, const char *pszParmValue
,
2730 if (!bInGlobalSection
&& bGlobalOnly
)
2733 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName
, pszParmValue
));
2735 if (bInGlobalSection
) {
2736 return lpcfg_do_global_parameter(userdata
, pszParmName
, pszParmValue
);
2738 return lpcfg_do_service_parameter(userdata
, ServicePtrs
[iServiceIndex
],
2739 pszParmName
, pszParmValue
);
2744 static const char *ad_dc_req_vfs_mods
[] = {"dfs_samba4", "acl_xattr", NULL
};
2747 * check that @vfs_objects includes all vfs modules required by an AD DC.
2749 static bool check_ad_dc_required_mods(const char **vfs_objects
)
2755 for (i
= 0; ad_dc_req_vfs_mods
[i
] != NULL
; i
++) {
2757 for (j
= 0; vfs_objects
[j
] != NULL
; j
++) {
2758 if (!strwicmp(ad_dc_req_vfs_mods
[i
], vfs_objects
[j
])) {
2764 DEBUG(0, ("vfs objects specified without required AD "
2765 "DC module: %s\n", ad_dc_req_vfs_mods
[i
]));
2770 DEBUG(6, ("vfs objects specified with all required AD DC modules\n"));
2775 /***************************************************************************
2776 Initialize any local variables in the sDefault table, after parsing a
2778 ***************************************************************************/
2780 static void init_locals(void)
2783 * We run this check once the [globals] is parsed, to force
2784 * the VFS objects and other per-share settings we need for
2785 * the standard way a AD DC is operated. We may change these
2786 * as our code evolves, which is why we force these settings.
2788 * We can't do this at the end of lp_load_ex(), as by that
2789 * point the services have been loaded and they will already
2790 * have "" as their vfs objects.
2792 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
) {
2793 const char **vfs_objects
= lp_vfs_objects(-1);
2794 if (vfs_objects
!= NULL
) {
2795 /* ignore return, only warn if modules are missing */
2796 check_ad_dc_required_mods(vfs_objects
);
2798 if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL
)) {
2799 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
2800 } else if (lp_parm_const_string(-1, "posix", "eadb", NULL
)) {
2801 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
2803 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
2807 lp_do_parameter(-1, "map hidden", "no");
2808 lp_do_parameter(-1, "map system", "no");
2809 lp_do_parameter(-1, "map readonly", "no");
2810 lp_do_parameter(-1, "map archive", "no");
2811 lp_do_parameter(-1, "store dos attributes", "yes");
2815 /***************************************************************************
2816 Process a new section (service). At this stage all sections are services.
2817 Later we'll have special sections that permit server parameters to be set.
2818 Returns true on success, false on failure.
2819 ***************************************************************************/
2821 bool lp_do_section(const char *pszSectionName
, void *userdata
)
2823 struct loadparm_context
*lp_ctx
= (struct loadparm_context
*)userdata
;
2825 bool isglobal
= ((strwicmp(pszSectionName
, GLOBAL_NAME
) == 0) ||
2826 (strwicmp(pszSectionName
, GLOBAL_NAME2
) == 0));
2828 /* if we were in a global section then do the local inits */
2829 if (bInGlobalSection
&& !isglobal
)
2832 /* if we've just struck a global section, note the fact. */
2833 bInGlobalSection
= isglobal
;
2834 if (lp_ctx
!= NULL
) {
2835 lp_ctx
->bInGlobalSection
= isglobal
;
2838 /* check for multiple global sections */
2839 if (bInGlobalSection
) {
2840 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName
));
2844 if (!bInGlobalSection
&& bGlobalOnly
)
2847 /* if we have a current service, tidy it up before moving on */
2850 if (iServiceIndex
>= 0)
2851 bRetval
= lpcfg_service_ok(ServicePtrs
[iServiceIndex
]);
2853 /* if all is still well, move to the next record in the services array */
2855 /* We put this here to avoid an odd message order if messages are */
2856 /* issued by the post-processing of a previous section. */
2857 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName
));
2859 iServiceIndex
= add_a_service(&sDefault
, pszSectionName
);
2860 if (iServiceIndex
< 0) {
2861 DEBUG(0, ("Failed to add a new service\n"));
2864 /* Clean all parametric options for service */
2865 /* They will be added during parsing again */
2866 free_param_opts(&ServicePtrs
[iServiceIndex
]->param_opt
);
2872 /***************************************************************************
2873 Display the contents of a parameter of a single services record.
2874 ***************************************************************************/
2876 bool dump_a_parameter(int snum
, char *parm_name
, FILE * f
, bool isGlobal
)
2878 bool result
= false;
2879 struct loadparm_context
*lp_ctx
;
2881 lp_ctx
= setup_lp_context(talloc_tos());
2882 if (lp_ctx
== NULL
) {
2887 result
= lpcfg_dump_a_parameter(lp_ctx
, NULL
, parm_name
, f
);
2889 result
= lpcfg_dump_a_parameter(lp_ctx
, ServicePtrs
[snum
], parm_name
, f
);
2891 TALLOC_FREE(lp_ctx
);
2896 /***************************************************************************
2897 Display the contents of a single copy structure.
2898 ***************************************************************************/
2899 static void dump_copy_map(bool *pcopymap
)
2905 printf("\n\tNon-Copied parameters:\n");
2907 for (i
= 0; parm_table
[i
].label
; i
++)
2908 if (parm_table
[i
].p_class
== P_LOCAL
&&
2909 parm_table
[i
].ptr
&& !pcopymap
[i
] &&
2910 (i
== 0 || (parm_table
[i
].ptr
!= parm_table
[i
- 1].ptr
)))
2912 printf("\t\t%s\n", parm_table
[i
].label
);
2917 /***************************************************************************
2918 Return TRUE if the passed service number is within range.
2919 ***************************************************************************/
2921 bool lp_snum_ok(int iService
)
2923 return (LP_SNUM_OK(iService
) && ServicePtrs
[iService
]->available
);
2926 /***************************************************************************
2927 Auto-load some home services.
2928 ***************************************************************************/
2930 static void lp_add_auto_services(const char *str
)
2940 s
= talloc_strdup(talloc_tos(), str
);
2942 smb_panic("talloc_strdup failed");
2946 homes
= lp_servicenumber(HOMES_NAME
);
2948 for (p
= strtok_r(s
, LIST_SEP
, &saveptr
); p
;
2949 p
= strtok_r(NULL
, LIST_SEP
, &saveptr
)) {
2952 if (lp_servicenumber(p
) >= 0)
2955 home
= get_user_home_dir(talloc_tos(), p
);
2957 if (home
&& home
[0] && homes
>= 0)
2958 lp_add_home(p
, homes
, p
, home
);
2965 /***************************************************************************
2966 Auto-load one printer.
2967 ***************************************************************************/
2969 void lp_add_one_printer(const char *name
, const char *comment
,
2970 const char *location
, void *pdata
)
2972 int printers
= lp_servicenumber(PRINTERS_NAME
);
2975 if (lp_servicenumber(name
) < 0) {
2976 lp_add_printer(name
, printers
);
2977 if ((i
= lp_servicenumber(name
)) >= 0) {
2978 lpcfg_string_set(ServicePtrs
[i
],
2979 &ServicePtrs
[i
]->comment
, comment
);
2980 ServicePtrs
[i
]->autoloaded
= true;
2985 /***************************************************************************
2986 Have we loaded a services file yet?
2987 ***************************************************************************/
2989 bool lp_loaded(void)
2994 /***************************************************************************
2995 Unload unused services.
2996 ***************************************************************************/
2998 void lp_killunused(struct smbd_server_connection
*sconn
,
2999 bool (*snumused
) (struct smbd_server_connection
*, int))
3002 for (i
= 0; i
< iNumServices
; i
++) {
3006 /* don't kill autoloaded or usershare services */
3007 if ( ServicePtrs
[i
]->autoloaded
||
3008 ServicePtrs
[i
]->usershare
== USERSHARE_VALID
) {
3012 if (!snumused
|| !snumused(sconn
, i
)) {
3013 free_service_byindex(i
);
3019 * Kill all except autoloaded and usershare services - convenience wrapper
3021 void lp_kill_all_services(void)
3023 lp_killunused(NULL
, NULL
);
3026 /***************************************************************************
3028 ***************************************************************************/
3030 void lp_killservice(int iServiceIn
)
3032 if (VALID(iServiceIn
)) {
3033 free_service_byindex(iServiceIn
);
3037 /***************************************************************************
3038 Save the curent values of all global and sDefault parameters into the
3039 defaults union. This allows testparm to show only the
3040 changed (ie. non-default) parameters.
3041 ***************************************************************************/
3043 static void lp_save_defaults(void)
3046 struct parmlist_entry
* parm
;
3047 for (i
= 0; parm_table
[i
].label
; i
++) {
3048 if (!(flags_list
[i
] & FLAG_CMDLINE
)) {
3049 flags_list
[i
] |= FLAG_DEFAULT
;
3052 if (i
> 0 && parm_table
[i
].offset
== parm_table
[i
- 1].offset
3053 && parm_table
[i
].p_class
== parm_table
[i
- 1].p_class
)
3055 switch (parm_table
[i
].type
) {
3058 parm_table
[i
].def
.lvalue
= str_list_copy(
3059 NULL
, *(const char ***)lp_parm_ptr(NULL
, &parm_table
[i
]));
3065 &parm_table
[i
].def
.svalue
,
3066 *(char **)lp_parm_ptr(
3067 NULL
, &parm_table
[i
]));
3068 if (parm_table
[i
].def
.svalue
== NULL
) {
3069 smb_panic("lpcfg_string_set() failed");
3074 parm_table
[i
].def
.bvalue
=
3075 *(bool *)lp_parm_ptr(NULL
, &parm_table
[i
]);
3078 parm_table
[i
].def
.cvalue
=
3079 *(char *)lp_parm_ptr(NULL
, &parm_table
[i
]);
3085 parm_table
[i
].def
.ivalue
=
3086 *(int *)lp_parm_ptr(NULL
, &parm_table
[i
]);
3091 for (parm
=Globals
.param_opt
; parm
; parm
=parm
->next
) {
3092 if (!(parm
->priority
& FLAG_CMDLINE
)) {
3093 parm
->priority
|= FLAG_DEFAULT
;
3097 for (parm
=sDefault
.param_opt
; parm
; parm
=parm
->next
) {
3098 if (!(parm
->priority
& FLAG_CMDLINE
)) {
3099 parm
->priority
|= FLAG_DEFAULT
;
3103 defaults_saved
= true;
3106 /***********************************************************
3107 If we should send plaintext/LANMAN passwords in the clinet
3108 ************************************************************/
3110 static void set_allowed_client_auth(void)
3112 if (Globals
.client_ntlmv2_auth
) {
3113 Globals
.client_lanman_auth
= false;
3115 if (!Globals
.client_lanman_auth
) {
3116 Globals
.client_plaintext_auth
= false;
3120 /***************************************************************************
3122 The following code allows smbd to read a user defined share file.
3123 Yes, this is my intent. Yes, I'm comfortable with that...
3125 THE FOLLOWING IS SECURITY CRITICAL CODE.
3127 It washes your clothes, it cleans your house, it guards you while you sleep...
3128 Do not f%^k with it....
3129 ***************************************************************************/
3131 #define MAX_USERSHARE_FILE_SIZE (10*1024)
3133 /***************************************************************************
3134 Check allowed stat state of a usershare file.
3135 Ensure we print out who is dicking with us so the admin can
3136 get their sorry ass fired.
3137 ***************************************************************************/
3139 static bool check_usershare_stat(const char *fname
,
3140 const SMB_STRUCT_STAT
*psbuf
)
3142 if (!S_ISREG(psbuf
->st_ex_mode
)) {
3143 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3144 "not a regular file\n",
3145 fname
, (unsigned int)psbuf
->st_ex_uid
));
3149 /* Ensure this doesn't have the other write bit set. */
3150 if (psbuf
->st_ex_mode
& S_IWOTH
) {
3151 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
3152 "public write. Refusing to allow as a usershare file.\n",
3153 fname
, (unsigned int)psbuf
->st_ex_uid
));
3157 /* Should be 10k or less. */
3158 if (psbuf
->st_ex_size
> MAX_USERSHARE_FILE_SIZE
) {
3159 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3160 "too large (%u) to be a user share file.\n",
3161 fname
, (unsigned int)psbuf
->st_ex_uid
,
3162 (unsigned int)psbuf
->st_ex_size
));
3169 /***************************************************************************
3170 Parse the contents of a usershare file.
3171 ***************************************************************************/
3173 enum usershare_err
parse_usershare_file(TALLOC_CTX
*ctx
,
3174 SMB_STRUCT_STAT
*psbuf
,
3175 const char *servicename
,
3179 char **pp_sharepath
,
3181 char **pp_cp_servicename
,
3182 struct security_descriptor
**ppsd
,
3185 const char **prefixallowlist
= lp_usershare_prefix_allow_list();
3186 const char **prefixdenylist
= lp_usershare_prefix_deny_list();
3189 SMB_STRUCT_STAT sbuf
;
3190 char *sharepath
= NULL
;
3191 char *comment
= NULL
;
3193 *pp_sharepath
= NULL
;
3196 *pallow_guest
= false;
3199 return USERSHARE_MALFORMED_FILE
;
3202 if (strcmp(lines
[0], "#VERSION 1") == 0) {
3204 } else if (strcmp(lines
[0], "#VERSION 2") == 0) {
3207 return USERSHARE_MALFORMED_FILE
;
3210 return USERSHARE_BAD_VERSION
;
3213 if (strncmp(lines
[1], "path=", 5) != 0) {
3214 return USERSHARE_MALFORMED_PATH
;
3217 sharepath
= talloc_strdup(ctx
, &lines
[1][5]);
3219 return USERSHARE_POSIX_ERR
;
3221 trim_string(sharepath
, " ", " ");
3223 if (strncmp(lines
[2], "comment=", 8) != 0) {
3224 return USERSHARE_MALFORMED_COMMENT_DEF
;
3227 comment
= talloc_strdup(ctx
, &lines
[2][8]);
3229 return USERSHARE_POSIX_ERR
;
3231 trim_string(comment
, " ", " ");
3232 trim_char(comment
, '"', '"');
3234 if (strncmp(lines
[3], "usershare_acl=", 14) != 0) {
3235 return USERSHARE_MALFORMED_ACL_DEF
;
3238 if (!parse_usershare_acl(ctx
, &lines
[3][14], ppsd
)) {
3239 return USERSHARE_ACL_ERR
;
3243 if (strncmp(lines
[4], "guest_ok=", 9) != 0) {
3244 return USERSHARE_MALFORMED_ACL_DEF
;
3246 if (lines
[4][9] == 'y') {
3247 *pallow_guest
= true;
3250 /* Backwards compatible extension to file version #2. */
3252 if (strncmp(lines
[5], "sharename=", 10) != 0) {
3253 return USERSHARE_MALFORMED_SHARENAME_DEF
;
3255 if (!strequal(&lines
[5][10], servicename
)) {
3256 return USERSHARE_BAD_SHARENAME
;
3258 *pp_cp_servicename
= talloc_strdup(ctx
, &lines
[5][10]);
3259 if (!*pp_cp_servicename
) {
3260 return USERSHARE_POSIX_ERR
;
3265 if (*pp_cp_servicename
== NULL
) {
3266 *pp_cp_servicename
= talloc_strdup(ctx
, servicename
);
3267 if (!*pp_cp_servicename
) {
3268 return USERSHARE_POSIX_ERR
;
3272 if (snum
!= -1 && (strcmp(sharepath
, ServicePtrs
[snum
]->path
) == 0)) {
3273 /* Path didn't change, no checks needed. */
3274 *pp_sharepath
= sharepath
;
3275 *pp_comment
= comment
;
3276 return USERSHARE_OK
;
3279 /* The path *must* be absolute. */
3280 if (sharepath
[0] != '/') {
3281 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
3282 servicename
, sharepath
));
3283 return USERSHARE_PATH_NOT_ABSOLUTE
;
3286 /* If there is a usershare prefix deny list ensure one of these paths
3287 doesn't match the start of the user given path. */
3288 if (prefixdenylist
) {
3290 for ( i
=0; prefixdenylist
[i
]; i
++ ) {
3291 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
3292 servicename
, i
, prefixdenylist
[i
], sharepath
));
3293 if (memcmp( sharepath
, prefixdenylist
[i
], strlen(prefixdenylist
[i
])) == 0) {
3294 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
3295 "usershare prefix deny list entries.\n",
3296 servicename
, sharepath
));
3297 return USERSHARE_PATH_IS_DENIED
;
3302 /* If there is a usershare prefix allow list ensure one of these paths
3303 does match the start of the user given path. */
3305 if (prefixallowlist
) {
3307 for ( i
=0; prefixallowlist
[i
]; i
++ ) {
3308 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
3309 servicename
, i
, prefixallowlist
[i
], sharepath
));
3310 if (memcmp( sharepath
, prefixallowlist
[i
], strlen(prefixallowlist
[i
])) == 0) {
3314 if (prefixallowlist
[i
] == NULL
) {
3315 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
3316 "usershare prefix allow list entries.\n",
3317 servicename
, sharepath
));
3318 return USERSHARE_PATH_NOT_ALLOWED
;
3322 /* Ensure this is pointing to a directory. */
3323 dp
= opendir(sharepath
);
3326 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3327 servicename
, sharepath
));
3328 return USERSHARE_PATH_NOT_DIRECTORY
;
3331 /* Ensure the owner of the usershare file has permission to share
3334 if (sys_stat(sharepath
, &sbuf
, false) == -1) {
3335 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
3336 servicename
, sharepath
, strerror(errno
) ));
3338 return USERSHARE_POSIX_ERR
;
3343 if (!S_ISDIR(sbuf
.st_ex_mode
)) {
3344 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3345 servicename
, sharepath
));
3346 return USERSHARE_PATH_NOT_DIRECTORY
;
3349 /* Check if sharing is restricted to owner-only. */
3350 /* psbuf is the stat of the usershare definition file,
3351 sbuf is the stat of the target directory to be shared. */
3353 if (lp_usershare_owner_only()) {
3354 /* root can share anything. */
3355 if ((psbuf
->st_ex_uid
!= 0) && (sbuf
.st_ex_uid
!= psbuf
->st_ex_uid
)) {
3356 return USERSHARE_PATH_NOT_ALLOWED
;
3360 *pp_sharepath
= sharepath
;
3361 *pp_comment
= comment
;
3362 return USERSHARE_OK
;
3365 /***************************************************************************
3366 Deal with a usershare file.
3369 -1 - Bad name, invalid contents.
3370 - service name already existed and not a usershare, problem
3371 with permissions to share directory etc.
3372 ***************************************************************************/
3374 static int process_usershare_file(const char *dir_name
, const char *file_name
, int snum_template
)
3376 SMB_STRUCT_STAT sbuf
;
3377 SMB_STRUCT_STAT lsbuf
;
3379 char *sharepath
= NULL
;
3380 char *comment
= NULL
;
3381 char *cp_service_name
= NULL
;
3382 char **lines
= NULL
;
3386 TALLOC_CTX
*ctx
= talloc_stackframe();
3387 struct security_descriptor
*psd
= NULL
;
3388 bool guest_ok
= false;
3389 char *canon_name
= NULL
;
3390 bool added_service
= false;
3394 /* Ensure share name doesn't contain invalid characters. */
3395 if (!validate_net_name(file_name
, INVALID_SHARENAME_CHARS
, strlen(file_name
))) {
3396 DEBUG(0,("process_usershare_file: share name %s contains "
3397 "invalid characters (any of %s)\n",
3398 file_name
, INVALID_SHARENAME_CHARS
));
3402 canon_name
= canonicalize_servicename(ctx
, file_name
);
3407 fname
= talloc_asprintf(ctx
, "%s/%s", dir_name
, file_name
);
3412 /* Minimize the race condition by doing an lstat before we
3413 open and fstat. Ensure this isn't a symlink link. */
3415 if (sys_lstat(fname
, &lsbuf
, false) != 0) {
3416 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
3417 fname
, strerror(errno
) ));
3421 /* This must be a regular file, not a symlink, directory or
3422 other strange filetype. */
3423 if (!check_usershare_stat(fname
, &lsbuf
)) {
3430 status
= dbwrap_fetch_bystring(ServiceHash
, canon_name
,
3435 if (NT_STATUS_IS_OK(status
) &&
3436 (data
.dptr
!= NULL
) &&
3437 (data
.dsize
== sizeof(iService
))) {
3438 memcpy(&iService
, data
.dptr
, sizeof(iService
));
3442 if (iService
!= -1 &&
3443 timespec_compare(&ServicePtrs
[iService
]->usershare_last_mod
,
3444 &lsbuf
.st_ex_mtime
) == 0) {
3445 /* Nothing changed - Mark valid and return. */
3446 DEBUG(10,("process_usershare_file: service %s not changed.\n",
3448 ServicePtrs
[iService
]->usershare
= USERSHARE_VALID
;
3453 /* Try and open the file read only - no symlinks allowed. */
3455 fd
= open(fname
, O_RDONLY
|O_NOFOLLOW
, 0);
3457 fd
= open(fname
, O_RDONLY
, 0);
3461 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
3462 fname
, strerror(errno
) ));
3466 /* Now fstat to be *SURE* it's a regular file. */
3467 if (sys_fstat(fd
, &sbuf
, false) != 0) {
3469 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
3470 fname
, strerror(errno
) ));
3474 /* Is it the same dev/inode as was lstated ? */
3475 if (!check_same_stat(&lsbuf
, &sbuf
)) {
3477 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
3478 "Symlink spoofing going on ?\n", fname
));
3482 /* This must be a regular file, not a symlink, directory or
3483 other strange filetype. */
3484 if (!check_usershare_stat(fname
, &sbuf
)) {
3489 lines
= fd_lines_load(fd
, &numlines
, MAX_USERSHARE_FILE_SIZE
, NULL
);
3492 if (lines
== NULL
) {
3493 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
3494 fname
, (unsigned int)sbuf
.st_ex_uid
));
3498 if (parse_usershare_file(ctx
, &sbuf
, file_name
,
3499 iService
, lines
, numlines
, &sharepath
,
3500 &comment
, &cp_service_name
,
3501 &psd
, &guest_ok
) != USERSHARE_OK
) {
3505 /* Everything ok - add the service possibly using a template. */
3507 const struct loadparm_service
*sp
= &sDefault
;
3508 if (snum_template
!= -1) {
3509 sp
= ServicePtrs
[snum_template
];
3512 if ((iService
= add_a_service(sp
, cp_service_name
)) < 0) {
3513 DEBUG(0, ("process_usershare_file: Failed to add "
3514 "new service %s\n", cp_service_name
));
3518 added_service
= true;
3520 /* Read only is controlled by usershare ACL below. */
3521 ServicePtrs
[iService
]->read_only
= false;
3524 /* Write the ACL of the new/modified share. */
3525 status
= set_share_security(canon_name
, psd
);
3526 if (!NT_STATUS_IS_OK(status
)) {
3527 DEBUG(0, ("process_usershare_file: Failed to set share "
3528 "security for user share %s\n",
3533 /* If from a template it may be marked invalid. */
3534 ServicePtrs
[iService
]->valid
= true;
3536 /* Set the service as a valid usershare. */
3537 ServicePtrs
[iService
]->usershare
= USERSHARE_VALID
;
3539 /* Set guest access. */
3540 if (lp_usershare_allow_guests()) {
3541 ServicePtrs
[iService
]->guest_ok
= guest_ok
;
3544 /* And note when it was loaded. */
3545 ServicePtrs
[iService
]->usershare_last_mod
= sbuf
.st_ex_mtime
;
3546 lpcfg_string_set(ServicePtrs
[iService
], &ServicePtrs
[iService
]->path
,
3548 lpcfg_string_set(ServicePtrs
[iService
],
3549 &ServicePtrs
[iService
]->comment
, comment
);
3555 if (ret
== -1 && iService
!= -1 && added_service
) {
3556 lp_remove_service(iService
);
3564 /***************************************************************************
3565 Checks if a usershare entry has been modified since last load.
3566 ***************************************************************************/
3568 static bool usershare_exists(int iService
, struct timespec
*last_mod
)
3570 SMB_STRUCT_STAT lsbuf
;
3571 const char *usersharepath
= Globals
.usershare_path
;
3574 fname
= talloc_asprintf(talloc_tos(),
3577 ServicePtrs
[iService
]->szService
);
3578 if (fname
== NULL
) {
3582 if (sys_lstat(fname
, &lsbuf
, false) != 0) {
3587 if (!S_ISREG(lsbuf
.st_ex_mode
)) {
3593 *last_mod
= lsbuf
.st_ex_mtime
;
3597 static bool usershare_directory_is_root(uid_t uid
)
3603 if (uid_wrapper_enabled()) {
3610 /***************************************************************************
3611 Load a usershare service by name. Returns a valid servicenumber or -1.
3612 ***************************************************************************/
3614 int load_usershare_service(const char *servicename
)
3616 SMB_STRUCT_STAT sbuf
;
3617 const char *usersharepath
= Globals
.usershare_path
;
3618 int max_user_shares
= Globals
.usershare_max_shares
;
3619 int snum_template
= -1;
3621 if (*usersharepath
== 0 || max_user_shares
== 0) {
3625 if (sys_stat(usersharepath
, &sbuf
, false) != 0) {
3626 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
3627 usersharepath
, strerror(errno
) ));
3631 if (!S_ISDIR(sbuf
.st_ex_mode
)) {
3632 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
3638 * This directory must be owned by root, and have the 't' bit set.
3639 * It also must not be writable by "other".
3643 if (!usershare_directory_is_root(sbuf
.st_ex_uid
) ||
3644 !(sbuf
.st_ex_mode
& S_ISVTX
) || (sbuf
.st_ex_mode
& S_IWOTH
)) {
3646 if (!usershare_directory_is_root(sbuf
.st_ex_uid
) ||
3647 (sbuf
.st_ex_mode
& S_IWOTH
)) {
3649 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
3650 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3655 /* Ensure the template share exists if it's set. */
3656 if (Globals
.usershare_template_share
[0]) {
3657 /* We can't use lp_servicenumber here as we are recommending that
3658 template shares have -valid=false set. */
3659 for (snum_template
= iNumServices
- 1; snum_template
>= 0; snum_template
--) {
3660 if (ServicePtrs
[snum_template
]->szService
&&
3661 strequal(ServicePtrs
[snum_template
]->szService
,
3662 Globals
.usershare_template_share
)) {
3667 if (snum_template
== -1) {
3668 DEBUG(0,("load_usershare_service: usershare template share %s "
3669 "does not exist.\n",
3670 Globals
.usershare_template_share
));
3675 return process_usershare_file(usersharepath
, servicename
, snum_template
);
3678 /***************************************************************************
3679 Load all user defined shares from the user share directory.
3680 We only do this if we're enumerating the share list.
3681 This is the function that can delete usershares that have
3683 ***************************************************************************/
3685 int load_usershare_shares(struct smbd_server_connection
*sconn
,
3686 bool (*snumused
) (struct smbd_server_connection
*, int))
3689 SMB_STRUCT_STAT sbuf
;
3691 int num_usershares
= 0;
3692 int max_user_shares
= Globals
.usershare_max_shares
;
3693 unsigned int num_dir_entries
, num_bad_dir_entries
, num_tmp_dir_entries
;
3694 unsigned int allowed_bad_entries
= ((2*max_user_shares
)/10);
3695 unsigned int allowed_tmp_entries
= ((2*max_user_shares
)/10);
3697 int snum_template
= -1;
3698 const char *usersharepath
= Globals
.usershare_path
;
3699 int ret
= lp_numservices();
3700 TALLOC_CTX
*tmp_ctx
;
3702 if (max_user_shares
== 0 || *usersharepath
== '\0') {
3703 return lp_numservices();
3706 if (sys_stat(usersharepath
, &sbuf
, false) != 0) {
3707 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
3708 usersharepath
, strerror(errno
) ));
3713 * This directory must be owned by root, and have the 't' bit set.
3714 * It also must not be writable by "other".
3718 if (sbuf
.st_ex_uid
!= 0 || !(sbuf
.st_ex_mode
& S_ISVTX
) || (sbuf
.st_ex_mode
& S_IWOTH
)) {
3720 if (sbuf
.st_ex_uid
!= 0 || (sbuf
.st_ex_mode
& S_IWOTH
)) {
3722 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
3723 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3728 /* Ensure the template share exists if it's set. */
3729 if (Globals
.usershare_template_share
[0]) {
3730 /* We can't use lp_servicenumber here as we are recommending that
3731 template shares have -valid=false set. */
3732 for (snum_template
= iNumServices
- 1; snum_template
>= 0; snum_template
--) {
3733 if (ServicePtrs
[snum_template
]->szService
&&
3734 strequal(ServicePtrs
[snum_template
]->szService
,
3735 Globals
.usershare_template_share
)) {
3740 if (snum_template
== -1) {
3741 DEBUG(0,("load_usershare_shares: usershare template share %s "
3742 "does not exist.\n",
3743 Globals
.usershare_template_share
));
3748 /* Mark all existing usershares as pending delete. */
3749 for (iService
= iNumServices
- 1; iService
>= 0; iService
--) {
3750 if (VALID(iService
) && ServicePtrs
[iService
]->usershare
) {
3751 ServicePtrs
[iService
]->usershare
= USERSHARE_PENDING_DELETE
;
3755 dp
= opendir(usersharepath
);
3757 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
3758 usersharepath
, strerror(errno
) ));
3762 for (num_dir_entries
= 0, num_bad_dir_entries
= 0, num_tmp_dir_entries
= 0;
3764 num_dir_entries
++ ) {
3766 const char *n
= de
->d_name
;
3768 /* Ignore . and .. */
3770 if ((n
[1] == '\0') || (n
[1] == '.' && n
[2] == '\0')) {
3776 /* Temporary file used when creating a share. */
3777 num_tmp_dir_entries
++;
3780 /* Allow 20% tmp entries. */
3781 if (num_tmp_dir_entries
> allowed_tmp_entries
) {
3782 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
3783 "in directory %s\n",
3784 num_tmp_dir_entries
, usersharepath
));
3788 r
= process_usershare_file(usersharepath
, n
, snum_template
);
3790 /* Update the services count. */
3792 if (num_usershares
>= max_user_shares
) {
3793 DEBUG(0,("load_usershare_shares: max user shares reached "
3794 "on file %s in directory %s\n",
3795 n
, usersharepath
));
3798 } else if (r
== -1) {
3799 num_bad_dir_entries
++;
3802 /* Allow 20% bad entries. */
3803 if (num_bad_dir_entries
> allowed_bad_entries
) {
3804 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
3805 "in directory %s\n",
3806 num_bad_dir_entries
, usersharepath
));
3810 /* Allow 20% bad entries. */
3811 if (num_dir_entries
> max_user_shares
+ allowed_bad_entries
) {
3812 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
3813 "in directory %s\n",
3814 num_dir_entries
, usersharepath
));
3821 /* Sweep through and delete any non-refreshed usershares that are
3822 not currently in use. */
3823 tmp_ctx
= talloc_stackframe();
3824 for (iService
= iNumServices
- 1; iService
>= 0; iService
--) {
3825 if (VALID(iService
) && (ServicePtrs
[iService
]->usershare
== USERSHARE_PENDING_DELETE
)) {
3826 const struct loadparm_substitution
*lp_sub
=
3827 loadparm_s3_global_substitution();
3830 if (snumused
&& snumused(sconn
, iService
)) {
3834 servname
= lp_servicename(tmp_ctx
, lp_sub
, iService
);
3836 /* Remove from the share ACL db. */
3837 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
3839 delete_share_security(servname
);
3840 free_service_byindex(iService
);
3843 talloc_free(tmp_ctx
);
3845 return lp_numservices();
3848 /********************************************************
3849 Destroy global resources allocated in this file
3850 ********************************************************/
3852 void gfree_loadparm(void)
3858 /* Free resources allocated to services */
3860 for ( i
= 0; i
< iNumServices
; i
++ ) {
3862 free_service_byindex(i
);
3866 TALLOC_FREE( ServicePtrs
);
3869 /* Now release all resources allocated to global
3870 parameters and the default service */
3872 free_global_parameters();
3876 /***************************************************************************
3877 Allow client apps to specify that they are a client
3878 ***************************************************************************/
3879 static void lp_set_in_client(bool b
)
3885 /***************************************************************************
3886 Determine if we're running in a client app
3887 ***************************************************************************/
3888 static bool lp_is_in_client(void)
3893 static void lp_enforce_ad_dc_settings(void)
3895 lp_do_parameter(GLOBAL_SECTION_SNUM
, "passdb backend", "samba_dsdb");
3896 lp_do_parameter(GLOBAL_SECTION_SNUM
,
3897 "winbindd:use external pipes", "true");
3898 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:default", "external");
3899 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:svcctl", "embedded");
3900 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:srvsvc", "embedded");
3901 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:eventlog", "embedded");
3902 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:ntsvcs", "embedded");
3903 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:winreg", "embedded");
3904 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:spoolss", "embedded");
3905 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_daemon:spoolssd", "embedded");
3906 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:tcpip", "no");
3909 /***************************************************************************
3910 Load the services array from the services file. Return true on success,
3912 ***************************************************************************/
3914 static bool lp_load_ex(const char *pszFname
,
3918 bool reinit_globals
,
3919 bool allow_include_registry
,
3920 bool load_all_shares
)
3924 TALLOC_CTX
*frame
= talloc_stackframe();
3925 struct loadparm_context
*lp_ctx
;
3926 int max_protocol
, min_protocol
;
3928 DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
3930 bInGlobalSection
= true;
3931 bGlobalOnly
= global_only
;
3932 bAllowIncludeRegistry
= allow_include_registry
;
3933 sDefault
= _sDefault
;
3935 lp_ctx
= setup_lp_context(talloc_tos());
3937 init_globals(lp_ctx
, reinit_globals
);
3941 if (save_defaults
) {
3946 if (!reinit_globals
) {
3947 free_param_opts(&Globals
.param_opt
);
3948 apply_lp_set_cmdline();
3951 lp_do_parameter(-1, "idmap config * : backend", Globals
.idmap_backend
);
3953 /* We get sections first, so have to start 'behind' to make up */
3956 if (lp_config_backend_is_file()) {
3957 n2
= talloc_sub_basic(talloc_tos(), get_current_username(),
3958 current_user_info
.domain
,
3961 smb_panic("lp_load_ex: out of memory");
3964 add_to_file_list(NULL
, &file_lists
, pszFname
, n2
);
3966 bRetval
= pm_process(n2
, lp_do_section
, do_parameter
, lp_ctx
);
3969 /* finish up the last section */
3970 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval
)));
3972 if (iServiceIndex
>= 0) {
3973 bRetval
= lpcfg_service_ok(ServicePtrs
[iServiceIndex
]);
3977 if (lp_config_backend_is_registry()) {
3979 /* config backend changed to registry in config file */
3981 * We need to use this extra global variable here to
3982 * survive restart: init_globals uses this as a default
3983 * for config_backend. Otherwise, init_globals would
3984 * send us into an endless loop here.
3987 config_backend
= CONFIG_BACKEND_REGISTRY
;
3989 DEBUG(1, ("lp_load_ex: changing to config backend "
3991 init_globals(lp_ctx
, true);
3993 TALLOC_FREE(lp_ctx
);
3995 lp_kill_all_services();
3996 ok
= lp_load_ex(pszFname
, global_only
, save_defaults
,
3997 add_ipc
, reinit_globals
,
3998 allow_include_registry
,
4003 } else if (lp_config_backend_is_registry()) {
4004 bRetval
= process_registry_globals();
4006 DEBUG(0, ("Illegal config backend given: %d\n",
4007 lp_config_backend()));
4011 if (bRetval
&& lp_registry_shares()) {
4012 if (load_all_shares
) {
4013 bRetval
= process_registry_shares();
4015 bRetval
= reload_registry_shares();
4020 const struct loadparm_substitution
*lp_sub
=
4021 loadparm_s3_global_substitution();
4022 char *serv
= lp_auto_services(talloc_tos(), lp_sub
);
4023 lp_add_auto_services(serv
);
4028 /* When 'restrict anonymous = 2' guest connections to ipc$
4030 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
4031 if ( lp_enable_asu_support() ) {
4032 lp_add_ipc("ADMIN$", false);
4036 set_allowed_client_auth();
4038 if (lp_security() == SEC_ADS
&& strchr(lp_password_server(), ':')) {
4039 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
4040 lp_password_server()));
4045 /* Now we check we_are_a_wins_server and set szWINSserver to 127.0.0.1 */
4046 /* if we_are_a_wins_server is true and we are in the client */
4047 if (lp_is_in_client() && Globals
.we_are_a_wins_server
) {
4048 lp_do_parameter(GLOBAL_SECTION_SNUM
, "wins server", "127.0.0.1");
4053 fault_configure(smb_panic_s3
);
4056 * We run this check once the whole smb.conf is parsed, to
4057 * force some settings for the standard way a AD DC is
4058 * operated. We may change these as our code evolves, which
4059 * is why we force these settings.
4061 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
) {
4062 lp_enforce_ad_dc_settings();
4065 bAllowIncludeRegistry
= true;
4067 /* Check if command line max protocol < min protocol, if so
4068 * report a warning to the user.
4070 max_protocol
= lp_client_max_protocol();
4071 min_protocol
= lp_client_min_protocol();
4072 if (max_protocol
< min_protocol
) {
4073 const char *max_protocolp
, *min_protocolp
;
4074 max_protocolp
= lpcfg_get_smb_protocol(max_protocol
);
4075 min_protocolp
= lpcfg_get_smb_protocol(min_protocol
);
4076 DBG_ERR("Max protocol %s is less than min protocol %s.\n",
4077 max_protocolp
, min_protocolp
);
4084 static bool lp_load(const char *pszFname
,
4088 bool reinit_globals
)
4090 return lp_load_ex(pszFname
,
4095 true, /* allow_include_registry */
4096 false); /* load_all_shares*/
4099 bool lp_load_initial_only(const char *pszFname
)
4101 return lp_load_ex(pszFname
,
4102 true, /* global only */
4103 true, /* save_defaults */
4104 false, /* add_ipc */
4105 true, /* reinit_globals */
4106 false, /* allow_include_registry */
4107 false); /* load_all_shares*/
4111 * most common lp_load wrapper, loading only the globals
4113 * If this is used in a daemon or client utility it should be called
4114 * after processing popt.
4116 bool lp_load_global(const char *file_name
)
4118 return lp_load(file_name
,
4119 true, /* global_only */
4120 false, /* save_defaults */
4121 false, /* add_ipc */
4122 true); /* reinit_globals */
4126 * The typical lp_load wrapper with shares, loads global and
4127 * shares, including IPC, but does not force immediate
4128 * loading of all shares from registry.
4130 bool lp_load_with_shares(const char *file_name
)
4132 return lp_load(file_name
,
4133 false, /* global_only */
4134 false, /* save_defaults */
4136 true); /* reinit_globals */
4140 * lp_load wrapper, especially for clients
4142 bool lp_load_client(const char *file_name
)
4144 lp_set_in_client(true);
4146 return lp_load_global(file_name
);
4150 * lp_load wrapper, loading only globals, but intended
4151 * for subsequent calls, not reinitializing the globals
4154 bool lp_load_global_no_reinit(const char *file_name
)
4156 return lp_load(file_name
,
4157 true, /* global_only */
4158 false, /* save_defaults */
4159 false, /* add_ipc */
4160 false); /* reinit_globals */
4164 * lp_load wrapper, loading globals and shares,
4165 * intended for subsequent calls, i.e. not reinitializing
4166 * the globals to default values.
4168 bool lp_load_no_reinit(const char *file_name
)
4170 return lp_load(file_name
,
4171 false, /* global_only */
4172 false, /* save_defaults */
4173 false, /* add_ipc */
4174 false); /* reinit_globals */
4179 * lp_load wrapper, especially for clients, no reinitialization
4181 bool lp_load_client_no_reinit(const char *file_name
)
4183 lp_set_in_client(true);
4185 return lp_load_global_no_reinit(file_name
);
4188 bool lp_load_with_registry_shares(const char *pszFname
)
4190 return lp_load_ex(pszFname
,
4191 false, /* global_only */
4192 true, /* save_defaults */
4193 false, /* add_ipc */
4194 true, /* reinit_globals */
4195 true, /* allow_include_registry */
4196 true); /* load_all_shares*/
4199 /***************************************************************************
4200 Return the max number of services.
4201 ***************************************************************************/
4203 int lp_numservices(void)
4205 return (iNumServices
);
4208 /***************************************************************************
4209 Display the contents of the services array in human-readable form.
4210 ***************************************************************************/
4212 void lp_dump(FILE *f
, bool show_defaults
, int maxtoprint
)
4215 struct loadparm_context
*lp_ctx
;
4218 defaults_saved
= false;
4220 lp_ctx
= setup_lp_context(talloc_tos());
4221 if (lp_ctx
== NULL
) {
4225 lpcfg_dump_globals(lp_ctx
, f
, !defaults_saved
);
4227 lpcfg_dump_a_service(&sDefault
, &sDefault
, f
, flags_list
, show_defaults
);
4229 for (iService
= 0; iService
< maxtoprint
; iService
++) {
4231 lp_dump_one(f
, show_defaults
, iService
);
4233 TALLOC_FREE(lp_ctx
);
4236 /***************************************************************************
4237 Display the contents of one service in human-readable form.
4238 ***************************************************************************/
4240 void lp_dump_one(FILE * f
, bool show_defaults
, int snum
)
4243 if (ServicePtrs
[snum
]->szService
[0] == '\0')
4245 lpcfg_dump_a_service(ServicePtrs
[snum
], &sDefault
, f
,
4246 flags_list
, show_defaults
);
4250 /***************************************************************************
4251 Return the number of the service with the given name, or -1 if it doesn't
4252 exist. Note that this is a DIFFERENT ANIMAL from the internal function
4253 getservicebyname()! This works ONLY if all services have been loaded, and
4254 does not copy the found service.
4255 ***************************************************************************/
4257 int lp_servicenumber(const char *pszServiceName
)
4260 fstring serviceName
;
4262 if (!pszServiceName
) {
4263 return GLOBAL_SECTION_SNUM
;
4266 for (iService
= iNumServices
- 1; iService
>= 0; iService
--) {
4267 if (VALID(iService
) && ServicePtrs
[iService
]->szService
) {
4269 * The substitution here is used to support %U in
4272 fstrcpy(serviceName
, ServicePtrs
[iService
]->szService
);
4273 standard_sub_basic(get_current_username(),
4274 current_user_info
.domain
,
4275 serviceName
,sizeof(serviceName
));
4276 if (strequal(serviceName
, pszServiceName
)) {
4282 if (iService
>= 0 && ServicePtrs
[iService
]->usershare
== USERSHARE_VALID
) {
4283 struct timespec last_mod
;
4285 if (!usershare_exists(iService
, &last_mod
)) {
4286 /* Remove the share security tdb entry for it. */
4287 delete_share_security(lp_const_servicename(iService
));
4288 /* Remove it from the array. */
4289 free_service_byindex(iService
);
4290 /* Doesn't exist anymore. */
4291 return GLOBAL_SECTION_SNUM
;
4294 /* Has it been modified ? If so delete and reload. */
4295 if (timespec_compare(&ServicePtrs
[iService
]->usershare_last_mod
,
4297 /* Remove it from the array. */
4298 free_service_byindex(iService
);
4299 /* and now reload it. */
4300 iService
= load_usershare_service(pszServiceName
);
4305 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName
));
4306 return GLOBAL_SECTION_SNUM
;
4312 /*******************************************************************
4313 A useful volume label function.
4314 ********************************************************************/
4316 const char *volume_label(TALLOC_CTX
*ctx
, int snum
)
4318 const struct loadparm_substitution
*lp_sub
=
4319 loadparm_s3_global_substitution();
4321 const char *label
= lp_volume(ctx
, lp_sub
, snum
);
4325 label
= lp_servicename(ctx
, lp_sub
, snum
);
4329 * Volume label can be a max of 32 bytes. Make sure to truncate
4330 * it at a codepoint boundary if it's longer than 32 and contains
4331 * multibyte characters. Windows insists on a volume label being
4332 * a valid mb sequence, and errors out if not.
4334 if (strlen(label
) > 32) {
4336 * A MB char can be a max of 5 bytes, thus
4337 * we should have a valid mb character at a
4338 * minimum position of (32-5) = 27.
4342 * Check if a codepoint starting from next byte
4343 * is valid. If yes, then the current byte is the
4344 * end of a MB or ascii sequence and the label can
4345 * be safely truncated here. If not, keep going
4346 * backwards till a valid codepoint is found.
4349 const char *s
= &label
[end
];
4350 codepoint_t c
= next_codepoint(s
, &len
);
4351 if (c
!= INVALID_CODEPOINT
) {
4358 /* This returns a max of 33 byte guarenteed null terminated string. */
4359 ret
= talloc_strndup(ctx
, label
, end
);
4366 /*******************************************************************
4367 Get the default server type we will announce as via nmbd.
4368 ********************************************************************/
4370 int lp_default_server_announce(void)
4372 int default_server_announce
= 0;
4373 default_server_announce
|= SV_TYPE_WORKSTATION
;
4374 default_server_announce
|= SV_TYPE_SERVER
;
4375 default_server_announce
|= SV_TYPE_SERVER_UNIX
;
4377 /* note that the flag should be set only if we have a
4378 printer service but nmbd doesn't actually load the
4379 services so we can't tell --jerry */
4381 default_server_announce
|= SV_TYPE_PRINTQ_SERVER
;
4383 default_server_announce
|= SV_TYPE_SERVER_NT
;
4384 default_server_announce
|= SV_TYPE_NT
;
4386 switch (lp_server_role()) {
4387 case ROLE_DOMAIN_MEMBER
:
4388 default_server_announce
|= SV_TYPE_DOMAIN_MEMBER
;
4390 case ROLE_DOMAIN_PDC
:
4391 default_server_announce
|= SV_TYPE_DOMAIN_CTRL
;
4393 case ROLE_DOMAIN_BDC
:
4394 default_server_announce
|= SV_TYPE_DOMAIN_BAKCTRL
;
4396 case ROLE_STANDALONE
:
4400 if (lp_time_server())
4401 default_server_announce
|= SV_TYPE_TIME_SOURCE
;
4403 if (lp_host_msdfs())
4404 default_server_announce
|= SV_TYPE_DFS_SERVER
;
4406 return default_server_announce
;
4409 /***********************************************************
4410 If we are PDC then prefer us as DMB
4411 ************************************************************/
4413 bool lp_domain_master(void)
4415 if (Globals
._domain_master
== Auto
)
4416 return (lp_server_role() == ROLE_DOMAIN_PDC
);
4418 return (bool)Globals
._domain_master
;
4421 /***********************************************************
4422 If we are PDC then prefer us as DMB
4423 ************************************************************/
4425 static bool lp_domain_master_true_or_auto(void)
4427 if (Globals
._domain_master
) /* auto or yes */
4433 /***********************************************************
4434 If we are DMB then prefer us as LMB
4435 ************************************************************/
4437 bool lp_preferred_master(void)
4439 int preferred_master
= lp__preferred_master();
4441 if (preferred_master
== Auto
)
4442 return (lp_local_master() && lp_domain_master());
4444 return (bool)preferred_master
;
4447 /*******************************************************************
4449 ********************************************************************/
4451 void lp_remove_service(int snum
)
4453 ServicePtrs
[snum
]->valid
= false;
4456 const char *lp_printername(TALLOC_CTX
*ctx
,
4457 const struct loadparm_substitution
*lp_sub
,
4460 const char *ret
= lp__printername(ctx
, lp_sub
, snum
);
4462 if (ret
== NULL
|| *ret
== '\0') {
4463 ret
= lp_const_servicename(snum
);
4470 /***********************************************************
4471 Allow daemons such as winbindd to fix their logfile name.
4472 ************************************************************/
4474 void lp_set_logfile(const char *name
)
4476 lpcfg_string_set(Globals
.ctx
, &Globals
.logfile
, name
);
4477 debug_set_logfile(name
);
4480 /*******************************************************************
4481 Return the max print jobs per queue.
4482 ********************************************************************/
4484 int lp_maxprintjobs(int snum
)
4486 int maxjobs
= lp_max_print_jobs(snum
);
4488 if (maxjobs
<= 0 || maxjobs
>= PRINT_MAX_JOBID
)
4489 maxjobs
= PRINT_MAX_JOBID
- 1;
4494 const char *lp_printcapname(void)
4496 const char *printcap_name
= lp_printcap_name();
4498 if ((printcap_name
!= NULL
) &&
4499 (printcap_name
[0] != '\0'))
4500 return printcap_name
;
4502 if (sDefault
.printing
== PRINT_CUPS
) {
4506 if (sDefault
.printing
== PRINT_BSD
)
4507 return "/etc/printcap";
4509 return PRINTCAP_NAME
;
4512 static uint32_t spoolss_state
;
4514 bool lp_disable_spoolss( void )
4516 if ( spoolss_state
== SVCCTL_STATE_UNKNOWN
)
4517 spoolss_state
= lp__disable_spoolss() ? SVCCTL_STOPPED
: SVCCTL_RUNNING
;
4519 return spoolss_state
== SVCCTL_STOPPED
? true : false;
4522 void lp_set_spoolss_state( uint32_t state
)
4524 SMB_ASSERT( (state
== SVCCTL_STOPPED
) || (state
== SVCCTL_RUNNING
) );
4526 spoolss_state
= state
;
4529 uint32_t lp_get_spoolss_state( void )
4531 return lp_disable_spoolss() ? SVCCTL_STOPPED
: SVCCTL_RUNNING
;
4534 /*******************************************************************
4535 Turn off sendfile if we find the underlying OS doesn't support it.
4536 ********************************************************************/
4538 void set_use_sendfile(int snum
, bool val
)
4540 if (LP_SNUM_OK(snum
))
4541 ServicePtrs
[snum
]->_use_sendfile
= val
;
4543 sDefault
._use_sendfile
= val
;
4546 void lp_set_mangling_method(const char *new_method
)
4548 lpcfg_string_set(Globals
.ctx
, &Globals
.mangling_method
, new_method
);
4551 /*******************************************************************
4552 Global state for POSIX pathname processing.
4553 ********************************************************************/
4555 static bool posix_pathnames
;
4557 bool lp_posix_pathnames(void)
4559 return posix_pathnames
;
4562 /*******************************************************************
4563 Change everything needed to ensure POSIX pathname processing (currently
4565 ********************************************************************/
4567 void lp_set_posix_pathnames(void)
4569 posix_pathnames
= true;
4572 /*******************************************************************
4573 Global state for POSIX lock processing - CIFS unix extensions.
4574 ********************************************************************/
4576 bool posix_default_lock_was_set
;
4577 static enum brl_flavour posix_cifsx_locktype
; /* By default 0 == WINDOWS_LOCK */
4579 enum brl_flavour
lp_posix_cifsu_locktype(files_struct
*fsp
)
4581 if (posix_default_lock_was_set
) {
4582 return posix_cifsx_locktype
;
4584 return (fsp
->posix_flags
& FSP_POSIX_FLAGS_OPEN
) ?
4585 POSIX_LOCK
: WINDOWS_LOCK
;
4589 /*******************************************************************
4590 ********************************************************************/
4592 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val
)
4594 posix_default_lock_was_set
= true;
4595 posix_cifsx_locktype
= val
;
4598 int lp_min_receive_file_size(void)
4600 int min_receivefile_size
= lp_min_receivefile_size();
4602 if (min_receivefile_size
< 0) {
4605 return min_receivefile_size
;
4608 /*******************************************************************
4609 Safe wide links checks.
4610 This helper function always verify the validity of wide links,
4611 even after a configuration file reload.
4612 ********************************************************************/
4614 void widelinks_warning(int snum
)
4616 if (lp_allow_insecure_wide_links()) {
4620 if (lp_unix_extensions() && lp_wide_links(snum
)) {
4621 DBG_ERR("Share '%s' has wide links and unix extensions enabled. "
4622 "These parameters are incompatible. "
4623 "Wide links will be disabled for this share.\n",
4624 lp_const_servicename(snum
));
4628 bool lp_widelinks(int snum
)
4630 /* wide links is always incompatible with unix extensions */
4631 if (lp_unix_extensions()) {
4633 * Unless we have "allow insecure widelinks"
4636 if (!lp_allow_insecure_wide_links()) {
4641 return lp_wide_links(snum
);
4644 int lp_server_role(void)
4646 return lp_find_server_role(lp__server_role(),
4648 lp__domain_logons(),
4649 lp_domain_master_true_or_auto());
4652 int lp_security(void)
4654 return lp_find_security(lp__server_role(),
4658 int lp_client_max_protocol(void)
4660 int client_max_protocol
= lp__client_max_protocol();
4661 if (client_max_protocol
== PROTOCOL_DEFAULT
) {
4662 return PROTOCOL_LATEST
;
4664 return client_max_protocol
;
4667 int lp_client_ipc_min_protocol(void)
4669 int client_ipc_min_protocol
= lp__client_ipc_min_protocol();
4670 if (client_ipc_min_protocol
== PROTOCOL_DEFAULT
) {
4671 client_ipc_min_protocol
= lp_client_min_protocol();
4673 if (client_ipc_min_protocol
< PROTOCOL_NT1
) {
4674 return PROTOCOL_NT1
;
4676 return client_ipc_min_protocol
;
4679 int lp_client_ipc_max_protocol(void)
4681 int client_ipc_max_protocol
= lp__client_ipc_max_protocol();
4682 if (client_ipc_max_protocol
== PROTOCOL_DEFAULT
) {
4683 return PROTOCOL_LATEST
;
4685 if (client_ipc_max_protocol
< PROTOCOL_NT1
) {
4686 return PROTOCOL_NT1
;
4688 return client_ipc_max_protocol
;
4691 int lp_client_ipc_signing(void)
4693 int client_ipc_signing
= lp__client_ipc_signing();
4694 if (client_ipc_signing
== SMB_SIGNING_DEFAULT
) {
4695 return SMB_SIGNING_REQUIRED
;
4697 return client_ipc_signing
;
4700 int lp_rpc_low_port(void)
4702 return Globals
.rpc_low_port
;
4705 int lp_rpc_high_port(void)
4707 return Globals
.rpc_high_port
;
4711 * Do not allow LanMan auth if unless NTLMv1 is also allowed
4713 * This also ensures it is disabled if NTLM is totally disabled
4715 bool lp_lanman_auth(void)
4717 enum ntlm_auth_level ntlm_auth_level
= lp_ntlm_auth();
4719 if (ntlm_auth_level
== NTLM_AUTH_ON
) {
4720 return lp__lanman_auth();
4726 struct loadparm_global
* get_globals(void)
4731 unsigned int * get_flags(void)
4733 if (flags_list
== NULL
) {
4734 flags_list
= talloc_zero_array(NULL
, unsigned int, num_parameters());