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"
74 #include "libcli/auth/ntlm_check.h"
76 #ifdef HAVE_SYS_SYSCTL_H
77 #include <sys/sysctl.h>
82 extern userdom_struct current_user_info;
84 /* the special value for the include parameter
85 * to be interpreted not as a file name but to
86 * trigger loading of the global smb.conf options
88 #ifndef INCLUDE_REGISTRY_NAME
89 #define INCLUDE_REGISTRY_NAME "registry"
92 static bool in_client = false; /* Not in the client by default */
93 static struct smbconf_csn conf_last_csn;
95 static int config_backend = CONFIG_BACKEND_FILE;
97 /* some helpful bits */
98 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && \
99 (ServicePtrs != NULL) && \
100 (ServicePtrs[(i)] != NULL) && ServicePtrs[(i)]->valid)
101 #define VALID(i) ((ServicePtrs != NULL) && (ServicePtrs[i]!= NULL) && \
102 ServicePtrs[i]->valid)
104 #define USERSHARE_VALID 1
105 #define USERSHARE_PENDING_DELETE 2
107 static bool defaults_saved = false;
109 #include "lib/param/param_global.h"
111 static struct loadparm_global Globals;
113 /* This is a default service used to prime a services structure */
114 static const struct loadparm_service _sDefault =
119 .usershare_last_mod = {0, 0},
122 .invalid_users = NULL,
129 .root_preexec = NULL,
130 .root_postexec = NULL,
131 .cups_options = NULL,
132 .print_command = NULL,
134 .lprm_command = NULL,
135 .lppause_command = NULL,
136 .lpresume_command = NULL,
137 .queuepause_command = NULL,
138 .queueresume_command = NULL,
139 ._printername = NULL,
140 .printjob_username = NULL,
141 .dont_descend = NULL,
144 .magic_script = NULL,
145 .magic_output = NULL,
148 .veto_oplock_files = NULL,
158 .aio_write_behind = NULL,
159 .dfree_command = NULL,
160 .min_print_space = 0,
161 .max_print_jobs = 1000,
162 .max_reported_print_jobs = 0,
163 .write_cache_size = 0,
165 .force_create_mode = 0,
166 .directory_mask = 0755,
167 .force_directory_mode = 0,
168 .max_connections = 0,
169 .default_case = CASE_LOWER,
170 .printing = DEFAULT_PRINTING,
173 .dfree_cache_time = 0,
174 .preexec_close = false,
175 .root_preexec_close = false,
176 .case_sensitive = Auto,
177 .preserve_case = true,
178 .short_preserve_case = true,
179 .hide_dot_files = true,
180 .hide_special_files = false,
181 .hide_unreadable = false,
182 .hide_unwriteable_files = false,
184 .access_based_share_enum = false,
189 .administrative_share = false,
192 .print_notify_backchannel = false,
196 .store_dos_attributes = 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 .map_acl_inherit = false,
235 .acl_check_permissions = true,
236 .acl_map_full_control = true,
237 .acl_group_control = false,
238 .acl_allow_execute_always = false,
239 .allocation_roundup_size = SMB_ROUNDUP_ALLOCATION_SIZE,
242 .map_readonly = MAP_READONLY_YES,
243 .directory_name_cache_size = 100,
244 .smb_encrypt = SMB_SIGNING_DEFAULT,
245 .kernel_share_modes = true,
246 .durable_handles = true,
252 * This is a copy of the default service structure. Service options in the
253 * global section would otherwise overwrite the initial default values.
255 static struct loadparm_service sDefault;
257 /* local variables */
258 static struct loadparm_service **ServicePtrs = NULL;
259 static int iNumServices = 0;
260 static int iServiceIndex = 0;
261 static struct db_context *ServiceHash;
262 static bool bInGlobalSection = true;
263 static bool bGlobalOnly = false;
264 static struct file_lists *file_lists = NULL;
265 static unsigned int *flags_list = NULL;
267 static void set_allowed_client_auth(void);
269 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue);
270 static void free_param_opts(struct parmlist_entry **popts);
273 * Function to return the default value for the maximum number of open
274 * file descriptors permitted. This function tries to consult the
275 * kernel-level (sysctl) and ulimit (getrlimit()) values and goes
276 * the smaller of those.
278 static int max_open_files(void)
280 int sysctl_max = MAX_OPEN_FILES;
281 int rlimit_max = MAX_OPEN_FILES;
283 #ifdef HAVE_SYSCTLBYNAME
285 size_t size = sizeof(sysctl_max);
286 sysctlbyname("kern.maxfilesperproc", &sysctl_max, &size, NULL,
291 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
297 if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
298 rlimit_max = rl.rlim_cur;
300 #if defined(RLIM_INFINITY)
301 if(rl.rlim_cur == RLIM_INFINITY)
302 rlimit_max = MAX_OPEN_FILES;
307 if (sysctl_max < MIN_OPEN_FILES_WINDOWS) {
308 DEBUG(2,("max_open_files: increasing sysctl_max (%d) to "
309 "minimum Windows limit (%d)\n",
311 MIN_OPEN_FILES_WINDOWS));
312 sysctl_max = MIN_OPEN_FILES_WINDOWS;
315 if (rlimit_max < MIN_OPEN_FILES_WINDOWS) {
316 DEBUG(2,("rlimit_max: increasing rlimit_max (%d) to "
317 "minimum Windows limit (%d)\n",
319 MIN_OPEN_FILES_WINDOWS));
320 rlimit_max = MIN_OPEN_FILES_WINDOWS;
323 return MIN(sysctl_max, rlimit_max);
327 * Common part of freeing allocated data for one parameter.
329 static void free_one_parameter_common(void *parm_ptr,
330 struct parm_struct parm)
332 if ((parm.type == P_STRING) ||
333 (parm.type == P_USTRING))
335 lpcfg_string_free((char**)parm_ptr);
336 } else if (parm.type == P_LIST || parm.type == P_CMDLIST) {
337 TALLOC_FREE(*((char***)parm_ptr));
342 * Free the allocated data for one parameter for a share
343 * given as a service struct.
345 static void free_one_parameter(struct loadparm_service *service,
346 struct parm_struct parm)
350 if (parm.p_class != P_LOCAL) {
354 parm_ptr = lp_parm_ptr(service, &parm);
356 free_one_parameter_common(parm_ptr, parm);
360 * Free the allocated parameter data of a share given
361 * as a service struct.
363 static void free_parameters(struct loadparm_service *service)
367 for (i=0; parm_table[i].label; i++) {
368 free_one_parameter(service, parm_table[i]);
373 * Free the allocated data for one parameter for a given share
374 * specified by an snum.
376 static void free_one_parameter_by_snum(int snum, struct parm_struct parm)
381 parm_ptr = lp_parm_ptr(NULL, &parm);
382 } else if (parm.p_class != P_LOCAL) {
385 parm_ptr = lp_parm_ptr(ServicePtrs[snum], &parm);
388 free_one_parameter_common(parm_ptr, parm);
392 * Free the allocated parameter data for a share specified
395 static void free_parameters_by_snum(int snum)
399 for (i=0; parm_table[i].label; i++) {
400 free_one_parameter_by_snum(snum, parm_table[i]);
405 * Free the allocated global parameters.
407 static void free_global_parameters(void)
410 struct parm_struct *parm;
412 free_param_opts(&Globals.param_opt);
413 free_parameters_by_snum(GLOBAL_SECTION_SNUM);
415 /* Reset references in the defaults because the context is going to be freed */
416 for (i=0; parm_table[i].label; i++) {
417 parm = &parm_table[i];
418 if ((parm->type == P_STRING) ||
419 (parm->type == P_USTRING)) {
420 if ((parm->def.svalue != NULL) &&
421 (*(parm->def.svalue) != '\0')) {
422 if (talloc_parent(parm->def.svalue) == Globals.ctx) {
423 parm->def.svalue = NULL;
428 TALLOC_FREE(Globals.ctx);
431 struct lp_stored_option {
432 struct lp_stored_option *prev, *next;
437 static struct lp_stored_option *stored_options;
440 save options set by lp_set_cmdline() into a list. This list is
441 re-applied when we do a globals reset, so that cmdline set options
442 are sticky across reloads of smb.conf
444 bool store_lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
446 struct lp_stored_option *entry, *entry_next;
447 for (entry = stored_options; entry != NULL; entry = entry_next) {
448 entry_next = entry->next;
449 if (strcmp(pszParmName, entry->label) == 0) {
450 DLIST_REMOVE(stored_options, entry);
456 entry = talloc(NULL, struct lp_stored_option);
461 entry->label = talloc_strdup(entry, pszParmName);
467 entry->value = talloc_strdup(entry, pszParmValue);
473 DLIST_ADD_END(stored_options, entry);
478 static bool apply_lp_set_cmdline(void)
480 struct lp_stored_option *entry = NULL;
481 for (entry = stored_options; entry != NULL; entry = entry->next) {
482 if (!lp_set_cmdline_helper(entry->label, entry->value)) {
483 DEBUG(0, ("Failed to re-apply cmdline parameter %s = %s\n",
484 entry->label, entry->value));
491 /***************************************************************************
492 Initialise the global parameter structure.
493 ***************************************************************************/
495 static void init_globals(struct loadparm_context *lp_ctx, bool reinit_globals)
497 static bool done_init = false;
501 /* If requested to initialize only once and we've already done it... */
502 if (!reinit_globals && done_init) {
503 /* ... then we have nothing more to do */
508 /* The logfile can be set before this is invoked. Free it if so. */
509 lpcfg_string_free(&Globals.logfile);
512 free_global_parameters();
515 /* This memset and the free_global_parameters() above will
516 * wipe out smb.conf options set with lp_set_cmdline(). The
517 * apply_lp_set_cmdline() call puts these values back in the
518 * table once the defaults are set */
519 ZERO_STRUCT(Globals);
521 Globals.ctx = talloc_pooled_object(NULL, char, 272, 2048);
523 /* Initialize the flags list if necessary */
524 if (flags_list == NULL) {
528 for (i = 0; parm_table[i].label; i++) {
529 if ((parm_table[i].type == P_STRING ||
530 parm_table[i].type == P_USTRING))
534 (char **)lp_parm_ptr(NULL, &parm_table[i]),
540 lpcfg_string_set(Globals.ctx, &sDefault.fstype, FSTYPE_STRING);
541 lpcfg_string_set(Globals.ctx, &sDefault.printjob_username, "%U");
543 init_printer_values(lp_ctx, Globals.ctx, &sDefault);
545 sDefault.ntvfs_handler = str_list_make_v3_const(NULL, "unixuid default", NULL);
547 DEBUG(3, ("Initialising global parameters\n"));
549 /* Must manually force to upper case here, as this does not go via the handler */
550 lpcfg_string_set(Globals.ctx, &Globals.netbios_name,
553 lpcfg_string_set(Globals.ctx, &Globals.smb_passwd_file,
554 get_dyn_SMB_PASSWD_FILE());
555 lpcfg_string_set(Globals.ctx, &Globals.private_dir,
556 get_dyn_PRIVATE_DIR());
557 lpcfg_string_set(Globals.ctx, &Globals.binddns_dir,
558 get_dyn_BINDDNS_DIR());
560 /* use the new 'hash2' method by default, with a prefix of 1 */
561 lpcfg_string_set(Globals.ctx, &Globals.mangling_method, "hash2");
562 Globals.mangle_prefix = 1;
564 lpcfg_string_set(Globals.ctx, &Globals.guest_account, GUEST_ACCOUNT);
566 /* using UTF8 by default allows us to support all chars */
567 lpcfg_string_set(Globals.ctx, &Globals.unix_charset,
568 DEFAULT_UNIX_CHARSET);
570 /* Use codepage 850 as a default for the dos character set */
571 lpcfg_string_set(Globals.ctx, &Globals.dos_charset,
572 DEFAULT_DOS_CHARSET);
575 * Allow the default PASSWD_CHAT to be overridden in local.h.
577 lpcfg_string_set(Globals.ctx, &Globals.passwd_chat,
578 DEFAULT_PASSWD_CHAT);
580 lpcfg_string_set(Globals.ctx, &Globals.workgroup, DEFAULT_WORKGROUP);
582 lpcfg_string_set(Globals.ctx, &Globals.passwd_program, "");
583 lpcfg_string_set(Globals.ctx, &Globals.lock_directory,
585 lpcfg_string_set(Globals.ctx, &Globals.state_directory,
587 lpcfg_string_set(Globals.ctx, &Globals.cache_directory,
589 lpcfg_string_set(Globals.ctx, &Globals.pid_directory,
591 lpcfg_string_set(Globals.ctx, &Globals.nbt_client_socket_address,
594 * By default support explicit binding to broadcast
597 Globals.nmbd_bind_explicit_broadcast = true;
599 s = talloc_asprintf(talloc_tos(), "Samba %s", samba_version_string());
601 smb_panic("init_globals: ENOMEM");
603 lpcfg_string_set(Globals.ctx, &Globals.server_string, s);
606 lpcfg_string_set(Globals.ctx, &Globals.panic_action,
607 "/bin/sleep 999999999");
610 lpcfg_string_set(Globals.ctx, &Globals.socket_options,
611 DEFAULT_SOCKET_OPTIONS);
613 lpcfg_string_set(Globals.ctx, &Globals.logon_drive, "");
614 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
615 lpcfg_string_set(Globals.ctx, &Globals.logon_home, "\\\\%N\\%U");
616 lpcfg_string_set(Globals.ctx, &Globals.logon_path,
617 "\\\\%N\\%U\\profile");
619 Globals.name_resolve_order =
620 str_list_make_v3_const(Globals.ctx,
621 DEFAULT_NAME_RESOLVE_ORDER,
623 lpcfg_string_set(Globals.ctx, &Globals.password_server, "*");
625 Globals.algorithmic_rid_base = BASE_RID;
627 Globals.load_printers = true;
628 Globals.printcap_cache_time = 750; /* 12.5 minutes */
630 Globals.config_backend = config_backend;
631 Globals._server_role = ROLE_AUTO;
633 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
634 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
635 Globals.max_xmit = 0x4104;
636 Globals.max_mux = 50; /* This is *needed* for profile support. */
637 Globals.lpq_cache_time = 30; /* changed to handle large print servers better -- jerry */
638 Globals._disable_spoolss = false;
639 Globals.max_smbd_processes = 0;/* no limit specified */
640 Globals.username_level = 0;
641 Globals.deadtime = 0;
642 Globals.getwd_cache = true;
643 Globals.large_readwrite = true;
644 Globals.max_log_size = 5000;
645 Globals.max_open_files = max_open_files();
646 Globals.server_max_protocol = PROTOCOL_SMB3_11;
647 Globals.server_min_protocol = PROTOCOL_LANMAN1;
648 Globals._client_max_protocol = PROTOCOL_DEFAULT;
649 Globals.client_min_protocol = PROTOCOL_CORE;
650 Globals._client_ipc_max_protocol = PROTOCOL_DEFAULT;
651 Globals._client_ipc_min_protocol = PROTOCOL_DEFAULT;
652 Globals._security = SEC_AUTO;
653 Globals.encrypt_passwords = true;
654 Globals.client_schannel = Auto;
655 Globals.winbind_sealed_pipes = true;
656 Globals.require_strong_key = true;
657 Globals.server_schannel = Auto;
658 Globals.read_raw = true;
659 Globals.write_raw = true;
660 Globals.null_passwords = false;
661 Globals.old_password_allowed_period = 60;
662 Globals.obey_pam_restrictions = false;
664 Globals.syslog_only = false;
665 Globals.timestamp_logs = true;
666 lpcfg_string_set(Globals.ctx, &Globals.log_level, "0");
667 Globals.debug_prefix_timestamp = false;
668 Globals.debug_hires_timestamp = true;
669 Globals.debug_pid = false;
670 Globals.debug_uid = false;
671 Globals.debug_class = false;
672 Globals.enable_core_files = true;
673 Globals.max_ttl = 60 * 60 * 24 * 3; /* 3 days default. */
674 Globals.max_wins_ttl = 60 * 60 * 24 * 6; /* 6 days default. */
675 Globals.min_wins_ttl = 60 * 60 * 6; /* 6 hours default. */
676 Globals.machine_password_timeout = 60 * 60 * 24 * 7; /* 7 days default. */
677 Globals.lm_announce = Auto; /* = Auto: send only if LM clients found */
678 Globals.lm_interval = 60;
679 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
680 Globals.nis_homedir = false;
681 #ifdef WITH_NISPLUS_HOME
682 lpcfg_string_set(Globals.ctx, &Globals.homedir_map,
683 "auto_home.org_dir");
685 lpcfg_string_set(Globals.ctx, &Globals.homedir_map, "auto.home");
688 Globals.time_server = false;
689 Globals.bind_interfaces_only = false;
690 Globals.unix_password_sync = false;
691 Globals.pam_password_change = false;
692 Globals.passwd_chat_debug = false;
693 Globals.passwd_chat_timeout = 2; /* 2 second default. */
694 Globals.nt_pipe_support = true; /* Do NT pipes by default. */
695 Globals.nt_status_support = true; /* Use NT status by default. */
696 Globals.smbd_profiling_level = 0;
697 Globals.stat_cache = true; /* use stat cache by default */
698 Globals.max_stat_cache_size = 256; /* 256k by default */
699 Globals.restrict_anonymous = 0;
700 Globals.client_lanman_auth = false; /* Do NOT use the LanMan hash if it is available */
701 Globals.client_plaintext_auth = false; /* Do NOT use a plaintext password even if is requested by the server */
702 Globals._lanman_auth = false; /* Do NOT use the LanMan hash, even if it is supplied */
703 Globals.ntlm_auth = NTLM_AUTH_NTLMV2_ONLY; /* Do NOT use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
704 Globals.raw_ntlmv2_auth = false; /* Reject NTLMv2 without NTLMSSP */
705 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 */
706 /* Note, that we will also use NTLM2 session security (which is different), if it is available */
708 Globals.allow_dcerpc_auth_level_connect = false; /* we don't allow this by default */
710 Globals.map_to_guest = 0; /* By Default, "Never" */
711 Globals.oplock_break_wait_time = 0; /* By Default, 0 msecs. */
712 Globals.enhanced_browsing = true;
713 Globals.lock_spin_time = WINDOWS_MINIMUM_LOCK_TIMEOUT_MS; /* msec. */
714 #ifdef MMAP_BLACKLIST
715 Globals.use_mmap = false;
717 Globals.use_mmap = true;
719 Globals.unicode = true;
720 Globals.unix_extensions = true;
721 Globals.reset_on_zero_vc = false;
722 Globals.log_writeable_files_on_exit = false;
723 Globals.create_krb5_conf = true;
724 Globals.include_system_krb5_conf = true;
725 Globals._winbind_max_domain_connections = 1;
727 /* hostname lookups can be very expensive and are broken on
728 a large number of sites (tridge) */
729 Globals.hostname_lookups = false;
731 Globals.change_notify = true,
732 Globals.kernel_change_notify = true,
734 lpcfg_string_set(Globals.ctx, &Globals.passdb_backend, "tdbsam");
735 lpcfg_string_set(Globals.ctx, &Globals.ldap_suffix, "");
736 lpcfg_string_set(Globals.ctx, &Globals._ldap_machine_suffix, "");
737 lpcfg_string_set(Globals.ctx, &Globals._ldap_user_suffix, "");
738 lpcfg_string_set(Globals.ctx, &Globals._ldap_group_suffix, "");
739 lpcfg_string_set(Globals.ctx, &Globals._ldap_idmap_suffix, "");
741 lpcfg_string_set(Globals.ctx, &Globals.ldap_admin_dn, "");
742 Globals.ldap_ssl = LDAP_SSL_START_TLS;
743 Globals.ldap_ssl_ads = false;
744 Globals.ldap_deref = -1;
745 Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
746 Globals.ldap_delete_dn = false;
747 Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
748 Globals.ldap_follow_referral = Auto;
749 Globals.ldap_timeout = LDAP_DEFAULT_TIMEOUT;
750 Globals.ldap_connection_timeout = LDAP_CONNECTION_DEFAULT_TIMEOUT;
751 Globals.ldap_page_size = LDAP_PAGE_SIZE;
753 Globals.ldap_debug_level = 0;
754 Globals.ldap_debug_threshold = 10;
756 Globals.client_ldap_sasl_wrapping = ADS_AUTH_SASL_SIGN;
758 Globals.ldap_server_require_strong_auth =
759 LDAP_SERVER_REQUIRE_STRONG_AUTH_YES;
761 /* This is what we tell the afs client. in reality we set the token
762 * to never expire, though, when this runs out the afs client will
763 * forget the token. Set to 0 to get NEVERDATE.*/
764 Globals.afs_token_lifetime = 604800;
765 Globals.cups_connection_timeout = CUPS_DEFAULT_CONNECTION_TIMEOUT;
767 /* these parameters are set to defaults that are more appropriate
768 for the increasing samba install base:
770 as a member of the workgroup, that will possibly become a
771 _local_ master browser (lm = true). this is opposed to a forced
772 local master browser startup (pm = true).
774 doesn't provide WINS server service by default (wsupp = false),
775 and doesn't provide domain master browser services by default, either.
779 Globals.show_add_printer_wizard = true;
780 Globals.os_level = 20;
781 Globals.local_master = true;
782 Globals._domain_master = Auto; /* depending on _domain_logons */
783 Globals._domain_logons = false;
784 Globals.browse_list = true;
785 Globals.we_are_a_wins_server = false;
786 Globals.wins_proxy = false;
788 TALLOC_FREE(Globals.init_logon_delayed_hosts);
789 Globals.init_logon_delay = 100; /* 100 ms default delay */
791 Globals.wins_dns_proxy = true;
793 Globals.allow_trusted_domains = true;
794 lpcfg_string_set(Globals.ctx, &Globals.idmap_backend, "tdb");
796 lpcfg_string_set(Globals.ctx, &Globals.template_shell, "/bin/false");
797 lpcfg_string_set(Globals.ctx, &Globals.template_homedir,
799 lpcfg_string_set(Globals.ctx, &Globals.winbind_separator, "\\");
800 lpcfg_string_set(Globals.ctx, &Globals.winbindd_socket_directory,
801 dyn_WINBINDD_SOCKET_DIR);
803 lpcfg_string_set(Globals.ctx, &Globals.cups_server, "");
804 lpcfg_string_set(Globals.ctx, &Globals.iprint_server, "");
806 lpcfg_string_set(Globals.ctx, &Globals._ctdbd_socket, "");
808 Globals.cluster_addresses = NULL;
809 Globals.clustering = false;
810 Globals.ctdb_timeout = 0;
811 Globals.ctdb_locktime_warn_threshold = 0;
813 Globals.winbind_cache_time = 300; /* 5 minutes */
814 Globals.winbind_reconnect_delay = 30; /* 30 seconds */
815 Globals.winbind_request_timeout = 60; /* 60 seconds */
816 Globals.winbind_max_clients = 200;
817 Globals.winbind_enum_users = false;
818 Globals.winbind_enum_groups = false;
819 Globals.winbind_use_default_domain = false;
820 Globals.winbind_nested_groups = true;
821 Globals.winbind_expand_groups = 0;
822 Globals.winbind_nss_info = str_list_make_v3_const(NULL, "template", NULL);
823 Globals.winbind_refresh_tickets = false;
824 Globals.winbind_offline_logon = false;
826 Globals.idmap_cache_time = 86400 * 7; /* a week by default */
827 Globals.idmap_negative_cache_time = 120; /* 2 minutes by default */
829 Globals.passdb_expand_explicit = false;
831 Globals.name_cache_timeout = 660; /* In seconds */
833 Globals.client_use_spnego = true;
835 Globals.client_signing = SMB_SIGNING_DEFAULT;
836 Globals._client_ipc_signing = SMB_SIGNING_DEFAULT;
837 Globals.server_signing = SMB_SIGNING_DEFAULT;
839 Globals.defer_sharing_violations = true;
840 Globals.smb_ports = str_list_make_v3_const(NULL, SMB_PORTS, NULL);
842 Globals.enable_privileges = true;
843 Globals.host_msdfs = true;
844 Globals.enable_asu_support = false;
846 /* User defined shares. */
847 s = talloc_asprintf(talloc_tos(), "%s/usershares", get_dyn_STATEDIR());
849 smb_panic("init_globals: ENOMEM");
851 lpcfg_string_set(Globals.ctx, &Globals.usershare_path, s);
853 lpcfg_string_set(Globals.ctx, &Globals.usershare_template_share, "");
854 Globals.usershare_max_shares = 0;
855 /* By default disallow sharing of directories not owned by the sharer. */
856 Globals.usershare_owner_only = true;
857 /* By default disallow guest access to usershares. */
858 Globals.usershare_allow_guests = false;
860 Globals.keepalive = DEFAULT_KEEPALIVE;
862 /* By default no shares out of the registry */
863 Globals.registry_shares = false;
865 Globals.min_receivefile_size = 0;
867 Globals.multicast_dns_register = true;
869 Globals.smb2_max_read = DEFAULT_SMB2_MAX_READ;
870 Globals.smb2_max_write = DEFAULT_SMB2_MAX_WRITE;
871 Globals.smb2_max_trans = DEFAULT_SMB2_MAX_TRANSACT;
872 Globals.smb2_max_credits = DEFAULT_SMB2_MAX_CREDITS;
873 Globals.smb2_leases = true;
875 lpcfg_string_set(Globals.ctx, &Globals.ncalrpc_dir,
876 get_dyn_NCALRPCDIR());
878 Globals.server_services = str_list_make_v3_const(NULL, "s3fs rpc nbt wrepl ldap cldap kdc drepl winbindd ntp_signd kcc dnsupdate dns", NULL);
880 Globals.dcerpc_endpoint_servers = str_list_make_v3_const(NULL, "epmapper wkssvc rpcecho samr netlogon lsarpc drsuapi dssetup unixinfo browser eventlog6 backupkey dnsserver", NULL);
882 Globals.tls_enabled = true;
883 Globals.tls_verify_peer = TLS_VERIFY_PEER_AS_STRICT_AS_POSSIBLE;
885 lpcfg_string_set(Globals.ctx, &Globals._tls_keyfile, "tls/key.pem");
886 lpcfg_string_set(Globals.ctx, &Globals._tls_certfile, "tls/cert.pem");
887 lpcfg_string_set(Globals.ctx, &Globals._tls_cafile, "tls/ca.pem");
888 lpcfg_string_set(Globals.ctx, &Globals.tls_priority,
889 "NORMAL:-VERS-SSL3.0");
891 lpcfg_string_set(Globals.ctx, &Globals.share_backend, "classic");
893 Globals._preferred_master = Auto;
895 Globals.allow_dns_updates = DNS_UPDATE_SIGNED;
897 lpcfg_string_set(Globals.ctx, &Globals.ntp_signd_socket_directory,
898 get_dyn_NTP_SIGND_SOCKET_DIR());
900 s = talloc_asprintf(talloc_tos(), "%s/samba_kcc", get_dyn_SCRIPTSBINDIR());
902 smb_panic("init_globals: ENOMEM");
904 Globals.samba_kcc_command = str_list_make_v3_const(NULL, s, NULL);
908 Globals.mit_kdc_command = str_list_make_v3_const(NULL, MIT_KDC_PATH, NULL);
911 s = talloc_asprintf(talloc_tos(), "%s/samba_dnsupdate", get_dyn_SCRIPTSBINDIR());
913 smb_panic("init_globals: ENOMEM");
915 Globals.dns_update_command = str_list_make_v3_const(NULL, s, NULL);
918 s = talloc_asprintf(talloc_tos(), "%s/samba_gpoupdate", get_dyn_SCRIPTSBINDIR());
920 smb_panic("init_globals: ENOMEM");
922 Globals.gpo_update_command = str_list_make_v3_const(NULL, s, NULL);
925 s = talloc_asprintf(talloc_tos(), "%s/samba_spnupdate", get_dyn_SCRIPTSBINDIR());
927 smb_panic("init_globals: ENOMEM");
929 Globals.spn_update_command = str_list_make_v3_const(NULL, s, NULL);
932 Globals.nsupdate_command = str_list_make_v3_const(NULL, "/usr/bin/nsupdate -g", NULL);
934 Globals.rndc_command = str_list_make_v3_const(NULL, "/usr/sbin/rndc", NULL);
936 Globals.cldap_port = 389;
938 Globals.dgram_port = NBT_DGRAM_SERVICE_PORT;
940 Globals.nbt_port = NBT_NAME_SERVICE_PORT;
942 Globals.krb5_port = 88;
944 Globals.kpasswd_port = 464;
946 Globals.web_port = 901;
948 Globals.aio_max_threads = 100;
950 lpcfg_string_set(Globals.ctx,
951 &Globals.rpc_server_dynamic_port_range,
953 Globals.rpc_low_port = SERVER_TCP_LOW_PORT;
954 Globals.rpc_high_port = SERVER_TCP_HIGH_PORT;
955 Globals.prefork_children = 1;
957 /* Now put back the settings that were set with lp_set_cmdline() */
958 apply_lp_set_cmdline();
961 /* Convenience routine to setup an lp_context with additional s3 variables */
962 static struct loadparm_context *setup_lp_context(TALLOC_CTX *mem_ctx)
964 struct loadparm_context *lp_ctx;
966 lp_ctx = loadparm_init_s3(mem_ctx,
967 loadparm_s3_helpers());
968 if (lp_ctx == NULL) {
969 DEBUG(0, ("loadparm_init_s3 failed\n"));
973 lp_ctx->sDefault = talloc_zero(lp_ctx, struct loadparm_service);
974 if (lp_ctx->sDefault == NULL) {
975 DBG_ERR("talloc_zero failed\n");
980 *lp_ctx->sDefault = _sDefault;
981 lp_ctx->services = NULL; /* We do not want to access this directly */
982 lp_ctx->bInGlobalSection = bInGlobalSection;
983 lp_ctx->flags = flags_list;
988 /*******************************************************************
989 Convenience routine to grab string parameters into talloced memory
990 and run standard_sub_basic on them. The buffers can be written to by
991 callers without affecting the source string.
992 ********************************************************************/
994 char *lp_string(TALLOC_CTX *ctx, const char *s)
998 /* The follow debug is useful for tracking down memory problems
999 especially if you have an inner loop that is calling a lp_*()
1000 function that returns a string. Perhaps this debug should be
1001 present all the time? */
1004 DEBUG(10, ("lp_string(%s)\n", s));
1010 ret = talloc_sub_basic(ctx,
1011 get_current_username(),
1012 current_user_info.domain,
1014 if (trim_char(ret, '\"', '\"')) {
1015 if (strchr(ret,'\"') != NULL) {
1017 ret = talloc_sub_basic(ctx,
1018 get_current_username(),
1019 current_user_info.domain,
1027 In this section all the functions that are used to access the
1028 parameters from the rest of the program are defined
1031 #define FN_GLOBAL_STRING(fn_name,ptr) \
1032 char *lp_ ## fn_name(TALLOC_CTX *ctx) {return(lp_string((ctx), *(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : ""));}
1033 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1034 const char *lp_ ## fn_name(void) {return(*(const char * const *)(&Globals.ptr) ? *(const char * const *)(&Globals.ptr) : "");}
1035 #define FN_GLOBAL_LIST(fn_name,ptr) \
1036 const char **lp_ ## fn_name(void) {return(*(const char ***)(&Globals.ptr));}
1037 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1038 bool lp_ ## fn_name(void) {return(*(bool *)(&Globals.ptr));}
1039 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1040 char lp_ ## fn_name(void) {return(*(char *)(&Globals.ptr));}
1041 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1042 int lp_ ## fn_name(void) {return(*(int *)(&Globals.ptr));}
1044 #define FN_LOCAL_STRING(fn_name,val) \
1045 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));}
1046 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1047 const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1048 #define FN_LOCAL_LIST(fn_name,val) \
1049 const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1050 #define FN_LOCAL_BOOL(fn_name,val) \
1051 bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1052 #define FN_LOCAL_INTEGER(fn_name,val) \
1053 int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1055 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1056 bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1057 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1058 int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1059 #define FN_LOCAL_PARM_CHAR(fn_name,val) \
1060 char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1062 int lp_winbind_max_domain_connections(void)
1064 if (lp_winbind_offline_logon() &&
1065 lp__winbind_max_domain_connections() > 1) {
1066 DEBUG(1, ("offline logons active, restricting max domain "
1067 "connections to 1\n"));
1070 return MAX(1, lp__winbind_max_domain_connections());
1073 /* These functions remain in source3/param for now */
1075 #include "lib/param/param_functions.c"
1077 FN_LOCAL_STRING(servicename, szService)
1078 FN_LOCAL_CONST_STRING(const_servicename, szService)
1080 /* These functions cannot be auto-generated */
1081 FN_LOCAL_BOOL(autoloaded, autoloaded)
1082 FN_GLOBAL_CONST_STRING(dnsdomain, dnsdomain)
1084 /* local prototypes */
1086 static int map_parameter_canonical(const char *pszParmName, bool *inverse);
1087 static const char *get_boolean(bool bool_value);
1088 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
1090 static bool hash_a_service(const char *name, int number);
1091 static void free_service_byindex(int iService);
1092 static void show_parameter(int parmIndex);
1093 static bool is_synonym_of(int parm1, int parm2, bool *inverse);
1094 static bool lp_parameter_value_is_valid(const char *parm_name, const char *val);
1097 * This is a helper function for parametrical options support. It returns a
1098 * pointer to parametrical option value if it exists or NULL otherwise. Actual
1099 * parametrical functions are quite simple
1101 static struct parmlist_entry *get_parametrics(int snum, const char *type,
1104 if (snum >= iNumServices) return NULL;
1107 return get_parametric_helper(NULL, type, option, Globals.param_opt);
1109 return get_parametric_helper(ServicePtrs[snum],
1110 type, option, Globals.param_opt);
1114 static void discard_whitespace(char *str)
1116 size_t len = strlen(str);
1120 if (isspace(str[i])) {
1121 memmove(&str[i], &str[i+1], len-i);
1130 * @brief Go through all global parametric parameters
1132 * @param regex_str A regular expression to scan param for
1133 * @param max_matches Max number of submatches the regexp expects
1134 * @param cb Function to call on match. Should return true
1135 * when it wants wi_scan_global_parametrics to stop
1137 * @param private_data Anonymous pointer passed to cb
1139 * @return 0: success, regcomp/regexec return value on error.
1140 * See "man regexec" for possible errors
1143 int lp_wi_scan_global_parametrics(
1144 const char *regex_str, size_t max_matches,
1145 bool (*cb)(const char *string, regmatch_t matches[],
1146 void *private_data),
1149 struct parmlist_entry *data;
1153 ret = regcomp(®ex, regex_str, REG_ICASE);
1158 for (data = Globals.param_opt; data != NULL; data = data->next) {
1159 size_t keylen = strlen(data->key);
1161 regmatch_t matches[max_matches];
1164 memcpy(key, data->key, sizeof(key));
1165 discard_whitespace(key);
1167 ret = regexec(®ex, key, max_matches, matches, 0);
1168 if (ret == REG_NOMATCH) {
1175 stop = cb(key, matches, private_data);
1188 #define MISSING_PARAMETER(name) \
1189 DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
1191 /*******************************************************************
1192 convenience routine to return enum parameters.
1193 ********************************************************************/
1194 static int lp_enum(const char *s,const struct enum_list *_enum)
1198 if (!s || !*s || !_enum) {
1199 MISSING_PARAMETER(lp_enum);
1203 for (i=0; _enum[i].name; i++) {
1204 if (strequal(_enum[i].name,s))
1205 return _enum[i].value;
1208 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
1212 #undef MISSING_PARAMETER
1214 /* Return parametric option from a given service. Type is a part of option before ':' */
1215 /* Parametric option has following syntax: 'Type: option = value' */
1216 char *lp_parm_talloc_string(TALLOC_CTX *ctx, int snum, const char *type, const char *option, const char *def)
1218 struct parmlist_entry *data = get_parametrics(snum, type, option);
1220 if (data == NULL||data->value==NULL) {
1222 return lp_string(ctx, def);
1228 return lp_string(ctx, data->value);
1231 /* Return parametric option from a given service. Type is a part of option before ':' */
1232 /* Parametric option has following syntax: 'Type: option = value' */
1233 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
1235 struct parmlist_entry *data = get_parametrics(snum, type, option);
1237 if (data == NULL||data->value==NULL)
1244 /* Return parametric option from a given service. Type is a part of option before ':' */
1245 /* Parametric option has following syntax: 'Type: option = value' */
1247 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
1249 struct parmlist_entry *data = get_parametrics(snum, type, option);
1251 if (data == NULL||data->value==NULL)
1252 return (const char **)def;
1254 if (data->list==NULL) {
1255 data->list = str_list_make_v3(NULL, data->value, NULL);
1258 return discard_const_p(const char *, data->list);
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 int lp_parm_int(int snum, const char *type, const char *option, int def)
1266 struct parmlist_entry *data = get_parametrics(snum, type, option);
1268 if (data && data->value && *data->value)
1269 return lp_int(data->value);
1274 /* Return parametric option from a given service. Type is a part of option before ':' */
1275 /* Parametric option has following syntax: 'Type: option = value' */
1277 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
1279 struct parmlist_entry *data = get_parametrics(snum, type, option);
1281 if (data && data->value && *data->value)
1282 return lp_ulong(data->value);
1287 /* Return parametric option from a given service. Type is a part of option before ':' */
1288 /* Parametric option has following syntax: 'Type: option = value' */
1290 unsigned long long lp_parm_ulonglong(int snum, const char *type,
1291 const char *option, unsigned long long def)
1293 struct parmlist_entry *data = get_parametrics(snum, type, option);
1295 if (data && data->value && *data->value) {
1296 return lp_ulonglong(data->value);
1302 /* Return parametric option from a given service. Type is a part of option
1304 /* Parametric option has following syntax: 'Type: option = value' */
1306 bool lp_parm_bool(int snum, const char *type, const char *option, bool def)
1308 struct parmlist_entry *data = get_parametrics(snum, type, option);
1310 if (data && data->value && *data->value)
1311 return lp_bool(data->value);
1316 /* Return parametric option from a given service. Type is a part of option before ':' */
1317 /* Parametric option has following syntax: 'Type: option = value' */
1319 int lp_parm_enum(int snum, const char *type, const char *option,
1320 const struct enum_list *_enum, int def)
1322 struct parmlist_entry *data = get_parametrics(snum, type, option);
1324 if (data && data->value && *data->value && _enum)
1325 return lp_enum(data->value, _enum);
1331 * free a param_opts structure.
1332 * param_opts handling should be moved to talloc;
1333 * then this whole functions reduces to a TALLOC_FREE().
1336 static void free_param_opts(struct parmlist_entry **popts)
1338 struct parmlist_entry *opt, *next_opt;
1340 if (*popts != NULL) {
1341 DEBUG(5, ("Freeing parametrics:\n"));
1344 while (opt != NULL) {
1345 lpcfg_string_free(&opt->key);
1346 lpcfg_string_free(&opt->value);
1347 TALLOC_FREE(opt->list);
1348 next_opt = opt->next;
1355 /***************************************************************************
1356 Free the dynamically allocated parts of a service struct.
1357 ***************************************************************************/
1359 static void free_service(struct loadparm_service *pservice)
1364 if (pservice->szService)
1365 DEBUG(5, ("free_service: Freeing service %s\n",
1366 pservice->szService));
1368 free_parameters(pservice);
1370 lpcfg_string_free(&pservice->szService);
1371 TALLOC_FREE(pservice->copymap);
1373 free_param_opts(&pservice->param_opt);
1375 ZERO_STRUCTP(pservice);
1379 /***************************************************************************
1380 remove a service indexed in the ServicePtrs array from the ServiceHash
1381 and free the dynamically allocated parts
1382 ***************************************************************************/
1384 static void free_service_byindex(int idx)
1386 if ( !LP_SNUM_OK(idx) )
1389 ServicePtrs[idx]->valid = false;
1391 /* we have to cleanup the hash record */
1393 if (ServicePtrs[idx]->szService) {
1394 char *canon_name = canonicalize_servicename(
1396 ServicePtrs[idx]->szService );
1398 dbwrap_delete_bystring(ServiceHash, canon_name );
1399 TALLOC_FREE(canon_name);
1402 free_service(ServicePtrs[idx]);
1403 TALLOC_FREE(ServicePtrs[idx]);
1406 /***************************************************************************
1407 Add a new service to the services array initialising it with the given
1409 ***************************************************************************/
1411 static int add_a_service(const struct loadparm_service *pservice, const char *name)
1414 struct loadparm_service **tsp = NULL;
1416 /* it might already exist */
1418 i = getservicebyname(name, NULL);
1424 /* Re use empty slots if any before allocating new one.*/
1425 for (i=0; i < iNumServices; i++) {
1426 if (ServicePtrs[i] == NULL) {
1430 if (i == iNumServices) {
1431 /* if not, then create one */
1432 tsp = talloc_realloc(NULL, ServicePtrs,
1433 struct loadparm_service *,
1436 DEBUG(0, ("add_a_service: failed to enlarge "
1443 ServicePtrs[i] = talloc_zero(ServicePtrs, struct loadparm_service);
1444 if (!ServicePtrs[i]) {
1445 DEBUG(0,("add_a_service: out of memory!\n"));
1449 ServicePtrs[i]->valid = true;
1451 copy_service(ServicePtrs[i], pservice, NULL);
1453 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->szService,
1456 DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
1457 i, ServicePtrs[i]->szService));
1459 if (!hash_a_service(ServicePtrs[i]->szService, i)) {
1466 /***************************************************************************
1467 Convert a string to uppercase and remove whitespaces.
1468 ***************************************************************************/
1470 char *canonicalize_servicename(TALLOC_CTX *ctx, const char *src)
1475 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
1479 result = talloc_strdup(ctx, src);
1480 SMB_ASSERT(result != NULL);
1482 if (!strlower_m(result)) {
1483 TALLOC_FREE(result);
1489 /***************************************************************************
1490 Add a name/index pair for the services array to the hash table.
1491 ***************************************************************************/
1493 static bool hash_a_service(const char *name, int idx)
1497 if ( !ServiceHash ) {
1498 DEBUG(10,("hash_a_service: creating servicehash\n"));
1499 ServiceHash = db_open_rbt(NULL);
1500 if ( !ServiceHash ) {
1501 DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
1506 DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
1509 canon_name = canonicalize_servicename(talloc_tos(), name );
1511 dbwrap_store_bystring(ServiceHash, canon_name,
1512 make_tdb_data((uint8_t *)&idx, sizeof(idx)),
1515 TALLOC_FREE(canon_name);
1520 /***************************************************************************
1521 Add a new home service, with the specified home directory, defaults coming
1523 ***************************************************************************/
1525 bool lp_add_home(const char *pszHomename, int iDefaultService,
1526 const char *user, const char *pszHomedir)
1530 if (pszHomename == NULL || user == NULL || pszHomedir == NULL ||
1531 pszHomedir[0] == '\0') {
1535 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
1540 if (!(*(ServicePtrs[iDefaultService]->path))
1541 || strequal(ServicePtrs[iDefaultService]->path,
1542 lp_path(talloc_tos(), GLOBAL_SECTION_SNUM))) {
1543 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path,
1547 if (!(*(ServicePtrs[i]->comment))) {
1548 char *comment = talloc_asprintf(talloc_tos(), "Home directory of %s", user);
1549 if (comment == NULL) {
1552 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment,
1554 TALLOC_FREE(comment);
1557 /* set the browseable flag from the global default */
1559 ServicePtrs[i]->browseable = sDefault.browseable;
1560 ServicePtrs[i]->access_based_share_enum = sDefault.access_based_share_enum;
1562 ServicePtrs[i]->autoloaded = true;
1564 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
1565 user, ServicePtrs[i]->path ));
1570 /***************************************************************************
1571 Add a new service, based on an old one.
1572 ***************************************************************************/
1574 int lp_add_service(const char *pszService, int iDefaultService)
1576 if (iDefaultService < 0) {
1577 return add_a_service(&sDefault, pszService);
1580 return (add_a_service(ServicePtrs[iDefaultService], pszService));
1583 /***************************************************************************
1584 Add the IPC service.
1585 ***************************************************************************/
1587 static bool lp_add_ipc(const char *ipc_name, bool guest_ok)
1589 char *comment = NULL;
1590 int i = add_a_service(&sDefault, ipc_name);
1595 comment = talloc_asprintf(talloc_tos(), "IPC Service (%s)",
1596 Globals.server_string);
1597 if (comment == NULL) {
1601 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path, tmpdir());
1602 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1603 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->fstype, "IPC");
1604 ServicePtrs[i]->max_connections = 0;
1605 ServicePtrs[i]->available = true;
1606 ServicePtrs[i]->read_only = true;
1607 ServicePtrs[i]->guest_only = false;
1608 ServicePtrs[i]->administrative_share = true;
1609 ServicePtrs[i]->guest_ok = guest_ok;
1610 ServicePtrs[i]->printable = false;
1611 ServicePtrs[i]->browseable = sDefault.browseable;
1612 ServicePtrs[i]->autoloaded = false;
1614 DEBUG(3, ("adding IPC service\n"));
1616 TALLOC_FREE(comment);
1620 /***************************************************************************
1621 Add a new printer service, with defaults coming from service iFrom.
1622 ***************************************************************************/
1624 bool lp_add_printer(const char *pszPrintername, int iDefaultService)
1626 const char *comment = "From Printcap";
1627 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
1632 /* note that we do NOT default the availability flag to true - */
1633 /* we take it from the default service passed. This allows all */
1634 /* dynamic printers to be disabled by disabling the [printers] */
1635 /* entry (if/when the 'available' keyword is implemented!). */
1637 /* the printer name is set to the service name. */
1638 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->_printername,
1640 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1642 /* set the browseable flag from the gloabl default */
1643 ServicePtrs[i]->browseable = sDefault.browseable;
1645 /* Printers cannot be read_only. */
1646 ServicePtrs[i]->read_only = false;
1647 /* No oplocks on printer services. */
1648 ServicePtrs[i]->oplocks = false;
1649 /* Printer services must be printable. */
1650 ServicePtrs[i]->printable = true;
1652 DEBUG(3, ("adding printer service %s\n", pszPrintername));
1658 /***************************************************************************
1659 Check whether the given parameter name is valid.
1660 Parametric options (names containing a colon) are considered valid.
1661 ***************************************************************************/
1663 bool lp_parameter_is_valid(const char *pszParmName)
1665 return ((lpcfg_map_parameter(pszParmName) != -1) ||
1666 (strchr(pszParmName, ':') != NULL));
1669 /***************************************************************************
1670 Check whether the given name is the name of a global parameter.
1671 Returns true for strings belonging to parameters of class
1672 P_GLOBAL, false for all other strings, also for parametric options
1673 and strings not belonging to any option.
1674 ***************************************************************************/
1676 bool lp_parameter_is_global(const char *pszParmName)
1678 int num = lpcfg_map_parameter(pszParmName);
1681 return (parm_table[num].p_class == P_GLOBAL);
1687 /**************************************************************************
1688 Determine the canonical name for a parameter.
1689 Indicate when it is an inverse (boolean) synonym instead of a
1691 **************************************************************************/
1693 bool lp_canonicalize_parameter(const char *parm_name, const char **canon_parm,
1698 if (!lp_parameter_is_valid(parm_name)) {
1703 num = map_parameter_canonical(parm_name, inverse);
1705 /* parametric option */
1706 *canon_parm = parm_name;
1708 *canon_parm = parm_table[num].label;
1715 /**************************************************************************
1716 Determine the canonical name for a parameter.
1717 Turn the value given into the inverse boolean expression when
1718 the synonym is an invers boolean synonym.
1721 - parm_name is a valid parameter name and
1722 - val is a valid value for this parameter and
1723 - in case the parameter is an inverse boolean synonym, if the val
1724 string could successfully be converted to the reverse bool.
1725 Return false in all other cases.
1726 **************************************************************************/
1728 bool lp_canonicalize_parameter_with_value(const char *parm_name,
1730 const char **canon_parm,
1731 const char **canon_val)
1737 if (!lp_parameter_is_valid(parm_name)) {
1743 num = map_parameter_canonical(parm_name, &inverse);
1745 /* parametric option */
1746 *canon_parm = parm_name;
1751 *canon_parm = parm_table[num].label;
1753 if (!lp_invert_boolean(val, canon_val)) {
1761 ret = lp_parameter_value_is_valid(*canon_parm, *canon_val);
1766 /***************************************************************************
1767 Map a parameter's string representation to the index of the canonical
1768 form of the parameter (it might be a synonym).
1769 Returns -1 if the parameter string is not recognised.
1770 ***************************************************************************/
1772 static int map_parameter_canonical(const char *pszParmName, bool *inverse)
1774 int parm_num, canon_num;
1775 bool loc_inverse = false;
1777 parm_num = lpcfg_map_parameter(pszParmName);
1778 if ((parm_num < 0) || !(parm_table[parm_num].flags & FLAG_SYNONYM)) {
1779 /* invalid, parametric or no canidate for synonyms ... */
1783 for (canon_num = 0; parm_table[canon_num].label; canon_num++) {
1784 if (is_synonym_of(parm_num, canon_num, &loc_inverse)) {
1785 parm_num = canon_num;
1791 if (inverse != NULL) {
1792 *inverse = loc_inverse;
1797 /***************************************************************************
1798 return true if parameter number parm1 is a synonym of parameter
1799 number parm2 (parm2 being the principal name).
1800 set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
1802 ***************************************************************************/
1804 static bool is_synonym_of(int parm1, int parm2, bool *inverse)
1806 if ((parm_table[parm1].offset == parm_table[parm2].offset) &&
1807 (parm_table[parm1].p_class == parm_table[parm2].p_class) &&
1808 (parm_table[parm1].flags & FLAG_SYNONYM) &&
1809 !(parm_table[parm2].flags & FLAG_SYNONYM))
1811 if (inverse != NULL) {
1812 if ((parm_table[parm1].type == P_BOOLREV) &&
1813 (parm_table[parm2].type == P_BOOL))
1825 /***************************************************************************
1826 Show one parameter's name, type, [values,] and flags.
1827 (helper functions for show_parameter_list)
1828 ***************************************************************************/
1830 static void show_parameter(int parmIndex)
1832 int enumIndex, flagIndex;
1837 const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
1838 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
1839 "P_ENUM", "P_BYTES", "P_CMDLIST" };
1840 unsigned flags[] = { FLAG_DEPRECATED, FLAG_SYNONYM };
1841 const char *flag_names[] = { "FLAG_DEPRECATED", "FLAG_SYNONYM", NULL};
1843 printf("%s=%s", parm_table[parmIndex].label,
1844 type[parm_table[parmIndex].type]);
1845 if (parm_table[parmIndex].type == P_ENUM) {
1848 parm_table[parmIndex].enum_list[enumIndex].name;
1852 enumIndex ? "|" : "",
1853 parm_table[parmIndex].enum_list[enumIndex].name);
1858 for (flagIndex=0; flag_names[flagIndex]; flagIndex++) {
1859 if (parm_table[parmIndex].flags & flags[flagIndex]) {
1862 flag_names[flagIndex]);
1867 /* output synonyms */
1869 for (parmIndex2=0; parm_table[parmIndex2].label; parmIndex2++) {
1870 if (is_synonym_of(parmIndex, parmIndex2, &inverse)) {
1871 printf(" (%ssynonym of %s)", inverse ? "inverse " : "",
1872 parm_table[parmIndex2].label);
1873 } else if (is_synonym_of(parmIndex2, parmIndex, &inverse)) {
1875 printf(" (synonyms: ");
1880 printf("%s%s", parm_table[parmIndex2].label,
1881 inverse ? "[i]" : "");
1892 * Check the value for a P_ENUM
1894 static bool check_enum_parameter(struct parm_struct *parm, const char *value)
1898 for (i = 0; parm->enum_list[i].name; i++) {
1899 if (strwicmp(value, parm->enum_list[i].name) == 0) {
1906 /**************************************************************************
1907 Check whether the given value is valid for the given parameter name.
1908 **************************************************************************/
1910 static bool lp_parameter_value_is_valid(const char *parm_name, const char *val)
1912 bool ret = false, tmp_bool;
1913 int num = lpcfg_map_parameter(parm_name), tmp_int;
1914 uint64_t tmp_int64 = 0;
1915 struct parm_struct *parm;
1917 /* parametric options (parameter names containing a colon) cannot
1918 be checked and are therefore considered valid. */
1919 if (strchr(parm_name, ':') != NULL) {
1924 parm = &parm_table[num];
1925 switch (parm->type) {
1928 ret = set_boolean(val, &tmp_bool);
1932 ret = (sscanf(val, "%d", &tmp_int) == 1);
1936 ret = (sscanf(val, "%o", &tmp_int) == 1);
1940 ret = check_enum_parameter(parm, val);
1944 if (conv_str_size_error(val, &tmp_int64) &&
1945 tmp_int64 <= INT_MAX) {
1962 /***************************************************************************
1963 Show all parameter's name, type, [values,] and flags.
1964 ***************************************************************************/
1966 void show_parameter_list(void)
1968 int classIndex, parmIndex;
1969 const char *section_names[] = { "local", "global", NULL};
1971 for (classIndex=0; section_names[classIndex]; classIndex++) {
1972 printf("[%s]\n", section_names[classIndex]);
1973 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
1974 if (parm_table[parmIndex].p_class == classIndex) {
1975 show_parameter(parmIndex);
1981 /***************************************************************************
1982 Get the standard string representation of a boolean value ("yes" or "no")
1983 ***************************************************************************/
1985 static const char *get_boolean(bool bool_value)
1987 static const char *yes_str = "yes";
1988 static const char *no_str = "no";
1990 return (bool_value ? yes_str : no_str);
1993 /***************************************************************************
1994 Provide the string of the negated boolean value associated to the boolean
1995 given as a string. Returns false if the passed string does not correctly
1996 represent a boolean.
1997 ***************************************************************************/
1999 bool lp_invert_boolean(const char *str, const char **inverse_str)
2003 if (!set_boolean(str, &val)) {
2007 *inverse_str = get_boolean(!val);
2011 /***************************************************************************
2012 Provide the canonical string representation of a boolean value given
2013 as a string. Return true on success, false if the string given does
2014 not correctly represent a boolean.
2015 ***************************************************************************/
2017 bool lp_canonicalize_boolean(const char *str, const char**canon_str)
2021 if (!set_boolean(str, &val)) {
2025 *canon_str = get_boolean(val);
2029 /***************************************************************************
2030 Find a service by name. Otherwise works like get_service.
2031 ***************************************************************************/
2033 int getservicebyname(const char *pszServiceName, struct loadparm_service *pserviceDest)
2040 if (ServiceHash == NULL) {
2044 canon_name = canonicalize_servicename(talloc_tos(), pszServiceName);
2046 status = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name,
2049 if (NT_STATUS_IS_OK(status) &&
2050 (data.dptr != NULL) &&
2051 (data.dsize == sizeof(iService)))
2053 memcpy(&iService, data.dptr, sizeof(iService));
2056 TALLOC_FREE(canon_name);
2058 if ((iService != -1) && (LP_SNUM_OK(iService))
2059 && (pserviceDest != NULL)) {
2060 copy_service(pserviceDest, ServicePtrs[iService], NULL);
2066 /* Return a pointer to a service by name. Unlike getservicebyname, it does not copy the service */
2067 struct loadparm_service *lp_service(const char *pszServiceName)
2069 int iService = getservicebyname(pszServiceName, NULL);
2070 if (iService == -1 || !LP_SNUM_OK(iService)) {
2073 return ServicePtrs[iService];
2076 struct loadparm_service *lp_servicebynum(int snum)
2078 if ((snum == -1) || !LP_SNUM_OK(snum)) {
2081 return ServicePtrs[snum];
2084 struct loadparm_service *lp_default_loadparm_service()
2089 static struct smbconf_ctx *lp_smbconf_ctx(void)
2092 static struct smbconf_ctx *conf_ctx = NULL;
2094 if (conf_ctx == NULL) {
2095 err = smbconf_init(NULL, &conf_ctx, "registry:");
2096 if (!SBC_ERROR_IS_OK(err)) {
2097 DEBUG(1, ("error initializing registry configuration: "
2098 "%s\n", sbcErrorString(err)));
2106 static bool process_smbconf_service(struct smbconf_service *service)
2111 if (service == NULL) {
2115 ret = lp_do_section(service->name, NULL);
2119 for (count = 0; count < service->num_params; count++) {
2121 if (!bInGlobalSection && bGlobalOnly) {
2124 const char *pszParmName = service->param_names[count];
2125 const char *pszParmValue = service->param_values[count];
2127 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2129 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2130 pszParmName, pszParmValue);
2137 if (iServiceIndex >= 0) {
2138 return lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2144 * load a service from registry and activate it
2146 bool process_registry_service(const char *service_name)
2149 struct smbconf_service *service = NULL;
2150 TALLOC_CTX *mem_ctx = talloc_stackframe();
2151 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2154 if (conf_ctx == NULL) {
2158 DEBUG(5, ("process_registry_service: service name %s\n", service_name));
2160 if (!smbconf_share_exists(conf_ctx, service_name)) {
2162 * Registry does not contain data for this service (yet),
2163 * but make sure lp_load doesn't return false.
2169 err = smbconf_get_share(conf_ctx, mem_ctx, service_name, &service);
2170 if (!SBC_ERROR_IS_OK(err)) {
2174 ret = process_smbconf_service(service);
2180 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2183 TALLOC_FREE(mem_ctx);
2188 * process_registry_globals
2190 static bool process_registry_globals(void)
2194 add_to_file_list(NULL, &file_lists, INCLUDE_REGISTRY_NAME, INCLUDE_REGISTRY_NAME);
2196 if (!bInGlobalSection && bGlobalOnly) {
2199 const char *pszParmName = "registry shares";
2200 const char *pszParmValue = "yes";
2202 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2204 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2205 pszParmName, pszParmValue);
2212 return process_registry_service(GLOBAL_NAME);
2215 bool process_registry_shares(void)
2219 struct smbconf_service **service = NULL;
2220 uint32_t num_shares = 0;
2221 TALLOC_CTX *mem_ctx = talloc_stackframe();
2222 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2225 if (conf_ctx == NULL) {
2229 err = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &service);
2230 if (!SBC_ERROR_IS_OK(err)) {
2236 for (count = 0; count < num_shares; count++) {
2237 if (strequal(service[count]->name, GLOBAL_NAME)) {
2240 ret = process_smbconf_service(service[count]);
2247 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2250 TALLOC_FREE(mem_ctx);
2255 * reload those shares from registry that are already
2256 * activated in the services array.
2258 static bool reload_registry_shares(void)
2263 for (i = 0; i < iNumServices; i++) {
2268 if (ServicePtrs[i]->usershare == USERSHARE_VALID) {
2272 ret = process_registry_service(ServicePtrs[i]->szService);
2283 #define MAX_INCLUDE_DEPTH 100
2285 static uint8_t include_depth;
2288 * Free the file lists
2290 static void free_file_list(void)
2292 struct file_lists *f;
2293 struct file_lists *next;
2306 * Utility function for outsiders to check if we're running on registry.
2308 bool lp_config_backend_is_registry(void)
2310 return (lp_config_backend() == CONFIG_BACKEND_REGISTRY);
2314 * Utility function to check if the config backend is FILE.
2316 bool lp_config_backend_is_file(void)
2318 return (lp_config_backend() == CONFIG_BACKEND_FILE);
2321 /*******************************************************************
2322 Check if a config file has changed date.
2323 ********************************************************************/
2325 bool lp_file_list_changed(void)
2327 struct file_lists *f = file_lists;
2329 DEBUG(6, ("lp_file_list_changed()\n"));
2332 if (strequal(f->name, INCLUDE_REGISTRY_NAME)) {
2333 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2335 if (conf_ctx == NULL) {
2338 if (smbconf_changed(conf_ctx, &conf_last_csn, NULL,
2341 DEBUGADD(6, ("registry config changed\n"));
2348 n2 = talloc_sub_basic(talloc_tos(),
2349 get_current_username(),
2350 current_user_info.domain,
2355 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
2356 f->name, n2, ctime(&f->modtime)));
2358 mod_time = file_modtime(n2);
2361 ((f->modtime != mod_time) ||
2362 (f->subfname == NULL) ||
2363 (strcmp(n2, f->subfname) != 0)))
2366 ("file %s modified: %s\n", n2,
2368 f->modtime = mod_time;
2369 TALLOC_FREE(f->subfname);
2370 f->subfname = talloc_strdup(f, n2);
2371 if (f->subfname == NULL) {
2372 smb_panic("talloc_strdup failed");
2386 * Initialize iconv conversion descriptors.
2388 * This is called the first time it is needed, and also called again
2389 * every time the configuration is reloaded, because the charset or
2390 * codepage might have changed.
2392 static void init_iconv(void)
2394 struct smb_iconv_handle *ret = NULL;
2396 ret = reinit_iconv_handle(NULL,
2400 smb_panic("reinit_iconv_handle failed");
2404 /***************************************************************************
2405 Handle the include operation.
2406 ***************************************************************************/
2407 static bool bAllowIncludeRegistry = true;
2409 bool lp_include(struct loadparm_context *lp_ctx, struct loadparm_service *service,
2410 const char *pszParmValue, char **ptr)
2414 if (include_depth >= MAX_INCLUDE_DEPTH) {
2415 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
2420 if (strequal(pszParmValue, INCLUDE_REGISTRY_NAME)) {
2421 if (!bAllowIncludeRegistry) {
2424 if (lp_ctx->bInGlobalSection) {
2427 ret = process_registry_globals();
2431 DEBUG(1, ("\"include = registry\" only effective "
2432 "in %s section\n", GLOBAL_NAME));
2437 fname = talloc_sub_basic(talloc_tos(), get_current_username(),
2438 current_user_info.domain,
2441 add_to_file_list(NULL, &file_lists, pszParmValue, fname);
2443 if (service == NULL) {
2444 lpcfg_string_set(Globals.ctx, ptr, fname);
2446 lpcfg_string_set(service, ptr, fname);
2449 if (file_exist(fname)) {
2452 ret = pm_process(fname, lp_do_section, do_parameter, lp_ctx);
2458 DEBUG(2, ("Can't find include file %s\n", fname));
2463 bool lp_idmap_range(const char *domain_name, uint32_t *low, uint32_t *high)
2465 char *config_option = NULL;
2466 const char *range = NULL;
2469 SMB_ASSERT(low != NULL);
2470 SMB_ASSERT(high != NULL);
2472 if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2476 config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2478 if (config_option == NULL) {
2479 DEBUG(0, ("out of memory\n"));
2483 range = lp_parm_const_string(-1, config_option, "range", NULL);
2484 if (range == NULL) {
2485 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name));
2489 if (sscanf(range, "%u - %u", low, high) != 2) {
2490 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2491 range, domain_name));
2498 talloc_free(config_option);
2503 bool lp_idmap_default_range(uint32_t *low, uint32_t *high)
2505 return lp_idmap_range("*", low, high);
2508 const char *lp_idmap_backend(const char *domain_name)
2510 char *config_option = NULL;
2511 const char *backend = NULL;
2513 if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2517 config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2519 if (config_option == NULL) {
2520 DEBUG(0, ("out of memory\n"));
2524 backend = lp_parm_const_string(-1, config_option, "backend", NULL);
2525 if (backend == NULL) {
2526 DEBUG(1, ("idmap backend not specified for domain '%s'\n", domain_name));
2531 talloc_free(config_option);
2535 const char *lp_idmap_default_backend(void)
2537 return lp_idmap_backend("*");
2540 /***************************************************************************
2541 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2542 ***************************************************************************/
2544 static const char *append_ldap_suffix(TALLOC_CTX *ctx, const char *str )
2546 const char *suffix_string;
2548 suffix_string = talloc_asprintf(ctx, "%s,%s", str,
2549 Globals.ldap_suffix );
2550 if ( !suffix_string ) {
2551 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2555 return suffix_string;
2558 const char *lp_ldap_machine_suffix(TALLOC_CTX *ctx)
2560 if (Globals._ldap_machine_suffix[0])
2561 return append_ldap_suffix(ctx, Globals._ldap_machine_suffix);
2563 return lp_string(ctx, Globals.ldap_suffix);
2566 const char *lp_ldap_user_suffix(TALLOC_CTX *ctx)
2568 if (Globals._ldap_user_suffix[0])
2569 return append_ldap_suffix(ctx, Globals._ldap_user_suffix);
2571 return lp_string(ctx, Globals.ldap_suffix);
2574 const char *lp_ldap_group_suffix(TALLOC_CTX *ctx)
2576 if (Globals._ldap_group_suffix[0])
2577 return append_ldap_suffix(ctx, Globals._ldap_group_suffix);
2579 return lp_string(ctx, Globals.ldap_suffix);
2582 const char *lp_ldap_idmap_suffix(TALLOC_CTX *ctx)
2584 if (Globals._ldap_idmap_suffix[0])
2585 return append_ldap_suffix(ctx, Globals._ldap_idmap_suffix);
2587 return lp_string(ctx, Globals.ldap_suffix);
2591 return the parameter pointer for a parameter
2593 void *lp_parm_ptr(struct loadparm_service *service, struct parm_struct *parm)
2595 if (service == NULL) {
2596 if (parm->p_class == P_LOCAL)
2597 return (void *)(((char *)&sDefault)+parm->offset);
2598 else if (parm->p_class == P_GLOBAL)
2599 return (void *)(((char *)&Globals)+parm->offset);
2602 return (void *)(((char *)service) + parm->offset);
2606 /***************************************************************************
2607 Process a parameter for a particular service number. If snum < 0
2608 then assume we are in the globals.
2609 ***************************************************************************/
2611 bool lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
2613 TALLOC_CTX *frame = talloc_stackframe();
2614 struct loadparm_context *lp_ctx;
2617 lp_ctx = setup_lp_context(frame);
2618 if (lp_ctx == NULL) {
2624 ok = lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue);
2626 ok = lpcfg_do_service_parameter(lp_ctx, ServicePtrs[snum],
2627 pszParmName, pszParmValue);
2635 /***************************************************************************
2636 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
2637 FLAG_CMDLINE won't be overridden by loads from smb.conf.
2638 ***************************************************************************/
2640 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue)
2643 parmnum = lpcfg_map_parameter(pszParmName);
2645 flags_list[parmnum] &= ~FLAG_CMDLINE;
2646 if (!lp_do_parameter(-1, pszParmName, pszParmValue)) {
2649 flags_list[parmnum] |= FLAG_CMDLINE;
2651 /* we have to also set FLAG_CMDLINE on aliases. Aliases must
2652 * be grouped in the table, so we don't have to search the
2655 i>=0 && parm_table[i].offset == parm_table[parmnum].offset
2656 && parm_table[i].p_class == parm_table[parmnum].p_class;
2658 flags_list[i] |= FLAG_CMDLINE;
2660 for (i=parmnum+1;i<num_parameters() && parm_table[i].offset == parm_table[parmnum].offset
2661 && parm_table[i].p_class == parm_table[parmnum].p_class;i++) {
2662 flags_list[i] |= FLAG_CMDLINE;
2668 /* it might be parametric */
2669 if (strchr(pszParmName, ':') != NULL) {
2670 set_param_opt(NULL, &Globals.param_opt, pszParmName, pszParmValue, FLAG_CMDLINE);
2674 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
2678 bool lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
2681 TALLOC_CTX *frame = talloc_stackframe();
2682 struct loadparm_context *lp_ctx;
2684 lp_ctx = setup_lp_context(frame);
2685 if (lp_ctx == NULL) {
2690 ret = lpcfg_set_cmdline(lp_ctx, pszParmName, pszParmValue);
2696 /***************************************************************************
2697 Process a parameter.
2698 ***************************************************************************/
2700 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
2703 if (!bInGlobalSection && bGlobalOnly)
2706 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2708 if (bInGlobalSection) {
2709 return lpcfg_do_global_parameter(userdata, pszParmName, pszParmValue);
2711 return lpcfg_do_service_parameter(userdata, ServicePtrs[iServiceIndex],
2712 pszParmName, pszParmValue);
2716 /***************************************************************************
2717 Initialize any local variables in the sDefault table, after parsing a
2719 ***************************************************************************/
2721 static void init_locals(void)
2724 * We run this check once the [globals] is parsed, to force
2725 * the VFS objects and other per-share settings we need for
2726 * the standard way a AD DC is operated. We may change these
2727 * as our code evolves, which is why we force these settings.
2729 * We can't do this at the end of lp_load_ex(), as by that
2730 * point the services have been loaded and they will already
2731 * have "" as their vfs objects.
2733 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
2734 const char **vfs_objects = lp_vfs_objects(-1);
2735 if (!vfs_objects || !vfs_objects[0]) {
2736 if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL)) {
2737 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
2738 } else if (lp_parm_const_string(-1, "posix", "eadb", NULL)) {
2739 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
2741 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
2745 lp_do_parameter(-1, "map hidden", "no");
2746 lp_do_parameter(-1, "map system", "no");
2747 lp_do_parameter(-1, "map readonly", "no");
2748 lp_do_parameter(-1, "map archive", "no");
2749 lp_do_parameter(-1, "store dos attributes", "yes");
2753 /***************************************************************************
2754 Process a new section (service). At this stage all sections are services.
2755 Later we'll have special sections that permit server parameters to be set.
2756 Returns true on success, false on failure.
2757 ***************************************************************************/
2759 bool lp_do_section(const char *pszSectionName, void *userdata)
2761 struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
2763 bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
2764 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
2767 /* if we were in a global section then do the local inits */
2768 if (bInGlobalSection && !isglobal)
2771 /* if we've just struck a global section, note the fact. */
2772 bInGlobalSection = isglobal;
2773 if (lp_ctx != NULL) {
2774 lp_ctx->bInGlobalSection = isglobal;
2777 /* check for multiple global sections */
2778 if (bInGlobalSection) {
2779 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
2783 if (!bInGlobalSection && bGlobalOnly)
2786 /* if we have a current service, tidy it up before moving on */
2789 if (iServiceIndex >= 0)
2790 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2792 /* if all is still well, move to the next record in the services array */
2794 /* We put this here to avoid an odd message order if messages are */
2795 /* issued by the post-processing of a previous section. */
2796 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
2798 iServiceIndex = add_a_service(&sDefault, pszSectionName);
2799 if (iServiceIndex < 0) {
2800 DEBUG(0, ("Failed to add a new service\n"));
2803 /* Clean all parametric options for service */
2804 /* They will be added during parsing again */
2805 free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
2811 /***************************************************************************
2812 Display the contents of a parameter of a single services record.
2813 ***************************************************************************/
2815 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
2817 bool result = false;
2818 struct loadparm_context *lp_ctx;
2820 lp_ctx = setup_lp_context(talloc_tos());
2821 if (lp_ctx == NULL) {
2826 result = lpcfg_dump_a_parameter(lp_ctx, NULL, parm_name, f);
2828 result = lpcfg_dump_a_parameter(lp_ctx, ServicePtrs[snum], parm_name, f);
2830 TALLOC_FREE(lp_ctx);
2835 /***************************************************************************
2836 Display the contents of a single copy structure.
2837 ***************************************************************************/
2838 static void dump_copy_map(bool *pcopymap)
2844 printf("\n\tNon-Copied parameters:\n");
2846 for (i = 0; parm_table[i].label; i++)
2847 if (parm_table[i].p_class == P_LOCAL &&
2848 parm_table[i].ptr && !pcopymap[i] &&
2849 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
2851 printf("\t\t%s\n", parm_table[i].label);
2856 /***************************************************************************
2857 Return TRUE if the passed service number is within range.
2858 ***************************************************************************/
2860 bool lp_snum_ok(int iService)
2862 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->available);
2865 /***************************************************************************
2866 Auto-load some home services.
2867 ***************************************************************************/
2869 static void lp_add_auto_services(char *str)
2879 s = talloc_strdup(talloc_tos(), str);
2881 smb_panic("talloc_strdup failed");
2885 homes = lp_servicenumber(HOMES_NAME);
2887 for (p = strtok_r(s, LIST_SEP, &saveptr); p;
2888 p = strtok_r(NULL, LIST_SEP, &saveptr)) {
2891 if (lp_servicenumber(p) >= 0)
2894 home = get_user_home_dir(talloc_tos(), p);
2896 if (home && home[0] && homes >= 0)
2897 lp_add_home(p, homes, p, home);
2904 /***************************************************************************
2905 Auto-load one printer.
2906 ***************************************************************************/
2908 void lp_add_one_printer(const char *name, const char *comment,
2909 const char *location, void *pdata)
2911 int printers = lp_servicenumber(PRINTERS_NAME);
2914 if (lp_servicenumber(name) < 0) {
2915 lp_add_printer(name, printers);
2916 if ((i = lp_servicenumber(name)) >= 0) {
2917 lpcfg_string_set(ServicePtrs[i],
2918 &ServicePtrs[i]->comment, comment);
2919 ServicePtrs[i]->autoloaded = true;
2924 /***************************************************************************
2925 Have we loaded a services file yet?
2926 ***************************************************************************/
2928 bool lp_loaded(void)
2933 /***************************************************************************
2934 Unload unused services.
2935 ***************************************************************************/
2937 void lp_killunused(struct smbd_server_connection *sconn,
2938 bool (*snumused) (struct smbd_server_connection *, int))
2941 for (i = 0; i < iNumServices; i++) {
2945 /* don't kill autoloaded or usershare services */
2946 if ( ServicePtrs[i]->autoloaded ||
2947 ServicePtrs[i]->usershare == USERSHARE_VALID) {
2951 if (!snumused || !snumused(sconn, i)) {
2952 free_service_byindex(i);
2958 * Kill all except autoloaded and usershare services - convenience wrapper
2960 void lp_kill_all_services(void)
2962 lp_killunused(NULL, NULL);
2965 /***************************************************************************
2967 ***************************************************************************/
2969 void lp_killservice(int iServiceIn)
2971 if (VALID(iServiceIn)) {
2972 free_service_byindex(iServiceIn);
2976 /***************************************************************************
2977 Save the curent values of all global and sDefault parameters into the
2978 defaults union. This allows testparm to show only the
2979 changed (ie. non-default) parameters.
2980 ***************************************************************************/
2982 static void lp_save_defaults(void)
2985 struct parmlist_entry * parm;
2986 for (i = 0; parm_table[i].label; i++) {
2987 if (!(flags_list[i] & FLAG_CMDLINE)) {
2988 flags_list[i] |= FLAG_DEFAULT;
2991 if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
2992 && parm_table[i].p_class == parm_table[i - 1].p_class)
2994 switch (parm_table[i].type) {
2997 parm_table[i].def.lvalue = str_list_copy(
2998 NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
3004 &parm_table[i].def.svalue,
3005 *(char **)lp_parm_ptr(
3006 NULL, &parm_table[i]));
3007 if (parm_table[i].def.svalue == NULL) {
3008 smb_panic("lpcfg_string_set() failed");
3013 parm_table[i].def.bvalue =
3014 *(bool *)lp_parm_ptr(NULL, &parm_table[i]);
3017 parm_table[i].def.cvalue =
3018 *(char *)lp_parm_ptr(NULL, &parm_table[i]);
3024 parm_table[i].def.ivalue =
3025 *(int *)lp_parm_ptr(NULL, &parm_table[i]);
3030 for (parm=Globals.param_opt; parm; parm=parm->next) {
3031 if (!(parm->priority & FLAG_CMDLINE)) {
3032 parm->priority |= FLAG_DEFAULT;
3036 for (parm=sDefault.param_opt; parm; parm=parm->next) {
3037 if (!(parm->priority & FLAG_CMDLINE)) {
3038 parm->priority |= FLAG_DEFAULT;
3042 defaults_saved = true;
3045 /***********************************************************
3046 If we should send plaintext/LANMAN passwords in the clinet
3047 ************************************************************/
3049 static void set_allowed_client_auth(void)
3051 if (Globals.client_ntlmv2_auth) {
3052 Globals.client_lanman_auth = false;
3054 if (!Globals.client_lanman_auth) {
3055 Globals.client_plaintext_auth = false;
3059 /***************************************************************************
3061 The following code allows smbd to read a user defined share file.
3062 Yes, this is my intent. Yes, I'm comfortable with that...
3064 THE FOLLOWING IS SECURITY CRITICAL CODE.
3066 It washes your clothes, it cleans your house, it guards you while you sleep...
3067 Do not f%^k with it....
3068 ***************************************************************************/
3070 #define MAX_USERSHARE_FILE_SIZE (10*1024)
3072 /***************************************************************************
3073 Check allowed stat state of a usershare file.
3074 Ensure we print out who is dicking with us so the admin can
3075 get their sorry ass fired.
3076 ***************************************************************************/
3078 static bool check_usershare_stat(const char *fname,
3079 const SMB_STRUCT_STAT *psbuf)
3081 if (!S_ISREG(psbuf->st_ex_mode)) {
3082 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3083 "not a regular file\n",
3084 fname, (unsigned int)psbuf->st_ex_uid ));
3088 /* Ensure this doesn't have the other write bit set. */
3089 if (psbuf->st_ex_mode & S_IWOTH) {
3090 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
3091 "public write. Refusing to allow as a usershare file.\n",
3092 fname, (unsigned int)psbuf->st_ex_uid ));
3096 /* Should be 10k or less. */
3097 if (psbuf->st_ex_size > MAX_USERSHARE_FILE_SIZE) {
3098 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3099 "too large (%u) to be a user share file.\n",
3100 fname, (unsigned int)psbuf->st_ex_uid,
3101 (unsigned int)psbuf->st_ex_size ));
3108 /***************************************************************************
3109 Parse the contents of a usershare file.
3110 ***************************************************************************/
3112 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
3113 SMB_STRUCT_STAT *psbuf,
3114 const char *servicename,
3118 char **pp_sharepath,
3120 char **pp_cp_servicename,
3121 struct security_descriptor **ppsd,
3124 const char **prefixallowlist = lp_usershare_prefix_allow_list();
3125 const char **prefixdenylist = lp_usershare_prefix_deny_list();
3128 SMB_STRUCT_STAT sbuf;
3129 char *sharepath = NULL;
3130 char *comment = NULL;
3132 *pp_sharepath = NULL;
3135 *pallow_guest = false;
3138 return USERSHARE_MALFORMED_FILE;
3141 if (strcmp(lines[0], "#VERSION 1") == 0) {
3143 } else if (strcmp(lines[0], "#VERSION 2") == 0) {
3146 return USERSHARE_MALFORMED_FILE;
3149 return USERSHARE_BAD_VERSION;
3152 if (strncmp(lines[1], "path=", 5) != 0) {
3153 return USERSHARE_MALFORMED_PATH;
3156 sharepath = talloc_strdup(ctx, &lines[1][5]);
3158 return USERSHARE_POSIX_ERR;
3160 trim_string(sharepath, " ", " ");
3162 if (strncmp(lines[2], "comment=", 8) != 0) {
3163 return USERSHARE_MALFORMED_COMMENT_DEF;
3166 comment = talloc_strdup(ctx, &lines[2][8]);
3168 return USERSHARE_POSIX_ERR;
3170 trim_string(comment, " ", " ");
3171 trim_char(comment, '"', '"');
3173 if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
3174 return USERSHARE_MALFORMED_ACL_DEF;
3177 if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
3178 return USERSHARE_ACL_ERR;
3182 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
3183 return USERSHARE_MALFORMED_ACL_DEF;
3185 if (lines[4][9] == 'y') {
3186 *pallow_guest = true;
3189 /* Backwards compatible extension to file version #2. */
3191 if (strncmp(lines[5], "sharename=", 10) != 0) {
3192 return USERSHARE_MALFORMED_SHARENAME_DEF;
3194 if (!strequal(&lines[5][10], servicename)) {
3195 return USERSHARE_BAD_SHARENAME;
3197 *pp_cp_servicename = talloc_strdup(ctx, &lines[5][10]);
3198 if (!*pp_cp_servicename) {
3199 return USERSHARE_POSIX_ERR;
3204 if (*pp_cp_servicename == NULL) {
3205 *pp_cp_servicename = talloc_strdup(ctx, servicename);
3206 if (!*pp_cp_servicename) {
3207 return USERSHARE_POSIX_ERR;
3211 if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->path) == 0)) {
3212 /* Path didn't change, no checks needed. */
3213 *pp_sharepath = sharepath;
3214 *pp_comment = comment;
3215 return USERSHARE_OK;
3218 /* The path *must* be absolute. */
3219 if (sharepath[0] != '/') {
3220 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
3221 servicename, sharepath));
3222 return USERSHARE_PATH_NOT_ABSOLUTE;
3225 /* If there is a usershare prefix deny list ensure one of these paths
3226 doesn't match the start of the user given path. */
3227 if (prefixdenylist) {
3229 for ( i=0; prefixdenylist[i]; i++ ) {
3230 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
3231 servicename, i, prefixdenylist[i], sharepath ));
3232 if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
3233 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
3234 "usershare prefix deny list entries.\n",
3235 servicename, sharepath));
3236 return USERSHARE_PATH_IS_DENIED;
3241 /* If there is a usershare prefix allow list ensure one of these paths
3242 does match the start of the user given path. */
3244 if (prefixallowlist) {
3246 for ( i=0; prefixallowlist[i]; i++ ) {
3247 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
3248 servicename, i, prefixallowlist[i], sharepath ));
3249 if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
3253 if (prefixallowlist[i] == NULL) {
3254 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
3255 "usershare prefix allow list entries.\n",
3256 servicename, sharepath));
3257 return USERSHARE_PATH_NOT_ALLOWED;
3261 /* Ensure this is pointing to a directory. */
3262 dp = opendir(sharepath);
3265 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3266 servicename, sharepath));
3267 return USERSHARE_PATH_NOT_DIRECTORY;
3270 /* Ensure the owner of the usershare file has permission to share
3273 if (sys_stat(sharepath, &sbuf, false) == -1) {
3274 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
3275 servicename, sharepath, strerror(errno) ));
3277 return USERSHARE_POSIX_ERR;
3282 if (!S_ISDIR(sbuf.st_ex_mode)) {
3283 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3284 servicename, sharepath ));
3285 return USERSHARE_PATH_NOT_DIRECTORY;
3288 /* Check if sharing is restricted to owner-only. */
3289 /* psbuf is the stat of the usershare definition file,
3290 sbuf is the stat of the target directory to be shared. */
3292 if (lp_usershare_owner_only()) {
3293 /* root can share anything. */
3294 if ((psbuf->st_ex_uid != 0) && (sbuf.st_ex_uid != psbuf->st_ex_uid)) {
3295 return USERSHARE_PATH_NOT_ALLOWED;
3299 *pp_sharepath = sharepath;
3300 *pp_comment = comment;
3301 return USERSHARE_OK;
3304 /***************************************************************************
3305 Deal with a usershare file.
3308 -1 - Bad name, invalid contents.
3309 - service name already existed and not a usershare, problem
3310 with permissions to share directory etc.
3311 ***************************************************************************/
3313 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
3315 SMB_STRUCT_STAT sbuf;
3316 SMB_STRUCT_STAT lsbuf;
3318 char *sharepath = NULL;
3319 char *comment = NULL;
3320 char *cp_service_name = NULL;
3321 char **lines = NULL;
3325 TALLOC_CTX *ctx = talloc_stackframe();
3326 struct security_descriptor *psd = NULL;
3327 bool guest_ok = false;
3328 char *canon_name = NULL;
3329 bool added_service = false;
3332 /* Ensure share name doesn't contain invalid characters. */
3333 if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
3334 DEBUG(0,("process_usershare_file: share name %s contains "
3335 "invalid characters (any of %s)\n",
3336 file_name, INVALID_SHARENAME_CHARS ));
3340 canon_name = canonicalize_servicename(ctx, file_name);
3345 fname = talloc_asprintf(ctx, "%s/%s", dir_name, file_name);
3350 /* Minimize the race condition by doing an lstat before we
3351 open and fstat. Ensure this isn't a symlink link. */
3353 if (sys_lstat(fname, &lsbuf, false) != 0) {
3354 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
3355 fname, strerror(errno) ));
3359 /* This must be a regular file, not a symlink, directory or
3360 other strange filetype. */
3361 if (!check_usershare_stat(fname, &lsbuf)) {
3369 status = dbwrap_fetch_bystring(ServiceHash, canon_name,
3374 if (NT_STATUS_IS_OK(status) &&
3375 (data.dptr != NULL) &&
3376 (data.dsize == sizeof(iService))) {
3377 memcpy(&iService, data.dptr, sizeof(iService));
3381 if (iService != -1 &&
3382 timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
3383 &lsbuf.st_ex_mtime) == 0) {
3384 /* Nothing changed - Mark valid and return. */
3385 DEBUG(10,("process_usershare_file: service %s not changed.\n",
3387 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3392 /* Try and open the file read only - no symlinks allowed. */
3394 fd = open(fname, O_RDONLY|O_NOFOLLOW, 0);
3396 fd = open(fname, O_RDONLY, 0);
3400 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
3401 fname, strerror(errno) ));
3405 /* Now fstat to be *SURE* it's a regular file. */
3406 if (sys_fstat(fd, &sbuf, false) != 0) {
3408 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
3409 fname, strerror(errno) ));
3413 /* Is it the same dev/inode as was lstated ? */
3414 if (!check_same_stat(&lsbuf, &sbuf)) {
3416 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
3417 "Symlink spoofing going on ?\n", fname ));
3421 /* This must be a regular file, not a symlink, directory or
3422 other strange filetype. */
3423 if (!check_usershare_stat(fname, &sbuf)) {
3428 lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE, NULL);
3431 if (lines == NULL) {
3432 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
3433 fname, (unsigned int)sbuf.st_ex_uid ));
3437 if (parse_usershare_file(ctx, &sbuf, file_name,
3438 iService, lines, numlines, &sharepath,
3439 &comment, &cp_service_name,
3440 &psd, &guest_ok) != USERSHARE_OK) {
3444 /* Everything ok - add the service possibly using a template. */
3446 const struct loadparm_service *sp = &sDefault;
3447 if (snum_template != -1) {
3448 sp = ServicePtrs[snum_template];
3451 if ((iService = add_a_service(sp, cp_service_name)) < 0) {
3452 DEBUG(0, ("process_usershare_file: Failed to add "
3453 "new service %s\n", cp_service_name));
3457 added_service = true;
3459 /* Read only is controlled by usershare ACL below. */
3460 ServicePtrs[iService]->read_only = false;
3463 /* Write the ACL of the new/modified share. */
3464 if (!set_share_security(canon_name, psd)) {
3465 DEBUG(0, ("process_usershare_file: Failed to set share "
3466 "security for user share %s\n",
3471 /* If from a template it may be marked invalid. */
3472 ServicePtrs[iService]->valid = true;
3474 /* Set the service as a valid usershare. */
3475 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3477 /* Set guest access. */
3478 if (lp_usershare_allow_guests()) {
3479 ServicePtrs[iService]->guest_ok = guest_ok;
3482 /* And note when it was loaded. */
3483 ServicePtrs[iService]->usershare_last_mod = sbuf.st_ex_mtime;
3484 lpcfg_string_set(ServicePtrs[iService], &ServicePtrs[iService]->path,
3486 lpcfg_string_set(ServicePtrs[iService],
3487 &ServicePtrs[iService]->comment, comment);
3493 if (ret == -1 && iService != -1 && added_service) {
3494 lp_remove_service(iService);
3502 /***************************************************************************
3503 Checks if a usershare entry has been modified since last load.
3504 ***************************************************************************/
3506 static bool usershare_exists(int iService, struct timespec *last_mod)
3508 SMB_STRUCT_STAT lsbuf;
3509 const char *usersharepath = Globals.usershare_path;
3512 fname = talloc_asprintf(talloc_tos(),
3515 ServicePtrs[iService]->szService);
3516 if (fname == NULL) {
3520 if (sys_lstat(fname, &lsbuf, false) != 0) {
3525 if (!S_ISREG(lsbuf.st_ex_mode)) {
3531 *last_mod = lsbuf.st_ex_mtime;
3535 static bool usershare_directory_is_root(uid_t uid)
3541 if (uid_wrapper_enabled()) {
3548 /***************************************************************************
3549 Load a usershare service by name. Returns a valid servicenumber or -1.
3550 ***************************************************************************/
3552 int load_usershare_service(const char *servicename)
3554 SMB_STRUCT_STAT sbuf;
3555 const char *usersharepath = Globals.usershare_path;
3556 int max_user_shares = Globals.usershare_max_shares;
3557 int snum_template = -1;
3559 if (*usersharepath == 0 || max_user_shares == 0) {
3563 if (sys_stat(usersharepath, &sbuf, false) != 0) {
3564 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
3565 usersharepath, strerror(errno) ));
3569 if (!S_ISDIR(sbuf.st_ex_mode)) {
3570 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
3576 * This directory must be owned by root, and have the 't' bit set.
3577 * It also must not be writable by "other".
3581 if (!usershare_directory_is_root(sbuf.st_ex_uid) ||
3582 !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3584 if (!usershare_directory_is_root(sbuf.st_ex_uid) ||
3585 (sbuf.st_ex_mode & S_IWOTH)) {
3587 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
3588 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3593 /* Ensure the template share exists if it's set. */
3594 if (Globals.usershare_template_share[0]) {
3595 /* We can't use lp_servicenumber here as we are recommending that
3596 template shares have -valid=false set. */
3597 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3598 if (ServicePtrs[snum_template]->szService &&
3599 strequal(ServicePtrs[snum_template]->szService,
3600 Globals.usershare_template_share)) {
3605 if (snum_template == -1) {
3606 DEBUG(0,("load_usershare_service: usershare template share %s "
3607 "does not exist.\n",
3608 Globals.usershare_template_share ));
3613 return process_usershare_file(usersharepath, servicename, snum_template);
3616 /***************************************************************************
3617 Load all user defined shares from the user share directory.
3618 We only do this if we're enumerating the share list.
3619 This is the function that can delete usershares that have
3621 ***************************************************************************/
3623 int load_usershare_shares(struct smbd_server_connection *sconn,
3624 bool (*snumused) (struct smbd_server_connection *, int))
3627 SMB_STRUCT_STAT sbuf;
3629 int num_usershares = 0;
3630 int max_user_shares = Globals.usershare_max_shares;
3631 unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
3632 unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
3633 unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
3635 int snum_template = -1;
3636 const char *usersharepath = Globals.usershare_path;
3637 int ret = lp_numservices();
3638 TALLOC_CTX *tmp_ctx;
3640 if (max_user_shares == 0 || *usersharepath == '\0') {
3641 return lp_numservices();
3644 if (sys_stat(usersharepath, &sbuf, false) != 0) {
3645 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
3646 usersharepath, strerror(errno) ));
3651 * This directory must be owned by root, and have the 't' bit set.
3652 * It also must not be writable by "other".
3656 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3658 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3660 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
3661 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3666 /* Ensure the template share exists if it's set. */
3667 if (Globals.usershare_template_share[0]) {
3668 /* We can't use lp_servicenumber here as we are recommending that
3669 template shares have -valid=false set. */
3670 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3671 if (ServicePtrs[snum_template]->szService &&
3672 strequal(ServicePtrs[snum_template]->szService,
3673 Globals.usershare_template_share)) {
3678 if (snum_template == -1) {
3679 DEBUG(0,("load_usershare_shares: usershare template share %s "
3680 "does not exist.\n",
3681 Globals.usershare_template_share ));
3686 /* Mark all existing usershares as pending delete. */
3687 for (iService = iNumServices - 1; iService >= 0; iService--) {
3688 if (VALID(iService) && ServicePtrs[iService]->usershare) {
3689 ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
3693 dp = opendir(usersharepath);
3695 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
3696 usersharepath, strerror(errno) ));
3700 for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
3702 num_dir_entries++ ) {
3704 const char *n = de->d_name;
3706 /* Ignore . and .. */
3708 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
3714 /* Temporary file used when creating a share. */
3715 num_tmp_dir_entries++;
3718 /* Allow 20% tmp entries. */
3719 if (num_tmp_dir_entries > allowed_tmp_entries) {
3720 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
3721 "in directory %s\n",
3722 num_tmp_dir_entries, usersharepath));
3726 r = process_usershare_file(usersharepath, n, snum_template);
3728 /* Update the services count. */
3730 if (num_usershares >= max_user_shares) {
3731 DEBUG(0,("load_usershare_shares: max user shares reached "
3732 "on file %s in directory %s\n",
3733 n, usersharepath ));
3736 } else if (r == -1) {
3737 num_bad_dir_entries++;
3740 /* Allow 20% bad entries. */
3741 if (num_bad_dir_entries > allowed_bad_entries) {
3742 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
3743 "in directory %s\n",
3744 num_bad_dir_entries, usersharepath));
3748 /* Allow 20% bad entries. */
3749 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
3750 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
3751 "in directory %s\n",
3752 num_dir_entries, usersharepath));
3759 /* Sweep through and delete any non-refreshed usershares that are
3760 not currently in use. */
3761 tmp_ctx = talloc_stackframe();
3762 for (iService = iNumServices - 1; iService >= 0; iService--) {
3763 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
3766 if (snumused && snumused(sconn, iService)) {
3770 servname = lp_servicename(tmp_ctx, iService);
3772 /* Remove from the share ACL db. */
3773 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
3775 delete_share_security(servname);
3776 free_service_byindex(iService);
3779 talloc_free(tmp_ctx);
3781 return lp_numservices();
3784 /********************************************************
3785 Destroy global resources allocated in this file
3786 ********************************************************/
3788 void gfree_loadparm(void)
3794 /* Free resources allocated to services */
3796 for ( i = 0; i < iNumServices; i++ ) {
3798 free_service_byindex(i);
3802 TALLOC_FREE( ServicePtrs );
3805 /* Now release all resources allocated to global
3806 parameters and the default service */
3808 free_global_parameters();
3812 /***************************************************************************
3813 Allow client apps to specify that they are a client
3814 ***************************************************************************/
3815 static void lp_set_in_client(bool b)
3821 /***************************************************************************
3822 Determine if we're running in a client app
3823 ***************************************************************************/
3824 static bool lp_is_in_client(void)
3829 static void lp_enforce_ad_dc_settings(void)
3831 lp_do_parameter(GLOBAL_SECTION_SNUM, "passdb backend", "samba_dsdb");
3832 lp_do_parameter(GLOBAL_SECTION_SNUM,
3833 "winbindd:use external pipes", "true");
3834 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:default", "external");
3835 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:svcctl", "embedded");
3836 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:srvsvc", "embedded");
3837 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:eventlog", "embedded");
3838 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:ntsvcs", "embedded");
3839 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:winreg", "embedded");
3840 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:spoolss", "embedded");
3841 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_daemon:spoolssd", "embedded");
3842 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:tcpip", "no");
3845 /***************************************************************************
3846 Load the services array from the services file. Return true on success,
3848 ***************************************************************************/
3850 static bool lp_load_ex(const char *pszFname,
3854 bool reinit_globals,
3855 bool allow_include_registry,
3856 bool load_all_shares)
3860 TALLOC_CTX *frame = talloc_stackframe();
3861 struct loadparm_context *lp_ctx;
3865 DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
3867 bInGlobalSection = true;
3868 bGlobalOnly = global_only;
3869 bAllowIncludeRegistry = allow_include_registry;
3870 sDefault = _sDefault;
3872 lp_ctx = setup_lp_context(talloc_tos());
3874 init_globals(lp_ctx, reinit_globals);
3878 if (save_defaults) {
3883 if (!reinit_globals) {
3884 free_param_opts(&Globals.param_opt);
3885 apply_lp_set_cmdline();
3888 lp_do_parameter(-1, "idmap config * : backend", Globals.idmap_backend);
3890 /* We get sections first, so have to start 'behind' to make up */
3893 if (lp_config_backend_is_file()) {
3894 n2 = talloc_sub_basic(talloc_tos(), get_current_username(),
3895 current_user_info.domain,
3898 smb_panic("lp_load_ex: out of memory");
3901 add_to_file_list(NULL, &file_lists, pszFname, n2);
3903 bRetval = pm_process(n2, lp_do_section, do_parameter, lp_ctx);
3906 /* finish up the last section */
3907 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
3909 if (iServiceIndex >= 0) {
3910 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
3914 if (lp_config_backend_is_registry()) {
3916 /* config backend changed to registry in config file */
3918 * We need to use this extra global variable here to
3919 * survive restart: init_globals uses this as a default
3920 * for config_backend. Otherwise, init_globals would
3921 * send us into an endless loop here.
3924 config_backend = CONFIG_BACKEND_REGISTRY;
3926 DEBUG(1, ("lp_load_ex: changing to config backend "
3928 init_globals(lp_ctx, true);
3930 TALLOC_FREE(lp_ctx);
3932 lp_kill_all_services();
3933 ok = lp_load_ex(pszFname, global_only, save_defaults,
3934 add_ipc, reinit_globals,
3935 allow_include_registry,
3940 } else if (lp_config_backend_is_registry()) {
3941 bRetval = process_registry_globals();
3943 DEBUG(0, ("Illegal config backend given: %d\n",
3944 lp_config_backend()));
3948 if (bRetval && lp_registry_shares()) {
3949 if (load_all_shares) {
3950 bRetval = process_registry_shares();
3952 bRetval = reload_registry_shares();
3957 char *serv = lp_auto_services(talloc_tos());
3958 lp_add_auto_services(serv);
3963 /* When 'restrict anonymous = 2' guest connections to ipc$
3965 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
3966 if ( lp_enable_asu_support() ) {
3967 lp_add_ipc("ADMIN$", false);
3971 set_allowed_client_auth();
3973 if (lp_security() == SEC_ADS && strchr(lp_password_server(), ':')) {
3974 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
3975 lp_password_server()));
3980 /* Now we check we_are_a_wins_server and set szWINSserver to 127.0.0.1 */
3981 /* if we_are_a_wins_server is true and we are in the client */
3982 if (lp_is_in_client() && Globals.we_are_a_wins_server) {
3983 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
3988 fault_configure(smb_panic_s3);
3991 * We run this check once the whole smb.conf is parsed, to
3992 * force some settings for the standard way a AD DC is
3993 * operated. We may change these as our code evolves, which
3994 * is why we force these settings.
3996 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
3997 lp_enforce_ad_dc_settings();
4000 bAllowIncludeRegistry = true;
4006 static bool lp_load(const char *pszFname,
4010 bool reinit_globals)
4012 return lp_load_ex(pszFname,
4017 true, /* allow_include_registry */
4018 false); /* load_all_shares*/
4021 bool lp_load_initial_only(const char *pszFname)
4023 return lp_load_ex(pszFname,
4024 true, /* global only */
4025 true, /* save_defaults */
4026 false, /* add_ipc */
4027 true, /* reinit_globals */
4028 false, /* allow_include_registry */
4029 false); /* load_all_shares*/
4033 * most common lp_load wrapper, loading only the globals
4035 * If this is used in a daemon or client utility it should be called
4036 * after processing popt.
4038 bool lp_load_global(const char *file_name)
4040 return lp_load(file_name,
4041 true, /* global_only */
4042 false, /* save_defaults */
4043 false, /* add_ipc */
4044 true); /* reinit_globals */
4048 * The typical lp_load wrapper with shares, loads global and
4049 * shares, including IPC, but does not force immediate
4050 * loading of all shares from registry.
4052 bool lp_load_with_shares(const char *file_name)
4054 return lp_load(file_name,
4055 false, /* global_only */
4056 false, /* save_defaults */
4058 true); /* reinit_globals */
4062 * lp_load wrapper, especially for clients
4064 bool lp_load_client(const char *file_name)
4066 lp_set_in_client(true);
4068 return lp_load_global(file_name);
4072 * lp_load wrapper, loading only globals, but intended
4073 * for subsequent calls, not reinitializing the globals
4076 bool lp_load_global_no_reinit(const char *file_name)
4078 return lp_load(file_name,
4079 true, /* global_only */
4080 false, /* save_defaults */
4081 false, /* add_ipc */
4082 false); /* reinit_globals */
4086 * lp_load wrapper, loading globals and shares,
4087 * intended for subsequent calls, i.e. not reinitializing
4088 * the globals to default values.
4090 bool lp_load_no_reinit(const char *file_name)
4092 return lp_load(file_name,
4093 false, /* global_only */
4094 false, /* save_defaults */
4095 false, /* add_ipc */
4096 false); /* reinit_globals */
4101 * lp_load wrapper, especially for clients, no reinitialization
4103 bool lp_load_client_no_reinit(const char *file_name)
4105 lp_set_in_client(true);
4107 return lp_load_global_no_reinit(file_name);
4110 bool lp_load_with_registry_shares(const char *pszFname)
4112 return lp_load_ex(pszFname,
4113 false, /* global_only */
4114 true, /* save_defaults */
4115 false, /* add_ipc */
4116 false, /* reinit_globals */
4117 true, /* allow_include_registry */
4118 true); /* load_all_shares*/
4121 /***************************************************************************
4122 Return the max number of services.
4123 ***************************************************************************/
4125 int lp_numservices(void)
4127 return (iNumServices);
4130 /***************************************************************************
4131 Display the contents of the services array in human-readable form.
4132 ***************************************************************************/
4134 void lp_dump(FILE *f, bool show_defaults, int maxtoprint)
4137 struct loadparm_context *lp_ctx;
4140 defaults_saved = false;
4142 lp_ctx = setup_lp_context(talloc_tos());
4143 if (lp_ctx == NULL) {
4147 lpcfg_dump_globals(lp_ctx, f, !defaults_saved);
4149 lpcfg_dump_a_service(&sDefault, &sDefault, f, flags_list, show_defaults);
4151 for (iService = 0; iService < maxtoprint; iService++) {
4153 lp_dump_one(f, show_defaults, iService);
4157 /***************************************************************************
4158 Display the contents of one service in human-readable form.
4159 ***************************************************************************/
4161 void lp_dump_one(FILE * f, bool show_defaults, int snum)
4164 if (ServicePtrs[snum]->szService[0] == '\0')
4166 lpcfg_dump_a_service(ServicePtrs[snum], &sDefault, f,
4167 flags_list, show_defaults);
4171 /***************************************************************************
4172 Return the number of the service with the given name, or -1 if it doesn't
4173 exist. Note that this is a DIFFERENT ANIMAL from the internal function
4174 getservicebyname()! This works ONLY if all services have been loaded, and
4175 does not copy the found service.
4176 ***************************************************************************/
4178 int lp_servicenumber(const char *pszServiceName)
4181 fstring serviceName;
4183 if (!pszServiceName) {
4184 return GLOBAL_SECTION_SNUM;
4187 for (iService = iNumServices - 1; iService >= 0; iService--) {
4188 if (VALID(iService) && ServicePtrs[iService]->szService) {
4190 * The substitution here is used to support %U in
4193 fstrcpy(serviceName, ServicePtrs[iService]->szService);
4194 standard_sub_basic(get_current_username(),
4195 current_user_info.domain,
4196 serviceName,sizeof(serviceName));
4197 if (strequal(serviceName, pszServiceName)) {
4203 if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
4204 struct timespec last_mod;
4206 if (!usershare_exists(iService, &last_mod)) {
4207 /* Remove the share security tdb entry for it. */
4208 delete_share_security(lp_servicename(talloc_tos(), iService));
4209 /* Remove it from the array. */
4210 free_service_byindex(iService);
4211 /* Doesn't exist anymore. */
4212 return GLOBAL_SECTION_SNUM;
4215 /* Has it been modified ? If so delete and reload. */
4216 if (timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
4218 /* Remove it from the array. */
4219 free_service_byindex(iService);
4220 /* and now reload it. */
4221 iService = load_usershare_service(pszServiceName);
4226 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
4227 return GLOBAL_SECTION_SNUM;
4233 /*******************************************************************
4234 A useful volume label function.
4235 ********************************************************************/
4237 const char *volume_label(TALLOC_CTX *ctx, int snum)
4240 const char *label = lp_volume(ctx, snum);
4242 label = lp_servicename(ctx, snum);
4245 /* This returns a 33 byte guarenteed null terminated string. */
4246 ret = talloc_strndup(ctx, label, 32);
4253 /*******************************************************************
4254 Get the default server type we will announce as via nmbd.
4255 ********************************************************************/
4257 int lp_default_server_announce(void)
4259 int default_server_announce = 0;
4260 default_server_announce |= SV_TYPE_WORKSTATION;
4261 default_server_announce |= SV_TYPE_SERVER;
4262 default_server_announce |= SV_TYPE_SERVER_UNIX;
4264 /* note that the flag should be set only if we have a
4265 printer service but nmbd doesn't actually load the
4266 services so we can't tell --jerry */
4268 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
4270 default_server_announce |= SV_TYPE_SERVER_NT;
4271 default_server_announce |= SV_TYPE_NT;
4273 switch (lp_server_role()) {
4274 case ROLE_DOMAIN_MEMBER:
4275 default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
4277 case ROLE_DOMAIN_PDC:
4278 default_server_announce |= SV_TYPE_DOMAIN_CTRL;
4280 case ROLE_DOMAIN_BDC:
4281 default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
4283 case ROLE_STANDALONE:
4287 if (lp_time_server())
4288 default_server_announce |= SV_TYPE_TIME_SOURCE;
4290 if (lp_host_msdfs())
4291 default_server_announce |= SV_TYPE_DFS_SERVER;
4293 return default_server_announce;
4296 /***********************************************************
4297 If we are PDC then prefer us as DMB
4298 ************************************************************/
4300 bool lp_domain_master(void)
4302 if (Globals._domain_master == Auto)
4303 return (lp_server_role() == ROLE_DOMAIN_PDC);
4305 return (bool)Globals._domain_master;
4308 /***********************************************************
4309 If we are PDC then prefer us as DMB
4310 ************************************************************/
4312 static bool lp_domain_master_true_or_auto(void)
4314 if (Globals._domain_master) /* auto or yes */
4320 /***********************************************************
4321 If we are DMB then prefer us as LMB
4322 ************************************************************/
4324 bool lp_preferred_master(void)
4326 int preferred_master = lp__preferred_master();
4328 if (preferred_master == Auto)
4329 return (lp_local_master() && lp_domain_master());
4331 return (bool)preferred_master;
4334 /*******************************************************************
4336 ********************************************************************/
4338 void lp_remove_service(int snum)
4340 ServicePtrs[snum]->valid = false;
4343 const char *lp_printername(TALLOC_CTX *ctx, int snum)
4345 const char *ret = lp__printername(ctx, snum);
4346 if (ret == NULL || *ret == '\0') {
4347 ret = lp_const_servicename(snum);
4354 /***********************************************************
4355 Allow daemons such as winbindd to fix their logfile name.
4356 ************************************************************/
4358 void lp_set_logfile(const char *name)
4360 lpcfg_string_set(Globals.ctx, &Globals.logfile, name);
4361 debug_set_logfile(name);
4364 /*******************************************************************
4365 Return the max print jobs per queue.
4366 ********************************************************************/
4368 int lp_maxprintjobs(int snum)
4370 int maxjobs = lp_max_print_jobs(snum);
4372 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
4373 maxjobs = PRINT_MAX_JOBID - 1;
4378 const char *lp_printcapname(void)
4380 const char *printcap_name = lp_printcap_name();
4382 if ((printcap_name != NULL) &&
4383 (printcap_name[0] != '\0'))
4384 return printcap_name;
4386 if (sDefault.printing == PRINT_CUPS) {
4390 if (sDefault.printing == PRINT_BSD)
4391 return "/etc/printcap";
4393 return PRINTCAP_NAME;
4396 static uint32_t spoolss_state;
4398 bool lp_disable_spoolss( void )
4400 if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
4401 spoolss_state = lp__disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4403 return spoolss_state == SVCCTL_STOPPED ? true : false;
4406 void lp_set_spoolss_state( uint32_t state )
4408 SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
4410 spoolss_state = state;
4413 uint32_t lp_get_spoolss_state( void )
4415 return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4418 /*******************************************************************
4419 Ensure we don't use sendfile if server smb signing is active.
4420 ********************************************************************/
4422 bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state)
4424 bool sign_active = false;
4426 /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
4427 if (get_Protocol() < PROTOCOL_NT1) {
4430 if (signing_state) {
4431 sign_active = smb_signing_is_active(signing_state);
4433 return (lp__use_sendfile(snum) &&
4434 (get_remote_arch() != RA_WIN95) &&
4438 /*******************************************************************
4439 Turn off sendfile if we find the underlying OS doesn't support it.
4440 ********************************************************************/
4442 void set_use_sendfile(int snum, bool val)
4444 if (LP_SNUM_OK(snum))
4445 ServicePtrs[snum]->_use_sendfile = val;
4447 sDefault._use_sendfile = val;
4450 void lp_set_mangling_method(const char *new_method)
4452 lpcfg_string_set(Globals.ctx, &Globals.mangling_method, new_method);
4455 /*******************************************************************
4456 Global state for POSIX pathname processing.
4457 ********************************************************************/
4459 static bool posix_pathnames;
4461 bool lp_posix_pathnames(void)
4463 return posix_pathnames;
4466 /*******************************************************************
4467 Change everything needed to ensure POSIX pathname processing (currently
4469 ********************************************************************/
4471 void lp_set_posix_pathnames(void)
4473 posix_pathnames = true;
4476 /*******************************************************************
4477 Global state for POSIX lock processing - CIFS unix extensions.
4478 ********************************************************************/
4480 bool posix_default_lock_was_set;
4481 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
4483 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
4485 if (posix_default_lock_was_set) {
4486 return posix_cifsx_locktype;
4488 return (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
4489 POSIX_LOCK : WINDOWS_LOCK;
4493 /*******************************************************************
4494 ********************************************************************/
4496 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
4498 posix_default_lock_was_set = true;
4499 posix_cifsx_locktype = val;
4502 int lp_min_receive_file_size(void)
4504 int min_receivefile_size = lp_min_receivefile_size();
4506 if (min_receivefile_size < 0) {
4509 return min_receivefile_size;
4512 /*******************************************************************
4513 Safe wide links checks.
4514 This helper function always verify the validity of wide links,
4515 even after a configuration file reload.
4516 ********************************************************************/
4518 void widelinks_warning(int snum)
4520 if (lp_allow_insecure_wide_links()) {
4524 if (lp_unix_extensions() && lp_wide_links(snum)) {
4525 DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
4526 "These parameters are incompatible. "
4527 "Wide links will be disabled for this share.\n",
4528 lp_servicename(talloc_tos(), snum) ));
4532 bool lp_widelinks(int snum)
4534 /* wide links is always incompatible with unix extensions */
4535 if (lp_unix_extensions()) {
4537 * Unless we have "allow insecure widelinks"
4540 if (!lp_allow_insecure_wide_links()) {
4545 return lp_wide_links(snum);
4548 int lp_server_role(void)
4550 return lp_find_server_role(lp__server_role(),
4552 lp__domain_logons(),
4553 lp_domain_master_true_or_auto());
4556 int lp_security(void)
4558 return lp_find_security(lp__server_role(),
4562 int lp_client_max_protocol(void)
4564 int client_max_protocol = lp__client_max_protocol();
4565 if (client_max_protocol == PROTOCOL_DEFAULT) {
4566 return PROTOCOL_LATEST;
4568 return client_max_protocol;
4571 int lp_client_ipc_min_protocol(void)
4573 int client_ipc_min_protocol = lp__client_ipc_min_protocol();
4574 if (client_ipc_min_protocol == PROTOCOL_DEFAULT) {
4575 client_ipc_min_protocol = lp_client_min_protocol();
4577 if (client_ipc_min_protocol < PROTOCOL_NT1) {
4578 return PROTOCOL_NT1;
4580 return client_ipc_min_protocol;
4583 int lp_client_ipc_max_protocol(void)
4585 int client_ipc_max_protocol = lp__client_ipc_max_protocol();
4586 if (client_ipc_max_protocol == PROTOCOL_DEFAULT) {
4587 return PROTOCOL_LATEST;
4589 if (client_ipc_max_protocol < PROTOCOL_NT1) {
4590 return PROTOCOL_NT1;
4592 return client_ipc_max_protocol;
4595 int lp_client_ipc_signing(void)
4597 int client_ipc_signing = lp__client_ipc_signing();
4598 if (client_ipc_signing == SMB_SIGNING_DEFAULT) {
4599 return SMB_SIGNING_REQUIRED;
4601 return client_ipc_signing;
4604 int lp_rpc_low_port(void)
4606 return Globals.rpc_low_port;
4609 int lp_rpc_high_port(void)
4611 return Globals.rpc_high_port;
4615 * Do not allow LanMan auth if unless NTLMv1 is also allowed
4617 * This also ensures it is disabled if NTLM is totally disabled
4619 bool lp_lanman_auth(void)
4621 enum ntlm_auth_level ntlm_auth_level = lp_ntlm_auth();
4623 if (ntlm_auth_level == NTLM_AUTH_ON) {
4624 return lp__lanman_auth();
4630 struct loadparm_global * get_globals(void)
4635 unsigned int * get_flags(void)
4637 if (flags_list == NULL) {
4638 flags_list = talloc_zero_array(NULL, unsigned int, num_parameters());