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
57 #include "system/filesys.h"
59 #include "lib/param/loadparm.h"
60 #include "lib/param/param.h"
62 #include "lib/smbconf/smbconf.h"
63 #include "lib/smbconf/smbconf_init.h"
66 #include "../librpc/gen_ndr/svcctl.h"
68 #include "../libcli/smb/smb_signing.h"
69 #include "dbwrap/dbwrap.h"
70 #include "dbwrap/dbwrap_rbt.h"
71 #include "../lib/util/bitmap.h"
72 #include "librpc/gen_ndr/nbt.h"
73 #include "source4/lib/tls/tls.h"
75 #ifdef HAVE_SYS_SYSCTL_H
76 #include <sys/sysctl.h>
81 extern userdom_struct current_user_info
;
83 /* the special value for the include parameter
84 * to be interpreted not as a file name but to
85 * trigger loading of the global smb.conf options
87 #ifndef INCLUDE_REGISTRY_NAME
88 #define INCLUDE_REGISTRY_NAME "registry"
91 static bool in_client
= false; /* Not in the client by default */
92 static struct smbconf_csn conf_last_csn
;
94 static int config_backend
= CONFIG_BACKEND_FILE
;
96 /* some helpful bits */
97 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && \
98 (ServicePtrs != NULL) && \
99 (ServicePtrs[(i)] != NULL) && ServicePtrs[(i)]->valid)
100 #define VALID(i) ((ServicePtrs != NULL) && (ServicePtrs[i]!= NULL) && \
101 ServicePtrs[i]->valid)
103 #define USERSHARE_VALID 1
104 #define USERSHARE_PENDING_DELETE 2
106 static bool defaults_saved
= false;
108 #include "lib/param/param_global.h"
110 static struct loadparm_global Globals
;
112 /* This is a default service used to prime a services structure */
113 static struct loadparm_service sDefault
=
118 .usershare_last_mod
= {0, 0},
121 .invalid_users
= NULL
,
128 .root_preexec
= NULL
,
129 .root_postexec
= NULL
,
130 .cups_options
= NULL
,
131 .print_command
= NULL
,
133 .lprm_command
= NULL
,
134 .lppause_command
= NULL
,
135 .lpresume_command
= NULL
,
136 .queuepause_command
= NULL
,
137 .queueresume_command
= NULL
,
138 ._printername
= NULL
,
139 .printjob_username
= NULL
,
140 .dont_descend
= NULL
,
143 .magic_script
= NULL
,
144 .magic_output
= NULL
,
147 .veto_oplock_files
= NULL
,
157 .aio_write_behind
= NULL
,
158 .dfree_command
= NULL
,
159 .min_print_space
= 0,
160 .max_print_jobs
= 1000,
161 .max_reported_print_jobs
= 0,
162 .write_cache_size
= 0,
164 .force_create_mode
= 0,
165 .directory_mask
= 0755,
166 .force_directory_mode
= 0,
167 .max_connections
= 0,
168 .default_case
= CASE_LOWER
,
169 .printing
= DEFAULT_PRINTING
,
170 .oplock_contention_limit
= 2,
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
= false,
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_YES
,
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 .profile_acls
= false,
233 .map_acl_inherit
= false,
236 .acl_check_permissions
= true,
237 .acl_map_full_control
= true,
238 .acl_group_control
= false,
239 .acl_allow_execute_always
= false,
240 .allocation_roundup_size
= SMB_ROUNDUP_ALLOCATION_SIZE
,
243 .map_readonly
= MAP_READONLY_YES
,
244 .directory_name_cache_size
= 100,
245 .smb_encrypt
= SMB_SIGNING_DEFAULT
,
246 .kernel_share_modes
= true,
247 .durable_handles
= true,
252 /* local variables */
253 static struct loadparm_service
**ServicePtrs
= NULL
;
254 static int iNumServices
= 0;
255 static int iServiceIndex
= 0;
256 static struct db_context
*ServiceHash
;
257 static bool bInGlobalSection
= true;
258 static bool bGlobalOnly
= false;
259 static struct file_lists
*file_lists
= NULL
;
260 static unsigned int *flags_list
= NULL
;
262 static void set_allowed_client_auth(void);
264 static bool lp_set_cmdline_helper(const char *pszParmName
, const char *pszParmValue
);
265 static void free_param_opts(struct parmlist_entry
**popts
);
268 * Function to return the default value for the maximum number of open
269 * file descriptors permitted. This function tries to consult the
270 * kernel-level (sysctl) and ulimit (getrlimit()) values and goes
271 * the smaller of those.
273 static int max_open_files(void)
275 int sysctl_max
= MAX_OPEN_FILES
;
276 int rlimit_max
= MAX_OPEN_FILES
;
278 #ifdef HAVE_SYSCTLBYNAME
280 size_t size
= sizeof(sysctl_max
);
281 sysctlbyname("kern.maxfilesperproc", &sysctl_max
, &size
, NULL
,
286 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
292 if (getrlimit(RLIMIT_NOFILE
, &rl
) == 0)
293 rlimit_max
= rl
.rlim_cur
;
295 #if defined(RLIM_INFINITY)
296 if(rl
.rlim_cur
== RLIM_INFINITY
)
297 rlimit_max
= MAX_OPEN_FILES
;
302 if (sysctl_max
< MIN_OPEN_FILES_WINDOWS
) {
303 DEBUG(2,("max_open_files: increasing sysctl_max (%d) to "
304 "minimum Windows limit (%d)\n",
306 MIN_OPEN_FILES_WINDOWS
));
307 sysctl_max
= MIN_OPEN_FILES_WINDOWS
;
310 if (rlimit_max
< MIN_OPEN_FILES_WINDOWS
) {
311 DEBUG(2,("rlimit_max: increasing rlimit_max (%d) to "
312 "minimum Windows limit (%d)\n",
314 MIN_OPEN_FILES_WINDOWS
));
315 rlimit_max
= MIN_OPEN_FILES_WINDOWS
;
318 return MIN(sysctl_max
, rlimit_max
);
322 * Common part of freeing allocated data for one parameter.
324 static void free_one_parameter_common(void *parm_ptr
,
325 struct parm_struct parm
)
327 if ((parm
.type
== P_STRING
) ||
328 (parm
.type
== P_USTRING
))
330 lpcfg_string_free((char**)parm_ptr
);
331 } else if (parm
.type
== P_LIST
|| parm
.type
== P_CMDLIST
) {
332 TALLOC_FREE(*((char***)parm_ptr
));
337 * Free the allocated data for one parameter for a share
338 * given as a service struct.
340 static void free_one_parameter(struct loadparm_service
*service
,
341 struct parm_struct parm
)
345 if (parm
.p_class
!= P_LOCAL
) {
349 parm_ptr
= lp_parm_ptr(service
, &parm
);
351 free_one_parameter_common(parm_ptr
, parm
);
355 * Free the allocated parameter data of a share given
356 * as a service struct.
358 static void free_parameters(struct loadparm_service
*service
)
362 for (i
=0; parm_table
[i
].label
; i
++) {
363 free_one_parameter(service
, parm_table
[i
]);
368 * Free the allocated data for one parameter for a given share
369 * specified by an snum.
371 static void free_one_parameter_by_snum(int snum
, struct parm_struct parm
)
376 parm_ptr
= lp_parm_ptr(NULL
, &parm
);
377 } else if (parm
.p_class
!= P_LOCAL
) {
380 parm_ptr
= lp_parm_ptr(ServicePtrs
[snum
], &parm
);
383 free_one_parameter_common(parm_ptr
, parm
);
387 * Free the allocated parameter data for a share specified
390 static void free_parameters_by_snum(int snum
)
394 for (i
=0; parm_table
[i
].label
; i
++) {
395 free_one_parameter_by_snum(snum
, parm_table
[i
]);
400 * Free the allocated global parameters.
402 static void free_global_parameters(void)
405 struct parm_struct
*parm
;
407 free_param_opts(&Globals
.param_opt
);
408 free_parameters_by_snum(GLOBAL_SECTION_SNUM
);
410 /* Reset references in the defaults because the context is going to be freed */
411 for (i
=0; parm_table
[i
].label
; i
++) {
412 parm
= &parm_table
[i
];
413 if ((parm
->type
== P_STRING
) ||
414 (parm
->type
== P_USTRING
)) {
415 if ((parm
->def
.svalue
!= NULL
) &&
416 (*(parm
->def
.svalue
) != '\0')) {
417 if (talloc_parent(parm
->def
.svalue
) == Globals
.ctx
) {
418 parm
->def
.svalue
= NULL
;
423 TALLOC_FREE(Globals
.ctx
);
426 struct lp_stored_option
{
427 struct lp_stored_option
*prev
, *next
;
432 static struct lp_stored_option
*stored_options
;
435 save options set by lp_set_cmdline() into a list. This list is
436 re-applied when we do a globals reset, so that cmdline set options
437 are sticky across reloads of smb.conf
439 bool store_lp_set_cmdline(const char *pszParmName
, const char *pszParmValue
)
441 struct lp_stored_option
*entry
, *entry_next
;
442 for (entry
= stored_options
; entry
!= NULL
; entry
= entry_next
) {
443 entry_next
= entry
->next
;
444 if (strcmp(pszParmName
, entry
->label
) == 0) {
445 DLIST_REMOVE(stored_options
, entry
);
451 entry
= talloc(NULL
, struct lp_stored_option
);
456 entry
->label
= talloc_strdup(entry
, pszParmName
);
462 entry
->value
= talloc_strdup(entry
, pszParmValue
);
468 DLIST_ADD_END(stored_options
, entry
);
473 static bool apply_lp_set_cmdline(void)
475 struct lp_stored_option
*entry
= NULL
;
476 for (entry
= stored_options
; entry
!= NULL
; entry
= entry
->next
) {
477 if (!lp_set_cmdline_helper(entry
->label
, entry
->value
)) {
478 DEBUG(0, ("Failed to re-apply cmdline parameter %s = %s\n",
479 entry
->label
, entry
->value
));
486 /***************************************************************************
487 Initialise the global parameter structure.
488 ***************************************************************************/
490 static void init_globals(struct loadparm_context
*lp_ctx
, bool reinit_globals
)
492 static bool done_init
= false;
496 /* If requested to initialize only once and we've already done it... */
497 if (!reinit_globals
&& done_init
) {
498 /* ... then we have nothing more to do */
503 /* The logfile can be set before this is invoked. Free it if so. */
504 lpcfg_string_free(&Globals
.logfile
);
507 free_global_parameters();
510 /* This memset and the free_global_parameters() above will
511 * wipe out smb.conf options set with lp_set_cmdline(). The
512 * apply_lp_set_cmdline() call puts these values back in the
513 * table once the defaults are set */
514 ZERO_STRUCT(Globals
);
516 Globals
.ctx
= talloc_pooled_object(NULL
, char, 272, 2048);
518 /* Initialize the flags list if necessary */
519 if (flags_list
== NULL
) {
523 for (i
= 0; parm_table
[i
].label
; i
++) {
524 if ((parm_table
[i
].type
== P_STRING
||
525 parm_table
[i
].type
== P_USTRING
))
529 (char **)lp_parm_ptr(NULL
, &parm_table
[i
]),
535 lpcfg_string_set(Globals
.ctx
, &sDefault
.fstype
, FSTYPE_STRING
);
536 lpcfg_string_set(Globals
.ctx
, &sDefault
.printjob_username
, "%U");
538 init_printer_values(lp_ctx
, Globals
.ctx
, &sDefault
);
540 sDefault
.ntvfs_handler
= str_list_make_v3_const(NULL
, "unixuid default", NULL
);
542 DEBUG(3, ("Initialising global parameters\n"));
544 /* Must manually force to upper case here, as this does not go via the handler */
545 lpcfg_string_set(Globals
.ctx
, &Globals
.netbios_name
,
548 lpcfg_string_set(Globals
.ctx
, &Globals
.smb_passwd_file
,
549 get_dyn_SMB_PASSWD_FILE());
550 lpcfg_string_set(Globals
.ctx
, &Globals
.private_dir
,
551 get_dyn_PRIVATE_DIR());
553 /* use the new 'hash2' method by default, with a prefix of 1 */
554 lpcfg_string_set(Globals
.ctx
, &Globals
.mangling_method
, "hash2");
555 Globals
.mangle_prefix
= 1;
557 lpcfg_string_set(Globals
.ctx
, &Globals
.guest_account
, GUEST_ACCOUNT
);
559 /* using UTF8 by default allows us to support all chars */
560 lpcfg_string_set(Globals
.ctx
, &Globals
.unix_charset
,
561 DEFAULT_UNIX_CHARSET
);
563 /* Use codepage 850 as a default for the dos character set */
564 lpcfg_string_set(Globals
.ctx
, &Globals
.dos_charset
,
565 DEFAULT_DOS_CHARSET
);
568 * Allow the default PASSWD_CHAT to be overridden in local.h.
570 lpcfg_string_set(Globals
.ctx
, &Globals
.passwd_chat
,
571 DEFAULT_PASSWD_CHAT
);
573 lpcfg_string_set(Globals
.ctx
, &Globals
.workgroup
, DEFAULT_WORKGROUP
);
575 lpcfg_string_set(Globals
.ctx
, &Globals
.passwd_program
, "");
576 lpcfg_string_set(Globals
.ctx
, &Globals
.lock_directory
,
578 lpcfg_string_set(Globals
.ctx
, &Globals
.state_directory
,
580 lpcfg_string_set(Globals
.ctx
, &Globals
.cache_directory
,
582 lpcfg_string_set(Globals
.ctx
, &Globals
.pid_directory
,
584 lpcfg_string_set(Globals
.ctx
, &Globals
.nbt_client_socket_address
,
587 * By default support explicit binding to broadcast
590 Globals
.nmbd_bind_explicit_broadcast
= true;
592 s
= talloc_asprintf(talloc_tos(), "Samba %s", samba_version_string());
594 smb_panic("init_globals: ENOMEM");
596 lpcfg_string_set(Globals
.ctx
, &Globals
.server_string
, s
);
599 lpcfg_string_set(Globals
.ctx
, &Globals
.panic_action
,
600 "/bin/sleep 999999999");
603 lpcfg_string_set(Globals
.ctx
, &Globals
.socket_options
,
604 DEFAULT_SOCKET_OPTIONS
);
606 lpcfg_string_set(Globals
.ctx
, &Globals
.logon_drive
, "");
607 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
608 lpcfg_string_set(Globals
.ctx
, &Globals
.logon_home
, "\\\\%N\\%U");
609 lpcfg_string_set(Globals
.ctx
, &Globals
.logon_path
,
610 "\\\\%N\\%U\\profile");
612 Globals
.name_resolve_order
= str_list_make_v3_const(NULL
, "lmhosts wins host bcast", NULL
);
613 lpcfg_string_set(Globals
.ctx
, &Globals
.password_server
, "*");
615 Globals
.algorithmic_rid_base
= BASE_RID
;
617 Globals
.load_printers
= true;
618 Globals
.printcap_cache_time
= 750; /* 12.5 minutes */
620 Globals
.config_backend
= config_backend
;
621 Globals
._server_role
= ROLE_AUTO
;
623 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
624 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
625 Globals
.max_xmit
= 0x4104;
626 Globals
.max_mux
= 50; /* This is *needed* for profile support. */
627 Globals
.lpq_cache_time
= 30; /* changed to handle large print servers better -- jerry */
628 Globals
._disable_spoolss
= false;
629 Globals
.max_smbd_processes
= 0;/* no limit specified */
630 Globals
.username_level
= 0;
631 Globals
.deadtime
= 0;
632 Globals
.getwd_cache
= true;
633 Globals
.large_readwrite
= true;
634 Globals
.max_log_size
= 5000;
635 Globals
.max_open_files
= max_open_files();
636 Globals
.server_max_protocol
= PROTOCOL_SMB3_11
;
637 Globals
.server_min_protocol
= PROTOCOL_LANMAN1
;
638 Globals
._client_max_protocol
= PROTOCOL_DEFAULT
;
639 Globals
.client_min_protocol
= PROTOCOL_CORE
;
640 Globals
._client_ipc_max_protocol
= PROTOCOL_DEFAULT
;
641 Globals
._client_ipc_min_protocol
= PROTOCOL_DEFAULT
;
642 Globals
._security
= SEC_AUTO
;
643 Globals
.encrypt_passwords
= true;
644 Globals
.client_schannel
= Auto
;
645 Globals
.winbind_sealed_pipes
= true;
646 Globals
.require_strong_key
= true;
647 Globals
.server_schannel
= Auto
;
648 Globals
.read_raw
= true;
649 Globals
.write_raw
= true;
650 Globals
.null_passwords
= false;
651 Globals
.old_password_allowed_period
= 60;
652 Globals
.obey_pam_restrictions
= false;
654 Globals
.syslog_only
= false;
655 Globals
.timestamp_logs
= true;
656 lpcfg_string_set(Globals
.ctx
, &Globals
.log_level
, "0");
657 Globals
.debug_prefix_timestamp
= false;
658 Globals
.debug_hires_timestamp
= true;
659 Globals
.debug_pid
= false;
660 Globals
.debug_uid
= false;
661 Globals
.debug_class
= false;
662 Globals
.enable_core_files
= true;
663 Globals
.max_ttl
= 60 * 60 * 24 * 3; /* 3 days default. */
664 Globals
.max_wins_ttl
= 60 * 60 * 24 * 6; /* 6 days default. */
665 Globals
.min_wins_ttl
= 60 * 60 * 6; /* 6 hours default. */
666 Globals
.machine_password_timeout
= 60 * 60 * 24 * 7; /* 7 days default. */
667 Globals
.lm_announce
= Auto
; /* = Auto: send only if LM clients found */
668 Globals
.lm_interval
= 60;
669 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
670 Globals
.nis_homedir
= false;
671 #ifdef WITH_NISPLUS_HOME
672 lpcfg_string_set(Globals
.ctx
, &Globals
.homedir_map
,
673 "auto_home.org_dir");
675 lpcfg_string_set(Globals
.ctx
, &Globals
.homedir_map
, "auto.home");
678 Globals
.time_server
= false;
679 Globals
.bind_interfaces_only
= false;
680 Globals
.unix_password_sync
= false;
681 Globals
.pam_password_change
= false;
682 Globals
.passwd_chat_debug
= false;
683 Globals
.passwd_chat_timeout
= 2; /* 2 second default. */
684 Globals
.nt_pipe_support
= true; /* Do NT pipes by default. */
685 Globals
.nt_status_support
= true; /* Use NT status by default. */
686 Globals
.smbd_profiling_level
= 0;
687 Globals
.stat_cache
= true; /* use stat cache by default */
688 Globals
.max_stat_cache_size
= 256; /* 256k by default */
689 Globals
.restrict_anonymous
= 0;
690 Globals
.client_lanman_auth
= false; /* Do NOT use the LanMan hash if it is available */
691 Globals
.client_plaintext_auth
= false; /* Do NOT use a plaintext password even if is requested by the server */
692 Globals
.lanman_auth
= false; /* Do NOT use the LanMan hash, even if it is supplied */
693 Globals
.ntlm_auth
= false; /* Do NOT use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
694 Globals
.raw_ntlmv2_auth
= false; /* Reject NTLMv2 without NTLMSSP */
695 Globals
.client_ntlmv2_auth
= true; /* Client should always use use NTLMv2, as we can't tell that the server supports it, but most modern servers do */
696 /* Note, that we will also use NTLM2 session security (which is different), if it is available */
698 Globals
.allow_dcerpc_auth_level_connect
= false; /* we don't allow this by default */
700 Globals
.map_to_guest
= 0; /* By Default, "Never" */
701 Globals
.oplock_break_wait_time
= 0; /* By Default, 0 msecs. */
702 Globals
.enhanced_browsing
= true;
703 Globals
.lock_spin_time
= WINDOWS_MINIMUM_LOCK_TIMEOUT_MS
; /* msec. */
704 #ifdef MMAP_BLACKLIST
705 Globals
.use_mmap
= false;
707 Globals
.use_mmap
= true;
709 Globals
.unicode
= true;
710 Globals
.unix_extensions
= true;
711 Globals
.reset_on_zero_vc
= false;
712 Globals
.log_writeable_files_on_exit
= false;
713 Globals
.create_krb5_conf
= true;
714 Globals
.include_system_krb5_conf
= true;
715 Globals
._winbind_max_domain_connections
= 1;
717 /* hostname lookups can be very expensive and are broken on
718 a large number of sites (tridge) */
719 Globals
.hostname_lookups
= false;
721 Globals
.change_notify
= true,
722 Globals
.kernel_change_notify
= true,
724 lpcfg_string_set(Globals
.ctx
, &Globals
.passdb_backend
, "tdbsam");
725 lpcfg_string_set(Globals
.ctx
, &Globals
.ldap_suffix
, "");
726 lpcfg_string_set(Globals
.ctx
, &Globals
._ldap_machine_suffix
, "");
727 lpcfg_string_set(Globals
.ctx
, &Globals
._ldap_user_suffix
, "");
728 lpcfg_string_set(Globals
.ctx
, &Globals
._ldap_group_suffix
, "");
729 lpcfg_string_set(Globals
.ctx
, &Globals
._ldap_idmap_suffix
, "");
731 lpcfg_string_set(Globals
.ctx
, &Globals
.ldap_admin_dn
, "");
732 Globals
.ldap_ssl
= LDAP_SSL_START_TLS
;
733 Globals
.ldap_ssl_ads
= false;
734 Globals
.ldap_deref
= -1;
735 Globals
.ldap_passwd_sync
= LDAP_PASSWD_SYNC_OFF
;
736 Globals
.ldap_delete_dn
= false;
737 Globals
.ldap_replication_sleep
= 1000; /* wait 1 sec for replication */
738 Globals
.ldap_follow_referral
= Auto
;
739 Globals
.ldap_timeout
= LDAP_DEFAULT_TIMEOUT
;
740 Globals
.ldap_connection_timeout
= LDAP_CONNECTION_DEFAULT_TIMEOUT
;
741 Globals
.ldap_page_size
= LDAP_PAGE_SIZE
;
743 Globals
.ldap_debug_level
= 0;
744 Globals
.ldap_debug_threshold
= 10;
746 Globals
.client_ldap_sasl_wrapping
= ADS_AUTH_SASL_SIGN
;
748 Globals
.ldap_server_require_strong_auth
=
749 LDAP_SERVER_REQUIRE_STRONG_AUTH_YES
;
751 /* This is what we tell the afs client. in reality we set the token
752 * to never expire, though, when this runs out the afs client will
753 * forget the token. Set to 0 to get NEVERDATE.*/
754 Globals
.afs_token_lifetime
= 604800;
755 Globals
.cups_connection_timeout
= CUPS_DEFAULT_CONNECTION_TIMEOUT
;
757 /* these parameters are set to defaults that are more appropriate
758 for the increasing samba install base:
760 as a member of the workgroup, that will possibly become a
761 _local_ master browser (lm = true). this is opposed to a forced
762 local master browser startup (pm = true).
764 doesn't provide WINS server service by default (wsupp = false),
765 and doesn't provide domain master browser services by default, either.
769 Globals
.show_add_printer_wizard
= true;
770 Globals
.os_level
= 20;
771 Globals
.local_master
= true;
772 Globals
._domain_master
= Auto
; /* depending on _domain_logons */
773 Globals
._domain_logons
= false;
774 Globals
.browse_list
= true;
775 Globals
.we_are_a_wins_server
= false;
776 Globals
.wins_proxy
= false;
778 TALLOC_FREE(Globals
.init_logon_delayed_hosts
);
779 Globals
.init_logon_delay
= 100; /* 100 ms default delay */
781 Globals
.wins_dns_proxy
= true;
783 Globals
.allow_trusted_domains
= true;
784 lpcfg_string_set(Globals
.ctx
, &Globals
.idmap_backend
, "tdb");
786 lpcfg_string_set(Globals
.ctx
, &Globals
.template_shell
, "/bin/false");
787 lpcfg_string_set(Globals
.ctx
, &Globals
.template_homedir
,
789 lpcfg_string_set(Globals
.ctx
, &Globals
.winbind_separator
, "\\");
790 lpcfg_string_set(Globals
.ctx
, &Globals
.winbindd_socket_directory
,
791 dyn_WINBINDD_SOCKET_DIR
);
793 lpcfg_string_set(Globals
.ctx
, &Globals
.cups_server
, "");
794 lpcfg_string_set(Globals
.ctx
, &Globals
.iprint_server
, "");
796 lpcfg_string_set(Globals
.ctx
, &Globals
._ctdbd_socket
, "");
798 Globals
.cluster_addresses
= NULL
;
799 Globals
.clustering
= false;
800 Globals
.ctdb_timeout
= 0;
801 Globals
.ctdb_locktime_warn_threshold
= 0;
803 Globals
.winbind_cache_time
= 300; /* 5 minutes */
804 Globals
.winbind_reconnect_delay
= 30; /* 30 seconds */
805 Globals
.winbind_request_timeout
= 60; /* 60 seconds */
806 Globals
.winbind_max_clients
= 200;
807 Globals
.winbind_enum_users
= false;
808 Globals
.winbind_enum_groups
= false;
809 Globals
.winbind_use_default_domain
= false;
810 Globals
.winbind_trusted_domains_only
= false;
811 Globals
.winbind_nested_groups
= true;
812 Globals
.winbind_expand_groups
= 0;
813 Globals
.winbind_nss_info
= str_list_make_v3_const(NULL
, "template", NULL
);
814 Globals
.winbind_refresh_tickets
= false;
815 Globals
.winbind_offline_logon
= false;
817 Globals
.idmap_cache_time
= 86400 * 7; /* a week by default */
818 Globals
.idmap_negative_cache_time
= 120; /* 2 minutes by default */
820 Globals
.passdb_expand_explicit
= false;
822 Globals
.name_cache_timeout
= 660; /* In seconds */
824 Globals
.use_spnego
= true;
825 Globals
.client_use_spnego
= true;
827 Globals
.client_signing
= SMB_SIGNING_DEFAULT
;
828 Globals
._client_ipc_signing
= SMB_SIGNING_DEFAULT
;
829 Globals
.server_signing
= SMB_SIGNING_DEFAULT
;
831 Globals
.defer_sharing_violations
= true;
832 Globals
.smb_ports
= str_list_make_v3_const(NULL
, SMB_PORTS
, NULL
);
834 Globals
.enable_privileges
= true;
835 Globals
.host_msdfs
= true;
836 Globals
.enable_asu_support
= false;
838 /* User defined shares. */
839 s
= talloc_asprintf(talloc_tos(), "%s/usershares", get_dyn_STATEDIR());
841 smb_panic("init_globals: ENOMEM");
843 lpcfg_string_set(Globals
.ctx
, &Globals
.usershare_path
, s
);
845 lpcfg_string_set(Globals
.ctx
, &Globals
.usershare_template_share
, "");
846 Globals
.usershare_max_shares
= 0;
847 /* By default disallow sharing of directories not owned by the sharer. */
848 Globals
.usershare_owner_only
= true;
849 /* By default disallow guest access to usershares. */
850 Globals
.usershare_allow_guests
= false;
852 Globals
.keepalive
= DEFAULT_KEEPALIVE
;
854 /* By default no shares out of the registry */
855 Globals
.registry_shares
= false;
857 Globals
.min_receivefile_size
= 0;
859 Globals
.map_untrusted_to_domain
= false;
860 Globals
.multicast_dns_register
= true;
862 Globals
.smb2_max_read
= DEFAULT_SMB2_MAX_READ
;
863 Globals
.smb2_max_write
= DEFAULT_SMB2_MAX_WRITE
;
864 Globals
.smb2_max_trans
= DEFAULT_SMB2_MAX_TRANSACT
;
865 Globals
.smb2_max_credits
= DEFAULT_SMB2_MAX_CREDITS
;
866 Globals
.smb2_leases
= true;
868 lpcfg_string_set(Globals
.ctx
, &Globals
.ncalrpc_dir
,
869 get_dyn_NCALRPCDIR());
871 Globals
.server_services
= str_list_make_v3_const(NULL
, "s3fs rpc nbt wrepl ldap cldap kdc drepl winbindd ntp_signd kcc dnsupdate dns", NULL
);
873 Globals
.dcerpc_endpoint_servers
= str_list_make_v3_const(NULL
, "epmapper wkssvc rpcecho samr netlogon lsarpc drsuapi dssetup unixinfo browser eventlog6 backupkey dnsserver", NULL
);
875 Globals
.tls_enabled
= true;
876 Globals
.tls_verify_peer
= TLS_VERIFY_PEER_AS_STRICT_AS_POSSIBLE
;
878 lpcfg_string_set(Globals
.ctx
, &Globals
._tls_keyfile
, "tls/key.pem");
879 lpcfg_string_set(Globals
.ctx
, &Globals
._tls_certfile
, "tls/cert.pem");
880 lpcfg_string_set(Globals
.ctx
, &Globals
._tls_cafile
, "tls/ca.pem");
881 lpcfg_string_set(Globals
.ctx
, &Globals
.tls_priority
,
882 "NORMAL:-VERS-SSL3.0");
884 lpcfg_string_set(Globals
.ctx
, &Globals
.share_backend
, "classic");
886 Globals
._preferred_master
= Auto
;
888 Globals
.allow_dns_updates
= DNS_UPDATE_SIGNED
;
890 lpcfg_string_set(Globals
.ctx
, &Globals
.ntp_signd_socket_directory
,
891 get_dyn_NTP_SIGND_SOCKET_DIR());
893 s
= talloc_asprintf(talloc_tos(), "%s/samba_kcc", get_dyn_SCRIPTSBINDIR());
895 smb_panic("init_globals: ENOMEM");
897 Globals
.samba_kcc_command
= str_list_make_v3_const(NULL
, s
, NULL
);
900 s
= talloc_asprintf(talloc_tos(), "%s/samba_dnsupdate", get_dyn_SCRIPTSBINDIR());
902 smb_panic("init_globals: ENOMEM");
904 Globals
.dns_update_command
= str_list_make_v3_const(NULL
, s
, NULL
);
907 s
= talloc_asprintf(talloc_tos(), "%s/samba_spnupdate", get_dyn_SCRIPTSBINDIR());
909 smb_panic("init_globals: ENOMEM");
911 Globals
.spn_update_command
= str_list_make_v3_const(NULL
, s
, NULL
);
914 Globals
.nsupdate_command
= str_list_make_v3_const(NULL
, "/usr/bin/nsupdate -g", NULL
);
916 Globals
.rndc_command
= str_list_make_v3_const(NULL
, "/usr/sbin/rndc", NULL
);
918 Globals
.cldap_port
= 389;
920 Globals
.dgram_port
= NBT_DGRAM_SERVICE_PORT
;
922 Globals
.nbt_port
= NBT_NAME_SERVICE_PORT
;
924 Globals
.krb5_port
= 88;
926 Globals
.kpasswd_port
= 464;
928 Globals
.web_port
= 901;
930 Globals
.aio_max_threads
= 100;
932 lpcfg_string_set(Globals
.ctx
,
933 &Globals
.rpc_server_dynamic_port_range
,
935 Globals
.rpc_low_port
= SERVER_TCP_LOW_PORT
;
936 Globals
.rpc_high_port
= SERVER_TCP_HIGH_PORT
;
938 /* Now put back the settings that were set with lp_set_cmdline() */
939 apply_lp_set_cmdline();
942 /* Convenience routine to setup an lp_context with additional s3 variables */
943 static struct loadparm_context
*setup_lp_context(TALLOC_CTX
*mem_ctx
)
945 struct loadparm_context
*lp_ctx
;
947 lp_ctx
= loadparm_init_s3(mem_ctx
,
948 loadparm_s3_helpers());
949 if (lp_ctx
== NULL
) {
950 DEBUG(0, ("loadparm_init_s3 failed\n"));
954 lp_ctx
->sDefault
= &sDefault
;
955 lp_ctx
->services
= NULL
; /* We do not want to access this directly */
956 lp_ctx
->bInGlobalSection
= bInGlobalSection
;
957 lp_ctx
->flags
= flags_list
;
962 /*******************************************************************
963 Convenience routine to grab string parameters into talloced memory
964 and run standard_sub_basic on them. The buffers can be written to by
965 callers without affecting the source string.
966 ********************************************************************/
968 char *lp_string(TALLOC_CTX
*ctx
, const char *s
)
972 /* The follow debug is useful for tracking down memory problems
973 especially if you have an inner loop that is calling a lp_*()
974 function that returns a string. Perhaps this debug should be
975 present all the time? */
978 DEBUG(10, ("lp_string(%s)\n", s
));
984 ret
= talloc_sub_basic(ctx
,
985 get_current_username(),
986 current_user_info
.domain
,
988 if (trim_char(ret
, '\"', '\"')) {
989 if (strchr(ret
,'\"') != NULL
) {
991 ret
= talloc_sub_basic(ctx
,
992 get_current_username(),
993 current_user_info
.domain
,
1001 In this section all the functions that are used to access the
1002 parameters from the rest of the program are defined
1005 #define FN_GLOBAL_STRING(fn_name,ptr) \
1006 char *lp_ ## fn_name(TALLOC_CTX *ctx) {return(lp_string((ctx), *(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : ""));}
1007 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1008 const char *lp_ ## fn_name(void) {return(*(const char * const *)(&Globals.ptr) ? *(const char * const *)(&Globals.ptr) : "");}
1009 #define FN_GLOBAL_LIST(fn_name,ptr) \
1010 const char **lp_ ## fn_name(void) {return(*(const char ***)(&Globals.ptr));}
1011 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1012 bool lp_ ## fn_name(void) {return(*(bool *)(&Globals.ptr));}
1013 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1014 char lp_ ## fn_name(void) {return(*(char *)(&Globals.ptr));}
1015 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1016 int lp_ ## fn_name(void) {return(*(int *)(&Globals.ptr));}
1018 #define FN_LOCAL_STRING(fn_name,val) \
1019 char *lp_ ## fn_name(TALLOC_CTX *ctx,int i) {return(lp_string((ctx), (LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
1020 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1021 const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1022 #define FN_LOCAL_LIST(fn_name,val) \
1023 const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1024 #define FN_LOCAL_BOOL(fn_name,val) \
1025 bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1026 #define FN_LOCAL_INTEGER(fn_name,val) \
1027 int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1029 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1030 bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1031 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1032 int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1033 #define FN_LOCAL_PARM_CHAR(fn_name,val) \
1034 char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1036 int lp_winbind_max_domain_connections(void)
1038 if (lp_winbind_offline_logon() &&
1039 lp__winbind_max_domain_connections() > 1) {
1040 DEBUG(1, ("offline logons active, restricting max domain "
1041 "connections to 1\n"));
1044 return MAX(1, lp__winbind_max_domain_connections());
1047 /* These functions remain in source3/param for now */
1049 #include "lib/param/param_functions.c"
1051 FN_LOCAL_STRING(servicename
, szService
)
1052 FN_LOCAL_CONST_STRING(const_servicename
, szService
)
1054 /* These functions cannot be auto-generated */
1055 FN_LOCAL_BOOL(autoloaded
, autoloaded
)
1056 FN_GLOBAL_CONST_STRING(dnsdomain
, dnsdomain
)
1058 /* local prototypes */
1060 static int map_parameter_canonical(const char *pszParmName
, bool *inverse
);
1061 static const char *get_boolean(bool bool_value
);
1062 static bool do_parameter(const char *pszParmName
, const char *pszParmValue
,
1064 static bool hash_a_service(const char *name
, int number
);
1065 static void free_service_byindex(int iService
);
1066 static void show_parameter(int parmIndex
);
1067 static bool is_synonym_of(int parm1
, int parm2
, bool *inverse
);
1068 static bool lp_parameter_value_is_valid(const char *parm_name
, const char *val
);
1071 * This is a helper function for parametrical options support. It returns a
1072 * pointer to parametrical option value if it exists or NULL otherwise. Actual
1073 * parametrical functions are quite simple
1075 static struct parmlist_entry
*get_parametrics(int snum
, const char *type
,
1078 if (snum
>= iNumServices
) return NULL
;
1081 return get_parametric_helper(NULL
, type
, option
, Globals
.param_opt
);
1083 return get_parametric_helper(ServicePtrs
[snum
],
1084 type
, option
, Globals
.param_opt
);
1088 static void discard_whitespace(char *str
)
1090 size_t len
= strlen(str
);
1094 if (isspace(str
[i
])) {
1095 memmove(&str
[i
], &str
[i
+1], len
-i
);
1104 * @brief Go through all global parametric parameters
1106 * @param regex_str A regular expression to scan param for
1107 * @param max_matches Max number of submatches the regexp expects
1108 * @param cb Function to call on match. Should return true
1109 * when it wants wi_scan_global_parametrics to stop
1111 * @param private_data Anonymous pointer passed to cb
1113 * @return 0: success, regcomp/regexec return value on error.
1114 * See "man regexec" for possible errors
1117 int lp_wi_scan_global_parametrics(
1118 const char *regex_str
, size_t max_matches
,
1119 bool (*cb
)(const char *string
, regmatch_t matches
[],
1120 void *private_data
),
1123 struct parmlist_entry
*data
;
1127 ret
= regcomp(®ex
, regex_str
, REG_ICASE
);
1132 for (data
= Globals
.param_opt
; data
!= NULL
; data
= data
->next
) {
1133 size_t keylen
= strlen(data
->key
);
1135 regmatch_t matches
[max_matches
];
1138 memcpy(key
, data
->key
, sizeof(key
));
1139 discard_whitespace(key
);
1141 ret
= regexec(®ex
, key
, max_matches
, matches
, 0);
1142 if (ret
== REG_NOMATCH
) {
1149 stop
= cb(key
, matches
, private_data
);
1162 #define MISSING_PARAMETER(name) \
1163 DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
1165 /*******************************************************************
1166 convenience routine to return enum parameters.
1167 ********************************************************************/
1168 static int lp_enum(const char *s
,const struct enum_list
*_enum
)
1172 if (!s
|| !*s
|| !_enum
) {
1173 MISSING_PARAMETER(lp_enum
);
1177 for (i
=0; _enum
[i
].name
; i
++) {
1178 if (strequal(_enum
[i
].name
,s
))
1179 return _enum
[i
].value
;
1182 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s
));
1186 #undef MISSING_PARAMETER
1188 /* Return parametric option from a given service. Type is a part of option before ':' */
1189 /* Parametric option has following syntax: 'Type: option = value' */
1190 char *lp_parm_talloc_string(TALLOC_CTX
*ctx
, int snum
, const char *type
, const char *option
, const char *def
)
1192 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1194 if (data
== NULL
||data
->value
==NULL
) {
1196 return lp_string(ctx
, def
);
1202 return lp_string(ctx
, data
->value
);
1205 /* Return parametric option from a given service. Type is a part of option before ':' */
1206 /* Parametric option has following syntax: 'Type: option = value' */
1207 const char *lp_parm_const_string(int snum
, const char *type
, const char *option
, const char *def
)
1209 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1211 if (data
== NULL
||data
->value
==NULL
)
1218 /* Return parametric option from a given service. Type is a part of option before ':' */
1219 /* Parametric option has following syntax: 'Type: option = value' */
1221 const char **lp_parm_string_list(int snum
, const char *type
, const char *option
, const char **def
)
1223 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1225 if (data
== NULL
||data
->value
==NULL
)
1226 return (const char **)def
;
1228 if (data
->list
==NULL
) {
1229 data
->list
= str_list_make_v3(NULL
, data
->value
, NULL
);
1232 return discard_const_p(const char *, data
->list
);
1235 /* Return parametric option from a given service. Type is a part of option before ':' */
1236 /* Parametric option has following syntax: 'Type: option = value' */
1238 int lp_parm_int(int snum
, const char *type
, const char *option
, int def
)
1240 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1242 if (data
&& data
->value
&& *data
->value
)
1243 return lp_int(data
->value
);
1248 /* Return parametric option from a given service. Type is a part of option before ':' */
1249 /* Parametric option has following syntax: 'Type: option = value' */
1251 unsigned long lp_parm_ulong(int snum
, const char *type
, const char *option
, unsigned long def
)
1253 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1255 if (data
&& data
->value
&& *data
->value
)
1256 return lp_ulong(data
->value
);
1261 /* Return parametric option from a given service. Type is a part of option before ':' */
1262 /* Parametric option has following syntax: 'Type: option = value' */
1264 unsigned long long lp_parm_ulonglong(int snum
, const char *type
,
1265 const char *option
, unsigned long long def
)
1267 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1269 if (data
&& data
->value
&& *data
->value
) {
1270 return lp_ulonglong(data
->value
);
1276 /* Return parametric option from a given service. Type is a part of option
1278 /* Parametric option has following syntax: 'Type: option = value' */
1280 bool lp_parm_bool(int snum
, const char *type
, const char *option
, bool def
)
1282 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1284 if (data
&& data
->value
&& *data
->value
)
1285 return lp_bool(data
->value
);
1290 /* Return parametric option from a given service. Type is a part of option before ':' */
1291 /* Parametric option has following syntax: 'Type: option = value' */
1293 int lp_parm_enum(int snum
, const char *type
, const char *option
,
1294 const struct enum_list
*_enum
, int def
)
1296 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1298 if (data
&& data
->value
&& *data
->value
&& _enum
)
1299 return lp_enum(data
->value
, _enum
);
1305 * free a param_opts structure.
1306 * param_opts handling should be moved to talloc;
1307 * then this whole functions reduces to a TALLOC_FREE().
1310 static void free_param_opts(struct parmlist_entry
**popts
)
1312 struct parmlist_entry
*opt
, *next_opt
;
1314 if (*popts
!= NULL
) {
1315 DEBUG(5, ("Freeing parametrics:\n"));
1318 while (opt
!= NULL
) {
1319 lpcfg_string_free(&opt
->key
);
1320 lpcfg_string_free(&opt
->value
);
1321 TALLOC_FREE(opt
->list
);
1322 next_opt
= opt
->next
;
1329 /***************************************************************************
1330 Free the dynamically allocated parts of a service struct.
1331 ***************************************************************************/
1333 static void free_service(struct loadparm_service
*pservice
)
1338 if (pservice
->szService
)
1339 DEBUG(5, ("free_service: Freeing service %s\n",
1340 pservice
->szService
));
1342 free_parameters(pservice
);
1344 lpcfg_string_free(&pservice
->szService
);
1345 TALLOC_FREE(pservice
->copymap
);
1347 free_param_opts(&pservice
->param_opt
);
1349 ZERO_STRUCTP(pservice
);
1353 /***************************************************************************
1354 remove a service indexed in the ServicePtrs array from the ServiceHash
1355 and free the dynamically allocated parts
1356 ***************************************************************************/
1358 static void free_service_byindex(int idx
)
1360 if ( !LP_SNUM_OK(idx
) )
1363 ServicePtrs
[idx
]->valid
= false;
1365 /* we have to cleanup the hash record */
1367 if (ServicePtrs
[idx
]->szService
) {
1368 char *canon_name
= canonicalize_servicename(
1370 ServicePtrs
[idx
]->szService
);
1372 dbwrap_delete_bystring(ServiceHash
, canon_name
);
1373 TALLOC_FREE(canon_name
);
1376 free_service(ServicePtrs
[idx
]);
1377 TALLOC_FREE(ServicePtrs
[idx
]);
1380 /***************************************************************************
1381 Add a new service to the services array initialising it with the given
1383 ***************************************************************************/
1385 static int add_a_service(const struct loadparm_service
*pservice
, const char *name
)
1388 struct loadparm_service
**tsp
= NULL
;
1390 /* it might already exist */
1392 i
= getservicebyname(name
, NULL
);
1398 /* Re use empty slots if any before allocating new one.*/
1399 for (i
=0; i
< iNumServices
; i
++) {
1400 if (ServicePtrs
[i
] == NULL
) {
1404 if (i
== iNumServices
) {
1405 /* if not, then create one */
1406 tsp
= talloc_realloc(NULL
, ServicePtrs
,
1407 struct loadparm_service
*,
1410 DEBUG(0, ("add_a_service: failed to enlarge "
1417 ServicePtrs
[i
] = talloc_zero(ServicePtrs
, struct loadparm_service
);
1418 if (!ServicePtrs
[i
]) {
1419 DEBUG(0,("add_a_service: out of memory!\n"));
1423 ServicePtrs
[i
]->valid
= true;
1425 copy_service(ServicePtrs
[i
], pservice
, NULL
);
1427 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->szService
,
1430 DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
1431 i
, ServicePtrs
[i
]->szService
));
1433 if (!hash_a_service(ServicePtrs
[i
]->szService
, i
)) {
1440 /***************************************************************************
1441 Convert a string to uppercase and remove whitespaces.
1442 ***************************************************************************/
1444 char *canonicalize_servicename(TALLOC_CTX
*ctx
, const char *src
)
1449 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
1453 result
= talloc_strdup(ctx
, src
);
1454 SMB_ASSERT(result
!= NULL
);
1456 if (!strlower_m(result
)) {
1457 TALLOC_FREE(result
);
1463 /***************************************************************************
1464 Add a name/index pair for the services array to the hash table.
1465 ***************************************************************************/
1467 static bool hash_a_service(const char *name
, int idx
)
1471 if ( !ServiceHash
) {
1472 DEBUG(10,("hash_a_service: creating servicehash\n"));
1473 ServiceHash
= db_open_rbt(NULL
);
1474 if ( !ServiceHash
) {
1475 DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
1480 DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
1483 canon_name
= canonicalize_servicename(talloc_tos(), name
);
1485 dbwrap_store_bystring(ServiceHash
, canon_name
,
1486 make_tdb_data((uint8_t *)&idx
, sizeof(idx
)),
1489 TALLOC_FREE(canon_name
);
1494 /***************************************************************************
1495 Add a new home service, with the specified home directory, defaults coming
1497 ***************************************************************************/
1499 bool lp_add_home(const char *pszHomename
, int iDefaultService
,
1500 const char *user
, const char *pszHomedir
)
1504 if (pszHomename
== NULL
|| user
== NULL
|| pszHomedir
== NULL
||
1505 pszHomedir
[0] == '\0') {
1509 i
= add_a_service(ServicePtrs
[iDefaultService
], pszHomename
);
1514 if (!(*(ServicePtrs
[iDefaultService
]->path
))
1515 || strequal(ServicePtrs
[iDefaultService
]->path
,
1516 lp_path(talloc_tos(), GLOBAL_SECTION_SNUM
))) {
1517 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->path
,
1521 if (!(*(ServicePtrs
[i
]->comment
))) {
1522 char *comment
= talloc_asprintf(talloc_tos(), "Home directory of %s", user
);
1523 if (comment
== NULL
) {
1526 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->comment
,
1528 TALLOC_FREE(comment
);
1531 /* set the browseable flag from the global default */
1533 ServicePtrs
[i
]->browseable
= sDefault
.browseable
;
1534 ServicePtrs
[i
]->access_based_share_enum
= sDefault
.access_based_share_enum
;
1536 ServicePtrs
[i
]->autoloaded
= true;
1538 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename
,
1539 user
, ServicePtrs
[i
]->path
));
1544 /***************************************************************************
1545 Add a new service, based on an old one.
1546 ***************************************************************************/
1548 int lp_add_service(const char *pszService
, int iDefaultService
)
1550 if (iDefaultService
< 0) {
1551 return add_a_service(&sDefault
, pszService
);
1554 return (add_a_service(ServicePtrs
[iDefaultService
], pszService
));
1557 /***************************************************************************
1558 Add the IPC service.
1559 ***************************************************************************/
1561 static bool lp_add_ipc(const char *ipc_name
, bool guest_ok
)
1563 char *comment
= NULL
;
1564 int i
= add_a_service(&sDefault
, ipc_name
);
1569 comment
= talloc_asprintf(talloc_tos(), "IPC Service (%s)",
1570 Globals
.server_string
);
1571 if (comment
== NULL
) {
1575 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->path
, tmpdir());
1576 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->comment
, comment
);
1577 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->fstype
, "IPC");
1578 ServicePtrs
[i
]->max_connections
= 0;
1579 ServicePtrs
[i
]->available
= true;
1580 ServicePtrs
[i
]->read_only
= true;
1581 ServicePtrs
[i
]->guest_only
= false;
1582 ServicePtrs
[i
]->administrative_share
= true;
1583 ServicePtrs
[i
]->guest_ok
= guest_ok
;
1584 ServicePtrs
[i
]->printable
= false;
1585 ServicePtrs
[i
]->browseable
= sDefault
.browseable
;
1586 ServicePtrs
[i
]->autoloaded
= true;
1588 DEBUG(3, ("adding IPC service\n"));
1590 TALLOC_FREE(comment
);
1594 /***************************************************************************
1595 Add a new printer service, with defaults coming from service iFrom.
1596 ***************************************************************************/
1598 bool lp_add_printer(const char *pszPrintername
, int iDefaultService
)
1600 const char *comment
= "From Printcap";
1601 int i
= add_a_service(ServicePtrs
[iDefaultService
], pszPrintername
);
1606 /* note that we do NOT default the availability flag to true - */
1607 /* we take it from the default service passed. This allows all */
1608 /* dynamic printers to be disabled by disabling the [printers] */
1609 /* entry (if/when the 'available' keyword is implemented!). */
1611 /* the printer name is set to the service name. */
1612 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->_printername
,
1614 lpcfg_string_set(ServicePtrs
[i
], &ServicePtrs
[i
]->comment
, comment
);
1616 /* set the browseable flag from the gloabl default */
1617 ServicePtrs
[i
]->browseable
= sDefault
.browseable
;
1619 /* Printers cannot be read_only. */
1620 ServicePtrs
[i
]->read_only
= false;
1621 /* No oplocks on printer services. */
1622 ServicePtrs
[i
]->oplocks
= false;
1623 /* Printer services must be printable. */
1624 ServicePtrs
[i
]->printable
= true;
1626 DEBUG(3, ("adding printer service %s\n", pszPrintername
));
1632 /***************************************************************************
1633 Check whether the given parameter name is valid.
1634 Parametric options (names containing a colon) are considered valid.
1635 ***************************************************************************/
1637 bool lp_parameter_is_valid(const char *pszParmName
)
1639 return ((lpcfg_map_parameter(pszParmName
) != -1) ||
1640 (strchr(pszParmName
, ':') != NULL
));
1643 /***************************************************************************
1644 Check whether the given name is the name of a global parameter.
1645 Returns true for strings belonging to parameters of class
1646 P_GLOBAL, false for all other strings, also for parametric options
1647 and strings not belonging to any option.
1648 ***************************************************************************/
1650 bool lp_parameter_is_global(const char *pszParmName
)
1652 int num
= lpcfg_map_parameter(pszParmName
);
1655 return (parm_table
[num
].p_class
== P_GLOBAL
);
1661 /**************************************************************************
1662 Determine the canonical name for a parameter.
1663 Indicate when it is an inverse (boolean) synonym instead of a
1665 **************************************************************************/
1667 bool lp_canonicalize_parameter(const char *parm_name
, const char **canon_parm
,
1672 if (!lp_parameter_is_valid(parm_name
)) {
1677 num
= map_parameter_canonical(parm_name
, inverse
);
1679 /* parametric option */
1680 *canon_parm
= parm_name
;
1682 *canon_parm
= parm_table
[num
].label
;
1689 /**************************************************************************
1690 Determine the canonical name for a parameter.
1691 Turn the value given into the inverse boolean expression when
1692 the synonym is an invers boolean synonym.
1695 - parm_name is a valid parameter name and
1696 - val is a valid value for this parameter and
1697 - in case the parameter is an inverse boolean synonym, if the val
1698 string could successfully be converted to the reverse bool.
1699 Return false in all other cases.
1700 **************************************************************************/
1702 bool lp_canonicalize_parameter_with_value(const char *parm_name
,
1704 const char **canon_parm
,
1705 const char **canon_val
)
1711 if (!lp_parameter_is_valid(parm_name
)) {
1717 num
= map_parameter_canonical(parm_name
, &inverse
);
1719 /* parametric option */
1720 *canon_parm
= parm_name
;
1725 *canon_parm
= parm_table
[num
].label
;
1727 if (!lp_invert_boolean(val
, canon_val
)) {
1735 ret
= lp_parameter_value_is_valid(*canon_parm
, *canon_val
);
1740 /***************************************************************************
1741 Map a parameter's string representation to the index of the canonical
1742 form of the parameter (it might be a synonym).
1743 Returns -1 if the parameter string is not recognised.
1744 ***************************************************************************/
1746 static int map_parameter_canonical(const char *pszParmName
, bool *inverse
)
1748 int parm_num
, canon_num
;
1749 bool loc_inverse
= false;
1751 parm_num
= lpcfg_map_parameter(pszParmName
);
1752 if ((parm_num
< 0) || !(parm_table
[parm_num
].flags
& FLAG_SYNONYM
)) {
1753 /* invalid, parametric or no canidate for synonyms ... */
1757 for (canon_num
= 0; parm_table
[canon_num
].label
; canon_num
++) {
1758 if (is_synonym_of(parm_num
, canon_num
, &loc_inverse
)) {
1759 parm_num
= canon_num
;
1765 if (inverse
!= NULL
) {
1766 *inverse
= loc_inverse
;
1771 /***************************************************************************
1772 return true if parameter number parm1 is a synonym of parameter
1773 number parm2 (parm2 being the principal name).
1774 set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
1776 ***************************************************************************/
1778 static bool is_synonym_of(int parm1
, int parm2
, bool *inverse
)
1780 if ((parm_table
[parm1
].offset
== parm_table
[parm2
].offset
) &&
1781 (parm_table
[parm1
].p_class
== parm_table
[parm2
].p_class
) &&
1782 (parm_table
[parm1
].flags
& FLAG_SYNONYM
) &&
1783 !(parm_table
[parm2
].flags
& FLAG_SYNONYM
))
1785 if (inverse
!= NULL
) {
1786 if ((parm_table
[parm1
].type
== P_BOOLREV
) &&
1787 (parm_table
[parm2
].type
== P_BOOL
))
1799 /***************************************************************************
1800 Show one parameter's name, type, [values,] and flags.
1801 (helper functions for show_parameter_list)
1802 ***************************************************************************/
1804 static void show_parameter(int parmIndex
)
1806 int enumIndex
, flagIndex
;
1811 const char *type
[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
1812 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
1813 "P_ENUM", "P_BYTES", "P_CMDLIST" };
1814 unsigned flags
[] = { FLAG_DEPRECATED
, FLAG_SYNONYM
};
1815 const char *flag_names
[] = { "FLAG_DEPRECATED", "FLAG_SYNONYM", NULL
};
1817 printf("%s=%s", parm_table
[parmIndex
].label
,
1818 type
[parm_table
[parmIndex
].type
]);
1819 if (parm_table
[parmIndex
].type
== P_ENUM
) {
1822 parm_table
[parmIndex
].enum_list
[enumIndex
].name
;
1826 enumIndex
? "|" : "",
1827 parm_table
[parmIndex
].enum_list
[enumIndex
].name
);
1832 for (flagIndex
=0; flag_names
[flagIndex
]; flagIndex
++) {
1833 if (parm_table
[parmIndex
].flags
& flags
[flagIndex
]) {
1836 flag_names
[flagIndex
]);
1841 /* output synonyms */
1843 for (parmIndex2
=0; parm_table
[parmIndex2
].label
; parmIndex2
++) {
1844 if (is_synonym_of(parmIndex
, parmIndex2
, &inverse
)) {
1845 printf(" (%ssynonym of %s)", inverse
? "inverse " : "",
1846 parm_table
[parmIndex2
].label
);
1847 } else if (is_synonym_of(parmIndex2
, parmIndex
, &inverse
)) {
1849 printf(" (synonyms: ");
1854 printf("%s%s", parm_table
[parmIndex2
].label
,
1855 inverse
? "[i]" : "");
1866 * Check the value for a P_ENUM
1868 static bool check_enum_parameter(struct parm_struct
*parm
, const char *value
)
1872 for (i
= 0; parm
->enum_list
[i
].name
; i
++) {
1873 if (strwicmp(value
, parm
->enum_list
[i
].name
) == 0) {
1880 /**************************************************************************
1881 Check whether the given value is valid for the given parameter name.
1882 **************************************************************************/
1884 static bool lp_parameter_value_is_valid(const char *parm_name
, const char *val
)
1886 bool ret
= false, tmp_bool
;
1887 int num
= lpcfg_map_parameter(parm_name
), tmp_int
;
1888 uint64_t tmp_int64
= 0;
1889 struct parm_struct
*parm
;
1891 /* parametric options (parameter names containing a colon) cannot
1892 be checked and are therefore considered valid. */
1893 if (strchr(parm_name
, ':') != NULL
) {
1898 parm
= &parm_table
[num
];
1899 switch (parm
->type
) {
1902 ret
= set_boolean(val
, &tmp_bool
);
1906 ret
= (sscanf(val
, "%d", &tmp_int
) == 1);
1910 ret
= (sscanf(val
, "%o", &tmp_int
) == 1);
1914 ret
= check_enum_parameter(parm
, val
);
1918 if (conv_str_size_error(val
, &tmp_int64
) &&
1919 tmp_int64
<= INT_MAX
) {
1936 /***************************************************************************
1937 Show all parameter's name, type, [values,] and flags.
1938 ***************************************************************************/
1940 void show_parameter_list(void)
1942 int classIndex
, parmIndex
;
1943 const char *section_names
[] = { "local", "global", NULL
};
1945 for (classIndex
=0; section_names
[classIndex
]; classIndex
++) {
1946 printf("[%s]\n", section_names
[classIndex
]);
1947 for (parmIndex
= 0; parm_table
[parmIndex
].label
; parmIndex
++) {
1948 if (parm_table
[parmIndex
].p_class
== classIndex
) {
1949 show_parameter(parmIndex
);
1955 /***************************************************************************
1956 Get the standard string representation of a boolean value ("yes" or "no")
1957 ***************************************************************************/
1959 static const char *get_boolean(bool bool_value
)
1961 static const char *yes_str
= "yes";
1962 static const char *no_str
= "no";
1964 return (bool_value
? yes_str
: no_str
);
1967 /***************************************************************************
1968 Provide the string of the negated boolean value associated to the boolean
1969 given as a string. Returns false if the passed string does not correctly
1970 represent a boolean.
1971 ***************************************************************************/
1973 bool lp_invert_boolean(const char *str
, const char **inverse_str
)
1977 if (!set_boolean(str
, &val
)) {
1981 *inverse_str
= get_boolean(!val
);
1985 /***************************************************************************
1986 Provide the canonical string representation of a boolean value given
1987 as a string. Return true on success, false if the string given does
1988 not correctly represent a boolean.
1989 ***************************************************************************/
1991 bool lp_canonicalize_boolean(const char *str
, const char**canon_str
)
1995 if (!set_boolean(str
, &val
)) {
1999 *canon_str
= get_boolean(val
);
2003 /***************************************************************************
2004 Find a service by name. Otherwise works like get_service.
2005 ***************************************************************************/
2007 int getservicebyname(const char *pszServiceName
, struct loadparm_service
*pserviceDest
)
2014 if (ServiceHash
== NULL
) {
2018 canon_name
= canonicalize_servicename(talloc_tos(), pszServiceName
);
2020 status
= dbwrap_fetch_bystring(ServiceHash
, canon_name
, canon_name
,
2023 if (NT_STATUS_IS_OK(status
) &&
2024 (data
.dptr
!= NULL
) &&
2025 (data
.dsize
== sizeof(iService
)))
2027 memcpy(&iService
, data
.dptr
, sizeof(iService
));
2030 TALLOC_FREE(canon_name
);
2032 if ((iService
!= -1) && (LP_SNUM_OK(iService
))
2033 && (pserviceDest
!= NULL
)) {
2034 copy_service(pserviceDest
, ServicePtrs
[iService
], NULL
);
2040 /* Return a pointer to a service by name. Unlike getservicebyname, it does not copy the service */
2041 struct loadparm_service
*lp_service(const char *pszServiceName
)
2043 int iService
= getservicebyname(pszServiceName
, NULL
);
2044 if (iService
== -1 || !LP_SNUM_OK(iService
)) {
2047 return ServicePtrs
[iService
];
2050 struct loadparm_service
*lp_servicebynum(int snum
)
2052 if ((snum
== -1) || !LP_SNUM_OK(snum
)) {
2055 return ServicePtrs
[snum
];
2058 struct loadparm_service
*lp_default_loadparm_service()
2063 static struct smbconf_ctx
*lp_smbconf_ctx(void)
2066 static struct smbconf_ctx
*conf_ctx
= NULL
;
2068 if (conf_ctx
== NULL
) {
2069 err
= smbconf_init(NULL
, &conf_ctx
, "registry:");
2070 if (!SBC_ERROR_IS_OK(err
)) {
2071 DEBUG(1, ("error initializing registry configuration: "
2072 "%s\n", sbcErrorString(err
)));
2080 static bool process_smbconf_service(struct smbconf_service
*service
)
2085 if (service
== NULL
) {
2089 ret
= lp_do_section(service
->name
, NULL
);
2093 for (count
= 0; count
< service
->num_params
; count
++) {
2095 if (!bInGlobalSection
&& bGlobalOnly
) {
2098 const char *pszParmName
= service
->param_names
[count
];
2099 const char *pszParmValue
= service
->param_values
[count
];
2101 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName
, pszParmValue
));
2103 ret
= lp_do_parameter(bInGlobalSection
? -2 : iServiceIndex
,
2104 pszParmName
, pszParmValue
);
2111 if (iServiceIndex
>= 0) {
2112 return lpcfg_service_ok(ServicePtrs
[iServiceIndex
]);
2118 * load a service from registry and activate it
2120 bool process_registry_service(const char *service_name
)
2123 struct smbconf_service
*service
= NULL
;
2124 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
2125 struct smbconf_ctx
*conf_ctx
= lp_smbconf_ctx();
2128 if (conf_ctx
== NULL
) {
2132 DEBUG(5, ("process_registry_service: service name %s\n", service_name
));
2134 if (!smbconf_share_exists(conf_ctx
, service_name
)) {
2136 * Registry does not contain data for this service (yet),
2137 * but make sure lp_load doesn't return false.
2143 err
= smbconf_get_share(conf_ctx
, mem_ctx
, service_name
, &service
);
2144 if (!SBC_ERROR_IS_OK(err
)) {
2148 ret
= process_smbconf_service(service
);
2154 smbconf_changed(conf_ctx
, &conf_last_csn
, NULL
, NULL
);
2157 TALLOC_FREE(mem_ctx
);
2162 * process_registry_globals
2164 static bool process_registry_globals(void)
2168 add_to_file_list(NULL
, &file_lists
, INCLUDE_REGISTRY_NAME
, INCLUDE_REGISTRY_NAME
);
2170 if (!bInGlobalSection
&& bGlobalOnly
) {
2173 const char *pszParmName
= "registry shares";
2174 const char *pszParmValue
= "yes";
2176 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName
, pszParmValue
));
2178 ret
= lp_do_parameter(bInGlobalSection
? -2 : iServiceIndex
,
2179 pszParmName
, pszParmValue
);
2186 return process_registry_service(GLOBAL_NAME
);
2189 bool process_registry_shares(void)
2193 struct smbconf_service
**service
= NULL
;
2194 uint32_t num_shares
= 0;
2195 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
2196 struct smbconf_ctx
*conf_ctx
= lp_smbconf_ctx();
2199 if (conf_ctx
== NULL
) {
2203 err
= smbconf_get_config(conf_ctx
, mem_ctx
, &num_shares
, &service
);
2204 if (!SBC_ERROR_IS_OK(err
)) {
2210 for (count
= 0; count
< num_shares
; count
++) {
2211 if (strequal(service
[count
]->name
, GLOBAL_NAME
)) {
2214 ret
= process_smbconf_service(service
[count
]);
2221 smbconf_changed(conf_ctx
, &conf_last_csn
, NULL
, NULL
);
2224 TALLOC_FREE(mem_ctx
);
2229 * reload those shares from registry that are already
2230 * activated in the services array.
2232 static bool reload_registry_shares(void)
2237 for (i
= 0; i
< iNumServices
; i
++) {
2242 if (ServicePtrs
[i
]->usershare
== USERSHARE_VALID
) {
2246 ret
= process_registry_service(ServicePtrs
[i
]->szService
);
2257 #define MAX_INCLUDE_DEPTH 100
2259 static uint8_t include_depth
;
2262 * Free the file lists
2264 static void free_file_list(void)
2266 struct file_lists
*f
;
2267 struct file_lists
*next
;
2280 * Utility function for outsiders to check if we're running on registry.
2282 bool lp_config_backend_is_registry(void)
2284 return (lp_config_backend() == CONFIG_BACKEND_REGISTRY
);
2288 * Utility function to check if the config backend is FILE.
2290 bool lp_config_backend_is_file(void)
2292 return (lp_config_backend() == CONFIG_BACKEND_FILE
);
2295 /*******************************************************************
2296 Check if a config file has changed date.
2297 ********************************************************************/
2299 bool lp_file_list_changed(void)
2301 struct file_lists
*f
= file_lists
;
2303 DEBUG(6, ("lp_file_list_changed()\n"));
2306 if (strequal(f
->name
, INCLUDE_REGISTRY_NAME
)) {
2307 struct smbconf_ctx
*conf_ctx
= lp_smbconf_ctx();
2309 if (conf_ctx
== NULL
) {
2312 if (smbconf_changed(conf_ctx
, &conf_last_csn
, NULL
,
2315 DEBUGADD(6, ("registry config changed\n"));
2322 n2
= talloc_sub_basic(talloc_tos(),
2323 get_current_username(),
2324 current_user_info
.domain
,
2329 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
2330 f
->name
, n2
, ctime(&f
->modtime
)));
2332 mod_time
= file_modtime(n2
);
2335 ((f
->modtime
!= mod_time
) ||
2336 (f
->subfname
== NULL
) ||
2337 (strcmp(n2
, f
->subfname
) != 0)))
2340 ("file %s modified: %s\n", n2
,
2342 f
->modtime
= mod_time
;
2343 TALLOC_FREE(f
->subfname
);
2344 f
->subfname
= talloc_strdup(f
, n2
);
2345 if (f
->subfname
== NULL
) {
2346 smb_panic("talloc_strdup failed");
2360 * Initialize iconv conversion descriptors.
2362 * This is called the first time it is needed, and also called again
2363 * every time the configuration is reloaded, because the charset or
2364 * codepage might have changed.
2366 static void init_iconv(void)
2368 global_iconv_handle
= smb_iconv_handle_reinit(NULL
, lp_dos_charset(),
2370 true, global_iconv_handle
);
2373 /***************************************************************************
2374 Handle the include operation.
2375 ***************************************************************************/
2376 static bool bAllowIncludeRegistry
= true;
2378 bool lp_include(struct loadparm_context
*lp_ctx
, struct loadparm_service
*service
,
2379 const char *pszParmValue
, char **ptr
)
2383 if (include_depth
>= MAX_INCLUDE_DEPTH
) {
2384 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
2389 if (strequal(pszParmValue
, INCLUDE_REGISTRY_NAME
)) {
2390 if (!bAllowIncludeRegistry
) {
2393 if (lp_ctx
->bInGlobalSection
) {
2396 ret
= process_registry_globals();
2400 DEBUG(1, ("\"include = registry\" only effective "
2401 "in %s section\n", GLOBAL_NAME
));
2406 fname
= talloc_sub_basic(talloc_tos(), get_current_username(),
2407 current_user_info
.domain
,
2410 add_to_file_list(NULL
, &file_lists
, pszParmValue
, fname
);
2412 if (service
== NULL
) {
2413 lpcfg_string_set(Globals
.ctx
, ptr
, fname
);
2415 lpcfg_string_set(service
, ptr
, fname
);
2418 if (file_exist(fname
)) {
2421 ret
= pm_process(fname
, lp_do_section
, do_parameter
, lp_ctx
);
2427 DEBUG(2, ("Can't find include file %s\n", fname
));
2432 bool lp_idmap_range(const char *domain_name
, uint32_t *low
, uint32_t *high
)
2434 char *config_option
= NULL
;
2435 const char *range
= NULL
;
2438 SMB_ASSERT(low
!= NULL
);
2439 SMB_ASSERT(high
!= NULL
);
2441 if ((domain_name
== NULL
) || (domain_name
[0] == '\0')) {
2445 config_option
= talloc_asprintf(talloc_tos(), "idmap config %s",
2447 if (config_option
== NULL
) {
2448 DEBUG(0, ("out of memory\n"));
2452 range
= lp_parm_const_string(-1, config_option
, "range", NULL
);
2453 if (range
== NULL
) {
2454 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name
));
2458 if (sscanf(range
, "%u - %u", low
, high
) != 2) {
2459 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2460 range
, domain_name
));
2467 talloc_free(config_option
);
2472 bool lp_idmap_default_range(uint32_t *low
, uint32_t *high
)
2474 return lp_idmap_range("*", low
, high
);
2477 const char *lp_idmap_backend(const char *domain_name
)
2479 char *config_option
= NULL
;
2480 const char *backend
= NULL
;
2482 if ((domain_name
== NULL
) || (domain_name
[0] == '\0')) {
2486 config_option
= talloc_asprintf(talloc_tos(), "idmap config %s",
2488 if (config_option
== NULL
) {
2489 DEBUG(0, ("out of memory\n"));
2493 backend
= lp_parm_const_string(-1, config_option
, "backend", NULL
);
2494 if (backend
== NULL
) {
2495 DEBUG(1, ("idmap backend not specified for domain '%s'\n", domain_name
));
2500 talloc_free(config_option
);
2504 const char *lp_idmap_default_backend(void)
2506 return lp_idmap_backend("*");
2509 /***************************************************************************
2510 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2511 ***************************************************************************/
2513 static const char *append_ldap_suffix(TALLOC_CTX
*ctx
, const char *str
)
2515 const char *suffix_string
;
2517 suffix_string
= talloc_asprintf(ctx
, "%s,%s", str
,
2518 Globals
.ldap_suffix
);
2519 if ( !suffix_string
) {
2520 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2524 return suffix_string
;
2527 const char *lp_ldap_machine_suffix(TALLOC_CTX
*ctx
)
2529 if (Globals
._ldap_machine_suffix
[0])
2530 return append_ldap_suffix(ctx
, Globals
._ldap_machine_suffix
);
2532 return lp_string(ctx
, Globals
.ldap_suffix
);
2535 const char *lp_ldap_user_suffix(TALLOC_CTX
*ctx
)
2537 if (Globals
._ldap_user_suffix
[0])
2538 return append_ldap_suffix(ctx
, Globals
._ldap_user_suffix
);
2540 return lp_string(ctx
, Globals
.ldap_suffix
);
2543 const char *lp_ldap_group_suffix(TALLOC_CTX
*ctx
)
2545 if (Globals
._ldap_group_suffix
[0])
2546 return append_ldap_suffix(ctx
, Globals
._ldap_group_suffix
);
2548 return lp_string(ctx
, Globals
.ldap_suffix
);
2551 const char *lp_ldap_idmap_suffix(TALLOC_CTX
*ctx
)
2553 if (Globals
._ldap_idmap_suffix
[0])
2554 return append_ldap_suffix(ctx
, Globals
._ldap_idmap_suffix
);
2556 return lp_string(ctx
, Globals
.ldap_suffix
);
2560 return the parameter pointer for a parameter
2562 void *lp_parm_ptr(struct loadparm_service
*service
, struct parm_struct
*parm
)
2564 if (service
== NULL
) {
2565 if (parm
->p_class
== P_LOCAL
)
2566 return (void *)(((char *)&sDefault
)+parm
->offset
);
2567 else if (parm
->p_class
== P_GLOBAL
)
2568 return (void *)(((char *)&Globals
)+parm
->offset
);
2571 return (void *)(((char *)service
) + parm
->offset
);
2575 /***************************************************************************
2576 Process a parameter for a particular service number. If snum < 0
2577 then assume we are in the globals.
2578 ***************************************************************************/
2580 bool lp_do_parameter(int snum
, const char *pszParmName
, const char *pszParmValue
)
2582 TALLOC_CTX
*frame
= talloc_stackframe();
2583 struct loadparm_context
*lp_ctx
;
2586 lp_ctx
= setup_lp_context(frame
);
2587 if (lp_ctx
== NULL
) {
2593 ok
= lpcfg_do_global_parameter(lp_ctx
, pszParmName
, pszParmValue
);
2595 ok
= lpcfg_do_service_parameter(lp_ctx
, ServicePtrs
[snum
],
2596 pszParmName
, pszParmValue
);
2604 /***************************************************************************
2605 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
2606 FLAG_CMDLINE won't be overridden by loads from smb.conf.
2607 ***************************************************************************/
2609 static bool lp_set_cmdline_helper(const char *pszParmName
, const char *pszParmValue
)
2612 parmnum
= lpcfg_map_parameter(pszParmName
);
2614 flags_list
[parmnum
] &= ~FLAG_CMDLINE
;
2615 if (!lp_do_parameter(-1, pszParmName
, pszParmValue
)) {
2618 flags_list
[parmnum
] |= FLAG_CMDLINE
;
2620 /* we have to also set FLAG_CMDLINE on aliases. Aliases must
2621 * be grouped in the table, so we don't have to search the
2624 i
>=0 && parm_table
[i
].offset
== parm_table
[parmnum
].offset
2625 && parm_table
[i
].p_class
== parm_table
[parmnum
].p_class
;
2627 flags_list
[i
] |= FLAG_CMDLINE
;
2629 for (i
=parmnum
+1;i
<num_parameters() && parm_table
[i
].offset
== parm_table
[parmnum
].offset
2630 && parm_table
[i
].p_class
== parm_table
[parmnum
].p_class
;i
++) {
2631 flags_list
[i
] |= FLAG_CMDLINE
;
2637 /* it might be parametric */
2638 if (strchr(pszParmName
, ':') != NULL
) {
2639 set_param_opt(NULL
, &Globals
.param_opt
, pszParmName
, pszParmValue
, FLAG_CMDLINE
);
2643 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName
));
2647 bool lp_set_cmdline(const char *pszParmName
, const char *pszParmValue
)
2650 TALLOC_CTX
*frame
= talloc_stackframe();
2651 struct loadparm_context
*lp_ctx
;
2653 lp_ctx
= setup_lp_context(frame
);
2654 if (lp_ctx
== NULL
) {
2659 ret
= lpcfg_set_cmdline(lp_ctx
, pszParmName
, pszParmValue
);
2665 /***************************************************************************
2666 Process a parameter.
2667 ***************************************************************************/
2669 static bool do_parameter(const char *pszParmName
, const char *pszParmValue
,
2672 if (!bInGlobalSection
&& bGlobalOnly
)
2675 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName
, pszParmValue
));
2677 if (bInGlobalSection
) {
2678 return lpcfg_do_global_parameter(userdata
, pszParmName
, pszParmValue
);
2680 return lpcfg_do_service_parameter(userdata
, ServicePtrs
[iServiceIndex
],
2681 pszParmName
, pszParmValue
);
2685 /***************************************************************************
2686 Initialize any local variables in the sDefault table, after parsing a
2688 ***************************************************************************/
2690 static void init_locals(void)
2693 * We run this check once the [globals] is parsed, to force
2694 * the VFS objects and other per-share settings we need for
2695 * the standard way a AD DC is operated. We may change these
2696 * as our code evolves, which is why we force these settings.
2698 * We can't do this at the end of lp_load_ex(), as by that
2699 * point the services have been loaded and they will already
2700 * have "" as their vfs objects.
2702 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
) {
2703 const char **vfs_objects
= lp_vfs_objects(-1);
2704 if (!vfs_objects
|| !vfs_objects
[0]) {
2705 if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL
)) {
2706 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
2707 } else if (lp_parm_const_string(-1, "posix", "eadb", NULL
)) {
2708 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
2710 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
2714 lp_do_parameter(-1, "map hidden", "no");
2715 lp_do_parameter(-1, "map system", "no");
2716 lp_do_parameter(-1, "map readonly", "no");
2717 lp_do_parameter(-1, "map archive", "no");
2718 lp_do_parameter(-1, "store dos attributes", "yes");
2722 /***************************************************************************
2723 Process a new section (service). At this stage all sections are services.
2724 Later we'll have special sections that permit server parameters to be set.
2725 Returns true on success, false on failure.
2726 ***************************************************************************/
2728 bool lp_do_section(const char *pszSectionName
, void *userdata
)
2730 struct loadparm_context
*lp_ctx
= (struct loadparm_context
*)userdata
;
2732 bool isglobal
= ((strwicmp(pszSectionName
, GLOBAL_NAME
) == 0) ||
2733 (strwicmp(pszSectionName
, GLOBAL_NAME2
) == 0));
2736 /* if we were in a global section then do the local inits */
2737 if (bInGlobalSection
&& !isglobal
)
2740 /* if we've just struck a global section, note the fact. */
2741 bInGlobalSection
= isglobal
;
2742 if (lp_ctx
!= NULL
) {
2743 lp_ctx
->bInGlobalSection
= isglobal
;
2746 /* check for multiple global sections */
2747 if (bInGlobalSection
) {
2748 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName
));
2752 if (!bInGlobalSection
&& bGlobalOnly
)
2755 /* if we have a current service, tidy it up before moving on */
2758 if (iServiceIndex
>= 0)
2759 bRetval
= lpcfg_service_ok(ServicePtrs
[iServiceIndex
]);
2761 /* if all is still well, move to the next record in the services array */
2763 /* We put this here to avoid an odd message order if messages are */
2764 /* issued by the post-processing of a previous section. */
2765 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName
));
2767 iServiceIndex
= add_a_service(&sDefault
, pszSectionName
);
2768 if (iServiceIndex
< 0) {
2769 DEBUG(0, ("Failed to add a new service\n"));
2772 /* Clean all parametric options for service */
2773 /* They will be added during parsing again */
2774 free_param_opts(&ServicePtrs
[iServiceIndex
]->param_opt
);
2780 /***************************************************************************
2781 Display the contents of a parameter of a single services record.
2782 ***************************************************************************/
2784 bool dump_a_parameter(int snum
, char *parm_name
, FILE * f
, bool isGlobal
)
2786 bool result
= false;
2787 struct loadparm_context
*lp_ctx
;
2789 lp_ctx
= setup_lp_context(talloc_tos());
2790 if (lp_ctx
== NULL
) {
2795 result
= lpcfg_dump_a_parameter(lp_ctx
, NULL
, parm_name
, f
);
2797 result
= lpcfg_dump_a_parameter(lp_ctx
, ServicePtrs
[snum
], parm_name
, f
);
2799 TALLOC_FREE(lp_ctx
);
2804 /***************************************************************************
2805 Display the contents of a single copy structure.
2806 ***************************************************************************/
2807 static void dump_copy_map(bool *pcopymap
)
2813 printf("\n\tNon-Copied parameters:\n");
2815 for (i
= 0; parm_table
[i
].label
; i
++)
2816 if (parm_table
[i
].p_class
== P_LOCAL
&&
2817 parm_table
[i
].ptr
&& !pcopymap
[i
] &&
2818 (i
== 0 || (parm_table
[i
].ptr
!= parm_table
[i
- 1].ptr
)))
2820 printf("\t\t%s\n", parm_table
[i
].label
);
2825 /***************************************************************************
2826 Return TRUE if the passed service number is within range.
2827 ***************************************************************************/
2829 bool lp_snum_ok(int iService
)
2831 return (LP_SNUM_OK(iService
) && ServicePtrs
[iService
]->available
);
2834 /***************************************************************************
2835 Auto-load some home services.
2836 ***************************************************************************/
2838 static void lp_add_auto_services(char *str
)
2848 s
= talloc_strdup(talloc_tos(), str
);
2850 smb_panic("talloc_strdup failed");
2854 homes
= lp_servicenumber(HOMES_NAME
);
2856 for (p
= strtok_r(s
, LIST_SEP
, &saveptr
); p
;
2857 p
= strtok_r(NULL
, LIST_SEP
, &saveptr
)) {
2860 if (lp_servicenumber(p
) >= 0)
2863 home
= get_user_home_dir(talloc_tos(), p
);
2865 if (home
&& home
[0] && homes
>= 0)
2866 lp_add_home(p
, homes
, p
, home
);
2873 /***************************************************************************
2874 Auto-load one printer.
2875 ***************************************************************************/
2877 void lp_add_one_printer(const char *name
, const char *comment
,
2878 const char *location
, void *pdata
)
2880 int printers
= lp_servicenumber(PRINTERS_NAME
);
2883 if (lp_servicenumber(name
) < 0) {
2884 lp_add_printer(name
, printers
);
2885 if ((i
= lp_servicenumber(name
)) >= 0) {
2886 lpcfg_string_set(ServicePtrs
[i
],
2887 &ServicePtrs
[i
]->comment
, comment
);
2888 ServicePtrs
[i
]->autoloaded
= true;
2893 /***************************************************************************
2894 Have we loaded a services file yet?
2895 ***************************************************************************/
2897 bool lp_loaded(void)
2902 /***************************************************************************
2903 Unload unused services.
2904 ***************************************************************************/
2906 void lp_killunused(struct smbd_server_connection
*sconn
,
2907 bool (*snumused
) (struct smbd_server_connection
*, int))
2910 for (i
= 0; i
< iNumServices
; i
++) {
2914 /* don't kill autoloaded or usershare services */
2915 if ( ServicePtrs
[i
]->autoloaded
||
2916 ServicePtrs
[i
]->usershare
== USERSHARE_VALID
) {
2920 if (!snumused
|| !snumused(sconn
, i
)) {
2921 free_service_byindex(i
);
2927 * Kill all except autoloaded and usershare services - convenience wrapper
2929 void lp_kill_all_services(void)
2931 lp_killunused(NULL
, NULL
);
2934 /***************************************************************************
2936 ***************************************************************************/
2938 void lp_killservice(int iServiceIn
)
2940 if (VALID(iServiceIn
)) {
2941 free_service_byindex(iServiceIn
);
2945 /***************************************************************************
2946 Save the curent values of all global and sDefault parameters into the
2947 defaults union. This allows testparm to show only the
2948 changed (ie. non-default) parameters.
2949 ***************************************************************************/
2951 static void lp_save_defaults(void)
2954 struct parmlist_entry
* parm
;
2955 for (i
= 0; parm_table
[i
].label
; i
++) {
2956 if (!(flags_list
[i
] & FLAG_CMDLINE
)) {
2957 flags_list
[i
] |= FLAG_DEFAULT
;
2960 if (i
> 0 && parm_table
[i
].offset
== parm_table
[i
- 1].offset
2961 && parm_table
[i
].p_class
== parm_table
[i
- 1].p_class
)
2963 switch (parm_table
[i
].type
) {
2966 parm_table
[i
].def
.lvalue
= str_list_copy(
2967 NULL
, *(const char ***)lp_parm_ptr(NULL
, &parm_table
[i
]));
2973 &parm_table
[i
].def
.svalue
,
2974 *(char **)lp_parm_ptr(
2975 NULL
, &parm_table
[i
]));
2976 if (parm_table
[i
].def
.svalue
== NULL
) {
2977 smb_panic("lpcfg_string_set() failed");
2982 parm_table
[i
].def
.bvalue
=
2983 *(bool *)lp_parm_ptr(NULL
, &parm_table
[i
]);
2986 parm_table
[i
].def
.cvalue
=
2987 *(char *)lp_parm_ptr(NULL
, &parm_table
[i
]);
2993 parm_table
[i
].def
.ivalue
=
2994 *(int *)lp_parm_ptr(NULL
, &parm_table
[i
]);
2999 for (parm
=Globals
.param_opt
; parm
; parm
=parm
->next
) {
3000 if (!(parm
->priority
& FLAG_CMDLINE
)) {
3001 parm
->priority
|= FLAG_DEFAULT
;
3005 for (parm
=sDefault
.param_opt
; parm
; parm
=parm
->next
) {
3006 if (!(parm
->priority
& FLAG_CMDLINE
)) {
3007 parm
->priority
|= FLAG_DEFAULT
;
3011 defaults_saved
= true;
3014 /***********************************************************
3015 If we should send plaintext/LANMAN passwords in the clinet
3016 ************************************************************/
3018 static void set_allowed_client_auth(void)
3020 if (Globals
.client_ntlmv2_auth
) {
3021 Globals
.client_lanman_auth
= false;
3023 if (!Globals
.client_lanman_auth
) {
3024 Globals
.client_plaintext_auth
= false;
3028 /***************************************************************************
3030 The following code allows smbd to read a user defined share file.
3031 Yes, this is my intent. Yes, I'm comfortable with that...
3033 THE FOLLOWING IS SECURITY CRITICAL CODE.
3035 It washes your clothes, it cleans your house, it guards you while you sleep...
3036 Do not f%^k with it....
3037 ***************************************************************************/
3039 #define MAX_USERSHARE_FILE_SIZE (10*1024)
3041 /***************************************************************************
3042 Check allowed stat state of a usershare file.
3043 Ensure we print out who is dicking with us so the admin can
3044 get their sorry ass fired.
3045 ***************************************************************************/
3047 static bool check_usershare_stat(const char *fname
,
3048 const SMB_STRUCT_STAT
*psbuf
)
3050 if (!S_ISREG(psbuf
->st_ex_mode
)) {
3051 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3052 "not a regular file\n",
3053 fname
, (unsigned int)psbuf
->st_ex_uid
));
3057 /* Ensure this doesn't have the other write bit set. */
3058 if (psbuf
->st_ex_mode
& S_IWOTH
) {
3059 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
3060 "public write. Refusing to allow as a usershare file.\n",
3061 fname
, (unsigned int)psbuf
->st_ex_uid
));
3065 /* Should be 10k or less. */
3066 if (psbuf
->st_ex_size
> MAX_USERSHARE_FILE_SIZE
) {
3067 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3068 "too large (%u) to be a user share file.\n",
3069 fname
, (unsigned int)psbuf
->st_ex_uid
,
3070 (unsigned int)psbuf
->st_ex_size
));
3077 /***************************************************************************
3078 Parse the contents of a usershare file.
3079 ***************************************************************************/
3081 enum usershare_err
parse_usershare_file(TALLOC_CTX
*ctx
,
3082 SMB_STRUCT_STAT
*psbuf
,
3083 const char *servicename
,
3087 char **pp_sharepath
,
3089 char **pp_cp_servicename
,
3090 struct security_descriptor
**ppsd
,
3093 const char **prefixallowlist
= lp_usershare_prefix_allow_list();
3094 const char **prefixdenylist
= lp_usershare_prefix_deny_list();
3097 SMB_STRUCT_STAT sbuf
;
3098 char *sharepath
= NULL
;
3099 char *comment
= NULL
;
3101 *pp_sharepath
= NULL
;
3104 *pallow_guest
= false;
3107 return USERSHARE_MALFORMED_FILE
;
3110 if (strcmp(lines
[0], "#VERSION 1") == 0) {
3112 } else if (strcmp(lines
[0], "#VERSION 2") == 0) {
3115 return USERSHARE_MALFORMED_FILE
;
3118 return USERSHARE_BAD_VERSION
;
3121 if (strncmp(lines
[1], "path=", 5) != 0) {
3122 return USERSHARE_MALFORMED_PATH
;
3125 sharepath
= talloc_strdup(ctx
, &lines
[1][5]);
3127 return USERSHARE_POSIX_ERR
;
3129 trim_string(sharepath
, " ", " ");
3131 if (strncmp(lines
[2], "comment=", 8) != 0) {
3132 return USERSHARE_MALFORMED_COMMENT_DEF
;
3135 comment
= talloc_strdup(ctx
, &lines
[2][8]);
3137 return USERSHARE_POSIX_ERR
;
3139 trim_string(comment
, " ", " ");
3140 trim_char(comment
, '"', '"');
3142 if (strncmp(lines
[3], "usershare_acl=", 14) != 0) {
3143 return USERSHARE_MALFORMED_ACL_DEF
;
3146 if (!parse_usershare_acl(ctx
, &lines
[3][14], ppsd
)) {
3147 return USERSHARE_ACL_ERR
;
3151 if (strncmp(lines
[4], "guest_ok=", 9) != 0) {
3152 return USERSHARE_MALFORMED_ACL_DEF
;
3154 if (lines
[4][9] == 'y') {
3155 *pallow_guest
= true;
3158 /* Backwards compatible extension to file version #2. */
3160 if (strncmp(lines
[5], "sharename=", 10) != 0) {
3161 return USERSHARE_MALFORMED_SHARENAME_DEF
;
3163 if (!strequal(&lines
[5][10], servicename
)) {
3164 return USERSHARE_BAD_SHARENAME
;
3166 *pp_cp_servicename
= talloc_strdup(ctx
, &lines
[5][10]);
3167 if (!*pp_cp_servicename
) {
3168 return USERSHARE_POSIX_ERR
;
3173 if (*pp_cp_servicename
== NULL
) {
3174 *pp_cp_servicename
= talloc_strdup(ctx
, servicename
);
3175 if (!*pp_cp_servicename
) {
3176 return USERSHARE_POSIX_ERR
;
3180 if (snum
!= -1 && (strcmp(sharepath
, ServicePtrs
[snum
]->path
) == 0)) {
3181 /* Path didn't change, no checks needed. */
3182 *pp_sharepath
= sharepath
;
3183 *pp_comment
= comment
;
3184 return USERSHARE_OK
;
3187 /* The path *must* be absolute. */
3188 if (sharepath
[0] != '/') {
3189 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
3190 servicename
, sharepath
));
3191 return USERSHARE_PATH_NOT_ABSOLUTE
;
3194 /* If there is a usershare prefix deny list ensure one of these paths
3195 doesn't match the start of the user given path. */
3196 if (prefixdenylist
) {
3198 for ( i
=0; prefixdenylist
[i
]; i
++ ) {
3199 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
3200 servicename
, i
, prefixdenylist
[i
], sharepath
));
3201 if (memcmp( sharepath
, prefixdenylist
[i
], strlen(prefixdenylist
[i
])) == 0) {
3202 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
3203 "usershare prefix deny list entries.\n",
3204 servicename
, sharepath
));
3205 return USERSHARE_PATH_IS_DENIED
;
3210 /* If there is a usershare prefix allow list ensure one of these paths
3211 does match the start of the user given path. */
3213 if (prefixallowlist
) {
3215 for ( i
=0; prefixallowlist
[i
]; i
++ ) {
3216 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
3217 servicename
, i
, prefixallowlist
[i
], sharepath
));
3218 if (memcmp( sharepath
, prefixallowlist
[i
], strlen(prefixallowlist
[i
])) == 0) {
3222 if (prefixallowlist
[i
] == NULL
) {
3223 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
3224 "usershare prefix allow list entries.\n",
3225 servicename
, sharepath
));
3226 return USERSHARE_PATH_NOT_ALLOWED
;
3230 /* Ensure this is pointing to a directory. */
3231 dp
= opendir(sharepath
);
3234 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3235 servicename
, sharepath
));
3236 return USERSHARE_PATH_NOT_DIRECTORY
;
3239 /* Ensure the owner of the usershare file has permission to share
3242 if (sys_stat(sharepath
, &sbuf
, false) == -1) {
3243 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
3244 servicename
, sharepath
, strerror(errno
) ));
3246 return USERSHARE_POSIX_ERR
;
3251 if (!S_ISDIR(sbuf
.st_ex_mode
)) {
3252 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3253 servicename
, sharepath
));
3254 return USERSHARE_PATH_NOT_DIRECTORY
;
3257 /* Check if sharing is restricted to owner-only. */
3258 /* psbuf is the stat of the usershare definition file,
3259 sbuf is the stat of the target directory to be shared. */
3261 if (lp_usershare_owner_only()) {
3262 /* root can share anything. */
3263 if ((psbuf
->st_ex_uid
!= 0) && (sbuf
.st_ex_uid
!= psbuf
->st_ex_uid
)) {
3264 return USERSHARE_PATH_NOT_ALLOWED
;
3268 *pp_sharepath
= sharepath
;
3269 *pp_comment
= comment
;
3270 return USERSHARE_OK
;
3273 /***************************************************************************
3274 Deal with a usershare file.
3277 -1 - Bad name, invalid contents.
3278 - service name already existed and not a usershare, problem
3279 with permissions to share directory etc.
3280 ***************************************************************************/
3282 static int process_usershare_file(const char *dir_name
, const char *file_name
, int snum_template
)
3284 SMB_STRUCT_STAT sbuf
;
3285 SMB_STRUCT_STAT lsbuf
;
3287 char *sharepath
= NULL
;
3288 char *comment
= NULL
;
3289 char *cp_service_name
= NULL
;
3290 char **lines
= NULL
;
3294 TALLOC_CTX
*ctx
= talloc_stackframe();
3295 struct security_descriptor
*psd
= NULL
;
3296 bool guest_ok
= false;
3297 char *canon_name
= NULL
;
3298 bool added_service
= false;
3301 /* Ensure share name doesn't contain invalid characters. */
3302 if (!validate_net_name(file_name
, INVALID_SHARENAME_CHARS
, strlen(file_name
))) {
3303 DEBUG(0,("process_usershare_file: share name %s contains "
3304 "invalid characters (any of %s)\n",
3305 file_name
, INVALID_SHARENAME_CHARS
));
3309 canon_name
= canonicalize_servicename(ctx
, file_name
);
3314 fname
= talloc_asprintf(ctx
, "%s/%s", dir_name
, file_name
);
3319 /* Minimize the race condition by doing an lstat before we
3320 open and fstat. Ensure this isn't a symlink link. */
3322 if (sys_lstat(fname
, &lsbuf
, false) != 0) {
3323 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
3324 fname
, strerror(errno
) ));
3328 /* This must be a regular file, not a symlink, directory or
3329 other strange filetype. */
3330 if (!check_usershare_stat(fname
, &lsbuf
)) {
3338 status
= dbwrap_fetch_bystring(ServiceHash
, canon_name
,
3343 if (NT_STATUS_IS_OK(status
) &&
3344 (data
.dptr
!= NULL
) &&
3345 (data
.dsize
== sizeof(iService
))) {
3346 memcpy(&iService
, data
.dptr
, sizeof(iService
));
3350 if (iService
!= -1 &&
3351 timespec_compare(&ServicePtrs
[iService
]->usershare_last_mod
,
3352 &lsbuf
.st_ex_mtime
) == 0) {
3353 /* Nothing changed - Mark valid and return. */
3354 DEBUG(10,("process_usershare_file: service %s not changed.\n",
3356 ServicePtrs
[iService
]->usershare
= USERSHARE_VALID
;
3361 /* Try and open the file read only - no symlinks allowed. */
3363 fd
= open(fname
, O_RDONLY
|O_NOFOLLOW
, 0);
3365 fd
= open(fname
, O_RDONLY
, 0);
3369 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
3370 fname
, strerror(errno
) ));
3374 /* Now fstat to be *SURE* it's a regular file. */
3375 if (sys_fstat(fd
, &sbuf
, false) != 0) {
3377 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
3378 fname
, strerror(errno
) ));
3382 /* Is it the same dev/inode as was lstated ? */
3383 if (!check_same_stat(&lsbuf
, &sbuf
)) {
3385 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
3386 "Symlink spoofing going on ?\n", fname
));
3390 /* This must be a regular file, not a symlink, directory or
3391 other strange filetype. */
3392 if (!check_usershare_stat(fname
, &sbuf
)) {
3397 lines
= fd_lines_load(fd
, &numlines
, MAX_USERSHARE_FILE_SIZE
, NULL
);
3400 if (lines
== NULL
) {
3401 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
3402 fname
, (unsigned int)sbuf
.st_ex_uid
));
3406 if (parse_usershare_file(ctx
, &sbuf
, file_name
,
3407 iService
, lines
, numlines
, &sharepath
,
3408 &comment
, &cp_service_name
,
3409 &psd
, &guest_ok
) != USERSHARE_OK
) {
3413 /* Everything ok - add the service possibly using a template. */
3415 const struct loadparm_service
*sp
= &sDefault
;
3416 if (snum_template
!= -1) {
3417 sp
= ServicePtrs
[snum_template
];
3420 if ((iService
= add_a_service(sp
, cp_service_name
)) < 0) {
3421 DEBUG(0, ("process_usershare_file: Failed to add "
3422 "new service %s\n", cp_service_name
));
3426 added_service
= true;
3428 /* Read only is controlled by usershare ACL below. */
3429 ServicePtrs
[iService
]->read_only
= false;
3432 /* Write the ACL of the new/modified share. */
3433 if (!set_share_security(canon_name
, psd
)) {
3434 DEBUG(0, ("process_usershare_file: Failed to set share "
3435 "security for user share %s\n",
3440 /* If from a template it may be marked invalid. */
3441 ServicePtrs
[iService
]->valid
= true;
3443 /* Set the service as a valid usershare. */
3444 ServicePtrs
[iService
]->usershare
= USERSHARE_VALID
;
3446 /* Set guest access. */
3447 if (lp_usershare_allow_guests()) {
3448 ServicePtrs
[iService
]->guest_ok
= guest_ok
;
3451 /* And note when it was loaded. */
3452 ServicePtrs
[iService
]->usershare_last_mod
= sbuf
.st_ex_mtime
;
3453 lpcfg_string_set(ServicePtrs
[iService
], &ServicePtrs
[iService
]->path
,
3455 lpcfg_string_set(ServicePtrs
[iService
],
3456 &ServicePtrs
[iService
]->comment
, comment
);
3462 if (ret
== -1 && iService
!= -1 && added_service
) {
3463 lp_remove_service(iService
);
3471 /***************************************************************************
3472 Checks if a usershare entry has been modified since last load.
3473 ***************************************************************************/
3475 static bool usershare_exists(int iService
, struct timespec
*last_mod
)
3477 SMB_STRUCT_STAT lsbuf
;
3478 const char *usersharepath
= Globals
.usershare_path
;
3481 fname
= talloc_asprintf(talloc_tos(),
3484 ServicePtrs
[iService
]->szService
);
3485 if (fname
== NULL
) {
3489 if (sys_lstat(fname
, &lsbuf
, false) != 0) {
3494 if (!S_ISREG(lsbuf
.st_ex_mode
)) {
3500 *last_mod
= lsbuf
.st_ex_mtime
;
3504 /***************************************************************************
3505 Load a usershare service by name. Returns a valid servicenumber or -1.
3506 ***************************************************************************/
3508 int load_usershare_service(const char *servicename
)
3510 SMB_STRUCT_STAT sbuf
;
3511 const char *usersharepath
= Globals
.usershare_path
;
3512 int max_user_shares
= Globals
.usershare_max_shares
;
3513 int snum_template
= -1;
3515 if (*usersharepath
== 0 || max_user_shares
== 0) {
3519 if (sys_stat(usersharepath
, &sbuf
, false) != 0) {
3520 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
3521 usersharepath
, strerror(errno
) ));
3525 if (!S_ISDIR(sbuf
.st_ex_mode
)) {
3526 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
3532 * This directory must be owned by root, and have the 't' bit set.
3533 * It also must not be writable by "other".
3537 if (sbuf
.st_ex_uid
!= 0 || !(sbuf
.st_ex_mode
& S_ISVTX
) || (sbuf
.st_ex_mode
& S_IWOTH
)) {
3539 if (sbuf
.st_ex_uid
!= 0 || (sbuf
.st_ex_mode
& S_IWOTH
)) {
3541 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
3542 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3547 /* Ensure the template share exists if it's set. */
3548 if (Globals
.usershare_template_share
[0]) {
3549 /* We can't use lp_servicenumber here as we are recommending that
3550 template shares have -valid=false set. */
3551 for (snum_template
= iNumServices
- 1; snum_template
>= 0; snum_template
--) {
3552 if (ServicePtrs
[snum_template
]->szService
&&
3553 strequal(ServicePtrs
[snum_template
]->szService
,
3554 Globals
.usershare_template_share
)) {
3559 if (snum_template
== -1) {
3560 DEBUG(0,("load_usershare_service: usershare template share %s "
3561 "does not exist.\n",
3562 Globals
.usershare_template_share
));
3567 return process_usershare_file(usersharepath
, servicename
, snum_template
);
3570 /***************************************************************************
3571 Load all user defined shares from the user share directory.
3572 We only do this if we're enumerating the share list.
3573 This is the function that can delete usershares that have
3575 ***************************************************************************/
3577 int load_usershare_shares(struct smbd_server_connection
*sconn
,
3578 bool (*snumused
) (struct smbd_server_connection
*, int))
3581 SMB_STRUCT_STAT sbuf
;
3583 int num_usershares
= 0;
3584 int max_user_shares
= Globals
.usershare_max_shares
;
3585 unsigned int num_dir_entries
, num_bad_dir_entries
, num_tmp_dir_entries
;
3586 unsigned int allowed_bad_entries
= ((2*max_user_shares
)/10);
3587 unsigned int allowed_tmp_entries
= ((2*max_user_shares
)/10);
3589 int snum_template
= -1;
3590 const char *usersharepath
= Globals
.usershare_path
;
3591 int ret
= lp_numservices();
3592 TALLOC_CTX
*tmp_ctx
;
3594 if (max_user_shares
== 0 || *usersharepath
== '\0') {
3595 return lp_numservices();
3598 if (sys_stat(usersharepath
, &sbuf
, false) != 0) {
3599 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
3600 usersharepath
, strerror(errno
) ));
3605 * This directory must be owned by root, and have the 't' bit set.
3606 * It also must not be writable by "other".
3610 if (sbuf
.st_ex_uid
!= 0 || !(sbuf
.st_ex_mode
& S_ISVTX
) || (sbuf
.st_ex_mode
& S_IWOTH
)) {
3612 if (sbuf
.st_ex_uid
!= 0 || (sbuf
.st_ex_mode
& S_IWOTH
)) {
3614 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
3615 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3620 /* Ensure the template share exists if it's set. */
3621 if (Globals
.usershare_template_share
[0]) {
3622 /* We can't use lp_servicenumber here as we are recommending that
3623 template shares have -valid=false set. */
3624 for (snum_template
= iNumServices
- 1; snum_template
>= 0; snum_template
--) {
3625 if (ServicePtrs
[snum_template
]->szService
&&
3626 strequal(ServicePtrs
[snum_template
]->szService
,
3627 Globals
.usershare_template_share
)) {
3632 if (snum_template
== -1) {
3633 DEBUG(0,("load_usershare_shares: usershare template share %s "
3634 "does not exist.\n",
3635 Globals
.usershare_template_share
));
3640 /* Mark all existing usershares as pending delete. */
3641 for (iService
= iNumServices
- 1; iService
>= 0; iService
--) {
3642 if (VALID(iService
) && ServicePtrs
[iService
]->usershare
) {
3643 ServicePtrs
[iService
]->usershare
= USERSHARE_PENDING_DELETE
;
3647 dp
= opendir(usersharepath
);
3649 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
3650 usersharepath
, strerror(errno
) ));
3654 for (num_dir_entries
= 0, num_bad_dir_entries
= 0, num_tmp_dir_entries
= 0;
3656 num_dir_entries
++ ) {
3658 const char *n
= de
->d_name
;
3660 /* Ignore . and .. */
3662 if ((n
[1] == '\0') || (n
[1] == '.' && n
[2] == '\0')) {
3668 /* Temporary file used when creating a share. */
3669 num_tmp_dir_entries
++;
3672 /* Allow 20% tmp entries. */
3673 if (num_tmp_dir_entries
> allowed_tmp_entries
) {
3674 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
3675 "in directory %s\n",
3676 num_tmp_dir_entries
, usersharepath
));
3680 r
= process_usershare_file(usersharepath
, n
, snum_template
);
3682 /* Update the services count. */
3684 if (num_usershares
>= max_user_shares
) {
3685 DEBUG(0,("load_usershare_shares: max user shares reached "
3686 "on file %s in directory %s\n",
3687 n
, usersharepath
));
3690 } else if (r
== -1) {
3691 num_bad_dir_entries
++;
3694 /* Allow 20% bad entries. */
3695 if (num_bad_dir_entries
> allowed_bad_entries
) {
3696 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
3697 "in directory %s\n",
3698 num_bad_dir_entries
, usersharepath
));
3702 /* Allow 20% bad entries. */
3703 if (num_dir_entries
> max_user_shares
+ allowed_bad_entries
) {
3704 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
3705 "in directory %s\n",
3706 num_dir_entries
, usersharepath
));
3713 /* Sweep through and delete any non-refreshed usershares that are
3714 not currently in use. */
3715 tmp_ctx
= talloc_stackframe();
3716 for (iService
= iNumServices
- 1; iService
>= 0; iService
--) {
3717 if (VALID(iService
) && (ServicePtrs
[iService
]->usershare
== USERSHARE_PENDING_DELETE
)) {
3720 if (snumused
&& snumused(sconn
, iService
)) {
3724 servname
= lp_servicename(tmp_ctx
, iService
);
3726 /* Remove from the share ACL db. */
3727 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
3729 delete_share_security(servname
);
3730 free_service_byindex(iService
);
3733 talloc_free(tmp_ctx
);
3735 return lp_numservices();
3738 /********************************************************
3739 Destroy global resources allocated in this file
3740 ********************************************************/
3742 void gfree_loadparm(void)
3748 /* Free resources allocated to services */
3750 for ( i
= 0; i
< iNumServices
; i
++ ) {
3752 free_service_byindex(i
);
3756 TALLOC_FREE( ServicePtrs
);
3759 /* Now release all resources allocated to global
3760 parameters and the default service */
3762 free_global_parameters();
3766 /***************************************************************************
3767 Allow client apps to specify that they are a client
3768 ***************************************************************************/
3769 static void lp_set_in_client(bool b
)
3775 /***************************************************************************
3776 Determine if we're running in a client app
3777 ***************************************************************************/
3778 static bool lp_is_in_client(void)
3783 static void lp_enforce_ad_dc_settings(void)
3785 lp_do_parameter(GLOBAL_SECTION_SNUM
, "passdb backend", "samba_dsdb");
3786 lp_do_parameter(GLOBAL_SECTION_SNUM
,
3787 "winbindd:use external pipes", "true");
3788 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:default", "external");
3789 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:svcctl", "embedded");
3790 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:srvsvc", "embedded");
3791 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:eventlog", "embedded");
3792 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:ntsvcs", "embedded");
3793 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:winreg", "embedded");
3794 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:spoolss", "embedded");
3795 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_daemon:spoolssd", "embedded");
3796 lp_do_parameter(GLOBAL_SECTION_SNUM
, "rpc_server:tcpip", "no");
3799 /***************************************************************************
3800 Load the services array from the services file. Return true on success,
3802 ***************************************************************************/
3804 static bool lp_load_ex(const char *pszFname
,
3808 bool reinit_globals
,
3809 bool allow_include_registry
,
3810 bool load_all_shares
)
3814 TALLOC_CTX
*frame
= talloc_stackframe();
3815 struct loadparm_context
*lp_ctx
;
3819 DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
3821 bInGlobalSection
= true;
3822 bGlobalOnly
= global_only
;
3823 bAllowIncludeRegistry
= allow_include_registry
;
3825 lp_ctx
= setup_lp_context(talloc_tos());
3827 init_globals(lp_ctx
, reinit_globals
);
3831 if (save_defaults
) {
3836 if (!reinit_globals
) {
3837 free_param_opts(&Globals
.param_opt
);
3838 apply_lp_set_cmdline();
3841 lp_do_parameter(-1, "idmap config * : backend", Globals
.idmap_backend
);
3843 /* We get sections first, so have to start 'behind' to make up */
3846 if (lp_config_backend_is_file()) {
3847 n2
= talloc_sub_basic(talloc_tos(), get_current_username(),
3848 current_user_info
.domain
,
3851 smb_panic("lp_load_ex: out of memory");
3854 add_to_file_list(NULL
, &file_lists
, pszFname
, n2
);
3856 bRetval
= pm_process(n2
, lp_do_section
, do_parameter
, lp_ctx
);
3859 /* finish up the last section */
3860 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval
)));
3862 if (iServiceIndex
>= 0) {
3863 bRetval
= lpcfg_service_ok(ServicePtrs
[iServiceIndex
]);
3867 if (lp_config_backend_is_registry()) {
3869 /* config backend changed to registry in config file */
3871 * We need to use this extra global variable here to
3872 * survive restart: init_globals uses this as a default
3873 * for config_backend. Otherwise, init_globals would
3874 * send us into an endless loop here.
3877 config_backend
= CONFIG_BACKEND_REGISTRY
;
3879 DEBUG(1, ("lp_load_ex: changing to config backend "
3881 init_globals(lp_ctx
, true);
3883 TALLOC_FREE(lp_ctx
);
3885 lp_kill_all_services();
3886 ok
= lp_load_ex(pszFname
, global_only
, save_defaults
,
3887 add_ipc
, reinit_globals
,
3888 allow_include_registry
,
3893 } else if (lp_config_backend_is_registry()) {
3894 bRetval
= process_registry_globals();
3896 DEBUG(0, ("Illegal config backend given: %d\n",
3897 lp_config_backend()));
3901 if (bRetval
&& lp_registry_shares()) {
3902 if (load_all_shares
) {
3903 bRetval
= process_registry_shares();
3905 bRetval
= reload_registry_shares();
3910 char *serv
= lp_auto_services(talloc_tos());
3911 lp_add_auto_services(serv
);
3916 /* When 'restrict anonymous = 2' guest connections to ipc$
3918 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
3919 if ( lp_enable_asu_support() ) {
3920 lp_add_ipc("ADMIN$", false);
3924 set_allowed_client_auth();
3926 if (lp_security() == SEC_ADS
&& strchr(lp_password_server(), ':')) {
3927 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
3928 lp_password_server()));
3933 /* Now we check we_are_a_wins_server and set szWINSserver to 127.0.0.1 */
3934 /* if we_are_a_wins_server is true and we are in the client */
3935 if (lp_is_in_client() && Globals
.we_are_a_wins_server
) {
3936 lp_do_parameter(GLOBAL_SECTION_SNUM
, "wins server", "127.0.0.1");
3941 fault_configure(smb_panic_s3
);
3944 * We run this check once the whole smb.conf is parsed, to
3945 * force some settings for the standard way a AD DC is
3946 * operated. We may change these as our code evolves, which
3947 * is why we force these settings.
3949 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
) {
3950 lp_enforce_ad_dc_settings();
3953 bAllowIncludeRegistry
= true;
3959 static bool lp_load(const char *pszFname
,
3963 bool reinit_globals
)
3965 return lp_load_ex(pszFname
,
3970 true, /* allow_include_registry */
3971 false); /* load_all_shares*/
3974 bool lp_load_initial_only(const char *pszFname
)
3976 return lp_load_ex(pszFname
,
3977 true, /* global only */
3978 true, /* save_defaults */
3979 false, /* add_ipc */
3980 true, /* reinit_globals */
3981 false, /* allow_include_registry */
3982 false); /* load_all_shares*/
3986 * most common lp_load wrapper, loading only the globals
3988 * If this is used in a daemon or client utility it should be called
3989 * after processing popt.
3991 bool lp_load_global(const char *file_name
)
3993 return lp_load(file_name
,
3994 true, /* global_only */
3995 false, /* save_defaults */
3996 false, /* add_ipc */
3997 true); /* reinit_globals */
4001 * The typical lp_load wrapper with shares, loads global and
4002 * shares, including IPC, but does not force immediate
4003 * loading of all shares from registry.
4005 bool lp_load_with_shares(const char *file_name
)
4007 return lp_load(file_name
,
4008 false, /* global_only */
4009 false, /* save_defaults */
4011 true); /* reinit_globals */
4015 * lp_load wrapper, especially for clients
4017 bool lp_load_client(const char *file_name
)
4019 lp_set_in_client(true);
4021 return lp_load_global(file_name
);
4025 * lp_load wrapper, loading only globals, but intended
4026 * for subsequent calls, not reinitializing the globals
4029 bool lp_load_global_no_reinit(const char *file_name
)
4031 return lp_load(file_name
,
4032 true, /* global_only */
4033 false, /* save_defaults */
4034 false, /* add_ipc */
4035 false); /* reinit_globals */
4039 * lp_load wrapper, loading globals and shares,
4040 * intended for subsequent calls, i.e. not reinitializing
4041 * the globals to default values.
4043 bool lp_load_no_reinit(const char *file_name
)
4045 return lp_load(file_name
,
4046 false, /* global_only */
4047 false, /* save_defaults */
4048 false, /* add_ipc */
4049 false); /* reinit_globals */
4054 * lp_load wrapper, especially for clients, no reinitialization
4056 bool lp_load_client_no_reinit(const char *file_name
)
4058 lp_set_in_client(true);
4060 return lp_load_global_no_reinit(file_name
);
4063 bool lp_load_with_registry_shares(const char *pszFname
)
4065 return lp_load_ex(pszFname
,
4066 false, /* global_only */
4067 true, /* save_defaults */
4068 false, /* add_ipc */
4069 false, /* reinit_globals */
4070 true, /* allow_include_registry */
4071 true); /* load_all_shares*/
4074 /***************************************************************************
4075 Return the max number of services.
4076 ***************************************************************************/
4078 int lp_numservices(void)
4080 return (iNumServices
);
4083 /***************************************************************************
4084 Display the contents of the services array in human-readable form.
4085 ***************************************************************************/
4087 void lp_dump(FILE *f
, bool show_defaults
, int maxtoprint
)
4090 struct loadparm_context
*lp_ctx
;
4093 defaults_saved
= false;
4095 lp_ctx
= setup_lp_context(talloc_tos());
4096 if (lp_ctx
== NULL
) {
4100 lpcfg_dump_globals(lp_ctx
, f
, !defaults_saved
);
4102 lpcfg_dump_a_service(&sDefault
, &sDefault
, f
, flags_list
, show_defaults
);
4104 for (iService
= 0; iService
< maxtoprint
; iService
++) {
4106 lp_dump_one(f
, show_defaults
, iService
);
4110 /***************************************************************************
4111 Display the contents of one service in human-readable form.
4112 ***************************************************************************/
4114 void lp_dump_one(FILE * f
, bool show_defaults
, int snum
)
4117 if (ServicePtrs
[snum
]->szService
[0] == '\0')
4119 lpcfg_dump_a_service(ServicePtrs
[snum
], &sDefault
, f
,
4120 flags_list
, show_defaults
);
4124 /***************************************************************************
4125 Return the number of the service with the given name, or -1 if it doesn't
4126 exist. Note that this is a DIFFERENT ANIMAL from the internal function
4127 getservicebyname()! This works ONLY if all services have been loaded, and
4128 does not copy the found service.
4129 ***************************************************************************/
4131 int lp_servicenumber(const char *pszServiceName
)
4134 fstring serviceName
;
4136 if (!pszServiceName
) {
4137 return GLOBAL_SECTION_SNUM
;
4140 for (iService
= iNumServices
- 1; iService
>= 0; iService
--) {
4141 if (VALID(iService
) && ServicePtrs
[iService
]->szService
) {
4143 * The substitution here is used to support %U in
4146 fstrcpy(serviceName
, ServicePtrs
[iService
]->szService
);
4147 standard_sub_basic(get_current_username(),
4148 current_user_info
.domain
,
4149 serviceName
,sizeof(serviceName
));
4150 if (strequal(serviceName
, pszServiceName
)) {
4156 if (iService
>= 0 && ServicePtrs
[iService
]->usershare
== USERSHARE_VALID
) {
4157 struct timespec last_mod
;
4159 if (!usershare_exists(iService
, &last_mod
)) {
4160 /* Remove the share security tdb entry for it. */
4161 delete_share_security(lp_servicename(talloc_tos(), iService
));
4162 /* Remove it from the array. */
4163 free_service_byindex(iService
);
4164 /* Doesn't exist anymore. */
4165 return GLOBAL_SECTION_SNUM
;
4168 /* Has it been modified ? If so delete and reload. */
4169 if (timespec_compare(&ServicePtrs
[iService
]->usershare_last_mod
,
4171 /* Remove it from the array. */
4172 free_service_byindex(iService
);
4173 /* and now reload it. */
4174 iService
= load_usershare_service(pszServiceName
);
4179 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName
));
4180 return GLOBAL_SECTION_SNUM
;
4186 /*******************************************************************
4187 A useful volume label function.
4188 ********************************************************************/
4190 const char *volume_label(TALLOC_CTX
*ctx
, int snum
)
4193 const char *label
= lp_volume(ctx
, snum
);
4195 label
= lp_servicename(ctx
, snum
);
4198 /* This returns a 33 byte guarenteed null terminated string. */
4199 ret
= talloc_strndup(ctx
, label
, 32);
4206 /*******************************************************************
4207 Get the default server type we will announce as via nmbd.
4208 ********************************************************************/
4210 int lp_default_server_announce(void)
4212 int default_server_announce
= 0;
4213 default_server_announce
|= SV_TYPE_WORKSTATION
;
4214 default_server_announce
|= SV_TYPE_SERVER
;
4215 default_server_announce
|= SV_TYPE_SERVER_UNIX
;
4217 /* note that the flag should be set only if we have a
4218 printer service but nmbd doesn't actually load the
4219 services so we can't tell --jerry */
4221 default_server_announce
|= SV_TYPE_PRINTQ_SERVER
;
4223 default_server_announce
|= SV_TYPE_SERVER_NT
;
4224 default_server_announce
|= SV_TYPE_NT
;
4226 switch (lp_server_role()) {
4227 case ROLE_DOMAIN_MEMBER
:
4228 default_server_announce
|= SV_TYPE_DOMAIN_MEMBER
;
4230 case ROLE_DOMAIN_PDC
:
4231 default_server_announce
|= SV_TYPE_DOMAIN_CTRL
;
4233 case ROLE_DOMAIN_BDC
:
4234 default_server_announce
|= SV_TYPE_DOMAIN_BAKCTRL
;
4236 case ROLE_STANDALONE
:
4240 if (lp_time_server())
4241 default_server_announce
|= SV_TYPE_TIME_SOURCE
;
4243 if (lp_host_msdfs())
4244 default_server_announce
|= SV_TYPE_DFS_SERVER
;
4246 return default_server_announce
;
4249 /***********************************************************
4250 If we are PDC then prefer us as DMB
4251 ************************************************************/
4253 bool lp_domain_master(void)
4255 if (Globals
._domain_master
== Auto
)
4256 return (lp_server_role() == ROLE_DOMAIN_PDC
);
4258 return (bool)Globals
._domain_master
;
4261 /***********************************************************
4262 If we are PDC then prefer us as DMB
4263 ************************************************************/
4265 static bool lp_domain_master_true_or_auto(void)
4267 if (Globals
._domain_master
) /* auto or yes */
4273 /***********************************************************
4274 If we are DMB then prefer us as LMB
4275 ************************************************************/
4277 bool lp_preferred_master(void)
4279 int preferred_master
= lp__preferred_master();
4281 if (preferred_master
== Auto
)
4282 return (lp_local_master() && lp_domain_master());
4284 return (bool)preferred_master
;
4287 /*******************************************************************
4289 ********************************************************************/
4291 void lp_remove_service(int snum
)
4293 ServicePtrs
[snum
]->valid
= false;
4296 const char *lp_printername(TALLOC_CTX
*ctx
, int snum
)
4298 const char *ret
= lp__printername(ctx
, snum
);
4299 if (ret
== NULL
|| *ret
== '\0') {
4300 ret
= lp_const_servicename(snum
);
4307 /***********************************************************
4308 Allow daemons such as winbindd to fix their logfile name.
4309 ************************************************************/
4311 void lp_set_logfile(const char *name
)
4313 lpcfg_string_set(Globals
.ctx
, &Globals
.logfile
, name
);
4314 debug_set_logfile(name
);
4317 /*******************************************************************
4318 Return the max print jobs per queue.
4319 ********************************************************************/
4321 int lp_maxprintjobs(int snum
)
4323 int maxjobs
= lp_max_print_jobs(snum
);
4325 if (maxjobs
<= 0 || maxjobs
>= PRINT_MAX_JOBID
)
4326 maxjobs
= PRINT_MAX_JOBID
- 1;
4331 const char *lp_printcapname(void)
4333 const char *printcap_name
= lp_printcap_name();
4335 if ((printcap_name
!= NULL
) &&
4336 (printcap_name
[0] != '\0'))
4337 return printcap_name
;
4339 if (sDefault
.printing
== PRINT_CUPS
) {
4343 if (sDefault
.printing
== PRINT_BSD
)
4344 return "/etc/printcap";
4346 return PRINTCAP_NAME
;
4349 static uint32_t spoolss_state
;
4351 bool lp_disable_spoolss( void )
4353 if ( spoolss_state
== SVCCTL_STATE_UNKNOWN
)
4354 spoolss_state
= lp__disable_spoolss() ? SVCCTL_STOPPED
: SVCCTL_RUNNING
;
4356 return spoolss_state
== SVCCTL_STOPPED
? true : false;
4359 void lp_set_spoolss_state( uint32_t state
)
4361 SMB_ASSERT( (state
== SVCCTL_STOPPED
) || (state
== SVCCTL_RUNNING
) );
4363 spoolss_state
= state
;
4366 uint32_t lp_get_spoolss_state( void )
4368 return lp_disable_spoolss() ? SVCCTL_STOPPED
: SVCCTL_RUNNING
;
4371 /*******************************************************************
4372 Ensure we don't use sendfile if server smb signing is active.
4373 ********************************************************************/
4375 bool lp_use_sendfile(int snum
, struct smb_signing_state
*signing_state
)
4377 bool sign_active
= false;
4379 /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
4380 if (get_Protocol() < PROTOCOL_NT1
) {
4383 if (signing_state
) {
4384 sign_active
= smb_signing_is_active(signing_state
);
4386 return (lp__use_sendfile(snum
) &&
4387 (get_remote_arch() != RA_WIN95
) &&
4391 /*******************************************************************
4392 Turn off sendfile if we find the underlying OS doesn't support it.
4393 ********************************************************************/
4395 void set_use_sendfile(int snum
, bool val
)
4397 if (LP_SNUM_OK(snum
))
4398 ServicePtrs
[snum
]->_use_sendfile
= val
;
4400 sDefault
._use_sendfile
= val
;
4403 void lp_set_mangling_method(const char *new_method
)
4405 lpcfg_string_set(Globals
.ctx
, &Globals
.mangling_method
, new_method
);
4408 /*******************************************************************
4409 Global state for POSIX pathname processing.
4410 ********************************************************************/
4412 static bool posix_pathnames
;
4414 bool lp_posix_pathnames(void)
4416 return posix_pathnames
;
4419 /*******************************************************************
4420 Change everything needed to ensure POSIX pathname processing (currently
4422 ********************************************************************/
4424 void lp_set_posix_pathnames(void)
4426 posix_pathnames
= true;
4429 /*******************************************************************
4430 Global state for POSIX lock processing - CIFS unix extensions.
4431 ********************************************************************/
4433 bool posix_default_lock_was_set
;
4434 static enum brl_flavour posix_cifsx_locktype
; /* By default 0 == WINDOWS_LOCK */
4436 enum brl_flavour
lp_posix_cifsu_locktype(files_struct
*fsp
)
4438 if (posix_default_lock_was_set
) {
4439 return posix_cifsx_locktype
;
4441 return (fsp
->posix_flags
& FSP_POSIX_FLAGS_OPEN
) ?
4442 POSIX_LOCK
: WINDOWS_LOCK
;
4446 /*******************************************************************
4447 ********************************************************************/
4449 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val
)
4451 posix_default_lock_was_set
= true;
4452 posix_cifsx_locktype
= val
;
4455 int lp_min_receive_file_size(void)
4457 int min_receivefile_size
= lp_min_receivefile_size();
4459 if (min_receivefile_size
< 0) {
4462 return min_receivefile_size
;
4465 /*******************************************************************
4466 Safe wide links checks.
4467 This helper function always verify the validity of wide links,
4468 even after a configuration file reload.
4469 ********************************************************************/
4471 void widelinks_warning(int snum
)
4473 if (lp_allow_insecure_wide_links()) {
4477 if (lp_unix_extensions() && lp_wide_links(snum
)) {
4478 DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
4479 "These parameters are incompatible. "
4480 "Wide links will be disabled for this share.\n",
4481 lp_servicename(talloc_tos(), snum
) ));
4485 bool lp_widelinks(int snum
)
4487 /* wide links is always incompatible with unix extensions */
4488 if (lp_unix_extensions()) {
4490 * Unless we have "allow insecure widelinks"
4493 if (!lp_allow_insecure_wide_links()) {
4498 return lp_wide_links(snum
);
4501 int lp_server_role(void)
4503 return lp_find_server_role(lp__server_role(),
4505 lp__domain_logons(),
4506 lp_domain_master_true_or_auto());
4509 int lp_security(void)
4511 return lp_find_security(lp__server_role(),
4515 int lp_client_max_protocol(void)
4517 int client_max_protocol
= lp__client_max_protocol();
4518 if (client_max_protocol
== PROTOCOL_DEFAULT
) {
4519 return PROTOCOL_NT1
;
4521 return client_max_protocol
;
4524 int lp_client_ipc_min_protocol(void)
4526 int client_ipc_min_protocol
= lp__client_ipc_min_protocol();
4527 if (client_ipc_min_protocol
== PROTOCOL_DEFAULT
) {
4528 client_ipc_min_protocol
= lp_client_min_protocol();
4530 if (client_ipc_min_protocol
< PROTOCOL_NT1
) {
4531 return PROTOCOL_NT1
;
4533 return client_ipc_min_protocol
;
4536 int lp_client_ipc_max_protocol(void)
4538 int client_ipc_max_protocol
= lp__client_ipc_max_protocol();
4539 if (client_ipc_max_protocol
== PROTOCOL_DEFAULT
) {
4540 return PROTOCOL_LATEST
;
4542 if (client_ipc_max_protocol
< PROTOCOL_NT1
) {
4543 return PROTOCOL_NT1
;
4545 return client_ipc_max_protocol
;
4548 int lp_client_ipc_signing(void)
4550 int client_ipc_signing
= lp__client_ipc_signing();
4551 if (client_ipc_signing
== SMB_SIGNING_DEFAULT
) {
4552 return SMB_SIGNING_REQUIRED
;
4554 return client_ipc_signing
;
4557 int lp_rpc_low_port(void)
4559 return Globals
.rpc_low_port
;
4562 int lp_rpc_high_port(void)
4564 return Globals
.rpc_high_port
;
4567 struct loadparm_global
* get_globals(void)
4572 unsigned int * get_flags(void)
4574 if (flags_list
== NULL
) {
4575 flags_list
= talloc_zero_array(NULL
, unsigned int, num_parameters());