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"
74 #ifdef HAVE_SYS_SYSCTL_H
75 #include <sys/sysctl.h>
80 extern userdom_struct current_user_info;
82 /* the special value for the include parameter
83 * to be interpreted not as a file name but to
84 * trigger loading of the global smb.conf options
86 #ifndef INCLUDE_REGISTRY_NAME
87 #define INCLUDE_REGISTRY_NAME "registry"
90 static bool in_client = false; /* Not in the client by default */
91 static struct smbconf_csn conf_last_csn;
93 static int config_backend = CONFIG_BACKEND_FILE;
95 /* some helpful bits */
96 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && \
97 (ServicePtrs != NULL) && \
98 (ServicePtrs[(i)] != NULL) && ServicePtrs[(i)]->valid)
99 #define VALID(i) ((ServicePtrs != NULL) && (ServicePtrs[i]!= NULL) && \
100 ServicePtrs[i]->valid)
102 #define USERSHARE_VALID 1
103 #define USERSHARE_PENDING_DELETE 2
105 static bool defaults_saved = false;
107 #include "lib/param/param_global.h"
109 static struct loadparm_global Globals;
111 /* This is a default service used to prime a services structure */
112 static struct loadparm_service sDefault =
117 .usershare_last_mod = {0, 0},
121 .invalid_users = NULL,
128 .root_preexec = NULL,
129 .root_postexec = NULL,
130 .cups_options = NULL,
131 .print_command = NULL,
133 .lprm_command = NULL,
134 .lppause_command = NULL,
135 .lpresume_command = NULL,
136 .queuepause_command = NULL,
137 .queueresume_command = NULL,
138 ._printername = NULL,
139 .printjob_username = NULL,
140 .dont_descend = NULL,
143 .magic_script = NULL,
144 .magic_output = NULL,
147 .veto_oplock_files = NULL,
157 .aio_write_behind = NULL,
158 .dfree_command = NULL,
159 .min_print_space = 0,
160 .max_print_jobs = 1000,
161 .max_reported_print_jobs = 0,
162 .write_cache_size = 0,
164 .force_create_mode = 0,
165 .directory_mask = 0755,
166 .force_directory_mode = 0,
167 .max_connections = 0,
168 .default_case = CASE_LOWER,
169 .printing = DEFAULT_PRINTING,
170 .oplock_contention_limit = 2,
173 .dfree_cache_time = 0,
174 .preexec_close = false,
175 .root_preexec_close = false,
176 .case_sensitive = Auto,
177 .preserve_case = true,
178 .short_preserve_case = true,
179 .hide_dot_files = true,
180 .hide_special_files = false,
181 .hide_unreadable = false,
182 .hide_unwriteable_files = false,
184 .access_based_share_enum = false,
189 .administrative_share = false,
192 .print_notify_backchannel = false,
196 .store_dos_attributes = false,
197 .dmapi_support = false,
199 .strict_locking = Auto,
200 .posix_locking = true,
202 .kernel_oplocks = false,
203 .level2_oplocks = true,
205 .mangled_names = true,
207 .follow_symlinks = true,
208 .sync_always = false,
209 .strict_allocate = false,
210 .strict_rename = false,
211 .strict_sync = false,
212 .mangling_char = '~',
214 .delete_readonly = false,
215 .fake_oplocks = false,
216 .delete_veto_files = false,
217 .dos_filemode = false,
218 .dos_filetimes = true,
219 .dos_filetime_resolution = false,
220 .fake_directory_create_times = false,
221 .blocking_locks = true,
222 .inherit_permissions = false,
223 .inherit_acls = false,
224 .inherit_owner = false,
226 .msdfs_shuffle_referrals = false,
227 .use_client_driver = false,
228 .default_devmode = true,
229 .force_printername = false,
230 .nt_acl_support = true,
231 .force_unknown_acl_user = false,
232 ._use_sendfile = false,
233 .profile_acls = false,
234 .map_acl_inherit = false,
237 .acl_check_permissions = true,
238 .acl_map_full_control = true,
239 .acl_group_control = false,
240 .acl_allow_execute_always = false,
241 .allocation_roundup_size = SMB_ROUNDUP_ALLOCATION_SIZE,
244 .map_readonly = MAP_READONLY_YES,
245 .directory_name_cache_size = 100,
246 .smb_encrypt = SMB_SIGNING_DEFAULT,
247 .kernel_share_modes = true,
248 .durable_handles = true,
253 /* local variables */
254 static struct loadparm_service **ServicePtrs = NULL;
255 static int iNumServices = 0;
256 static int iServiceIndex = 0;
257 static struct db_context *ServiceHash;
258 static bool bInGlobalSection = true;
259 static bool bGlobalOnly = false;
260 static struct file_lists *file_lists = NULL;
261 static unsigned int *flags_list = NULL;
263 static void set_allowed_client_auth(void);
265 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue);
266 static void free_param_opts(struct parmlist_entry **popts);
269 * Function to return the default value for the maximum number of open
270 * file descriptors permitted. This function tries to consult the
271 * kernel-level (sysctl) and ulimit (getrlimit()) values and goes
272 * the smaller of those.
274 static int max_open_files(void)
276 int sysctl_max = MAX_OPEN_FILES;
277 int rlimit_max = MAX_OPEN_FILES;
279 #ifdef HAVE_SYSCTLBYNAME
281 size_t size = sizeof(sysctl_max);
282 sysctlbyname("kern.maxfilesperproc", &sysctl_max, &size, NULL,
287 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
293 if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
294 rlimit_max = rl.rlim_cur;
296 #if defined(RLIM_INFINITY)
297 if(rl.rlim_cur == RLIM_INFINITY)
298 rlimit_max = MAX_OPEN_FILES;
303 if (sysctl_max < MIN_OPEN_FILES_WINDOWS) {
304 DEBUG(2,("max_open_files: increasing sysctl_max (%d) to "
305 "minimum Windows limit (%d)\n",
307 MIN_OPEN_FILES_WINDOWS));
308 sysctl_max = MIN_OPEN_FILES_WINDOWS;
311 if (rlimit_max < MIN_OPEN_FILES_WINDOWS) {
312 DEBUG(2,("rlimit_max: increasing rlimit_max (%d) to "
313 "minimum Windows limit (%d)\n",
315 MIN_OPEN_FILES_WINDOWS));
316 rlimit_max = MIN_OPEN_FILES_WINDOWS;
319 return MIN(sysctl_max, rlimit_max);
323 * Common part of freeing allocated data for one parameter.
325 static void free_one_parameter_common(void *parm_ptr,
326 struct parm_struct parm)
328 if ((parm.type == P_STRING) ||
329 (parm.type == P_USTRING))
331 lpcfg_string_free((char**)parm_ptr);
332 } else if (parm.type == P_LIST || parm.type == P_CMDLIST) {
333 TALLOC_FREE(*((char***)parm_ptr));
338 * Free the allocated data for one parameter for a share
339 * given as a service struct.
341 static void free_one_parameter(struct loadparm_service *service,
342 struct parm_struct parm)
346 if (parm.p_class != P_LOCAL) {
350 parm_ptr = lp_parm_ptr(service, &parm);
352 free_one_parameter_common(parm_ptr, parm);
356 * Free the allocated parameter data of a share given
357 * as a service struct.
359 static void free_parameters(struct loadparm_service *service)
363 for (i=0; parm_table[i].label; i++) {
364 free_one_parameter(service, parm_table[i]);
369 * Free the allocated data for one parameter for a given share
370 * specified by an snum.
372 static void free_one_parameter_by_snum(int snum, struct parm_struct parm)
377 parm_ptr = lp_parm_ptr(NULL, &parm);
378 } else if (parm.p_class != P_LOCAL) {
381 parm_ptr = lp_parm_ptr(ServicePtrs[snum], &parm);
384 free_one_parameter_common(parm_ptr, parm);
388 * Free the allocated parameter data for a share specified
391 static void free_parameters_by_snum(int snum)
395 for (i=0; parm_table[i].label; i++) {
396 free_one_parameter_by_snum(snum, parm_table[i]);
401 * Free the allocated global parameters.
403 static void free_global_parameters(void)
406 struct parm_struct *parm;
408 free_param_opts(&Globals.param_opt);
409 free_parameters_by_snum(GLOBAL_SECTION_SNUM);
411 /* Reset references in the defaults because the context is going to be freed */
412 for (i=0; parm_table[i].label; i++) {
413 parm = &parm_table[i];
414 if ((parm->type == P_STRING) ||
415 (parm->type == P_USTRING)) {
416 if ((parm->def.svalue != NULL) &&
417 (*(parm->def.svalue) != '\0')) {
418 if (talloc_parent(parm->def.svalue) == Globals.ctx) {
419 parm->def.svalue = NULL;
424 TALLOC_FREE(Globals.ctx);
427 struct lp_stored_option {
428 struct lp_stored_option *prev, *next;
433 static struct lp_stored_option *stored_options;
436 save options set by lp_set_cmdline() into a list. This list is
437 re-applied when we do a globals reset, so that cmdline set options
438 are sticky across reloads of smb.conf
440 bool store_lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
442 struct lp_stored_option *entry, *entry_next;
443 for (entry = stored_options; entry != NULL; entry = entry_next) {
444 entry_next = entry->next;
445 if (strcmp(pszParmName, entry->label) == 0) {
446 DLIST_REMOVE(stored_options, entry);
452 entry = talloc(NULL, struct lp_stored_option);
457 entry->label = talloc_strdup(entry, pszParmName);
463 entry->value = talloc_strdup(entry, pszParmValue);
469 DLIST_ADD_END(stored_options, entry);
474 static bool apply_lp_set_cmdline(void)
476 struct lp_stored_option *entry = NULL;
477 for (entry = stored_options; entry != NULL; entry = entry->next) {
478 if (!lp_set_cmdline_helper(entry->label, entry->value)) {
479 DEBUG(0, ("Failed to re-apply cmdline parameter %s = %s\n",
480 entry->label, entry->value));
487 /***************************************************************************
488 Initialise the global parameter structure.
489 ***************************************************************************/
491 static void init_globals(struct loadparm_context *lp_ctx, bool reinit_globals)
493 static bool done_init = false;
497 /* If requested to initialize only once and we've already done it... */
498 if (!reinit_globals && done_init) {
499 /* ... then we have nothing more to do */
504 /* The logfile can be set before this is invoked. Free it if so. */
505 lpcfg_string_free(&Globals.logfile);
508 free_global_parameters();
511 /* This memset and the free_global_parameters() above will
512 * wipe out smb.conf options set with lp_set_cmdline(). The
513 * apply_lp_set_cmdline() call puts these values back in the
514 * table once the defaults are set */
515 ZERO_STRUCT(Globals);
517 Globals.ctx = talloc_pooled_object(NULL, char, 272, 2048);
519 /* Initialize the flags list if necessary */
520 if (flags_list == NULL) {
524 for (i = 0; parm_table[i].label; i++) {
525 if ((parm_table[i].type == P_STRING ||
526 parm_table[i].type == P_USTRING))
530 (char **)lp_parm_ptr(NULL, &parm_table[i]),
536 lpcfg_string_set(Globals.ctx, &sDefault.fstype, FSTYPE_STRING);
537 lpcfg_string_set(Globals.ctx, &sDefault.printjob_username, "%U");
539 init_printer_values(lp_ctx, Globals.ctx, &sDefault);
541 sDefault.ntvfs_handler = str_list_make_v3_const(NULL, "unixuid default", NULL);
543 DEBUG(3, ("Initialising global parameters\n"));
545 /* Must manually force to upper case here, as this does not go via the handler */
546 lpcfg_string_set(Globals.ctx, &Globals.netbios_name,
549 lpcfg_string_set(Globals.ctx, &Globals.smb_passwd_file,
550 get_dyn_SMB_PASSWD_FILE());
551 lpcfg_string_set(Globals.ctx, &Globals.private_dir,
552 get_dyn_PRIVATE_DIR());
554 /* use the new 'hash2' method by default, with a prefix of 1 */
555 lpcfg_string_set(Globals.ctx, &Globals.mangling_method, "hash2");
556 Globals.mangle_prefix = 1;
558 lpcfg_string_set(Globals.ctx, &Globals.guest_account, GUEST_ACCOUNT);
560 /* using UTF8 by default allows us to support all chars */
561 lpcfg_string_set(Globals.ctx, &Globals.unix_charset,
562 DEFAULT_UNIX_CHARSET);
564 /* Use codepage 850 as a default for the dos character set */
565 lpcfg_string_set(Globals.ctx, &Globals.dos_charset,
566 DEFAULT_DOS_CHARSET);
569 * Allow the default PASSWD_CHAT to be overridden in local.h.
571 lpcfg_string_set(Globals.ctx, &Globals.passwd_chat,
572 DEFAULT_PASSWD_CHAT);
574 lpcfg_string_set(Globals.ctx, &Globals.workgroup, DEFAULT_WORKGROUP);
576 lpcfg_string_set(Globals.ctx, &Globals.passwd_program, "");
577 lpcfg_string_set(Globals.ctx, &Globals.lock_directory,
579 lpcfg_string_set(Globals.ctx, &Globals.state_directory,
581 lpcfg_string_set(Globals.ctx, &Globals.cache_directory,
583 lpcfg_string_set(Globals.ctx, &Globals.pid_directory,
585 lpcfg_string_set(Globals.ctx, &Globals.nbt_client_socket_address,
588 * By default support explicit binding to broadcast
591 Globals.nmbd_bind_explicit_broadcast = true;
593 s = talloc_asprintf(talloc_tos(), "Samba %s", samba_version_string());
595 smb_panic("init_globals: ENOMEM");
597 lpcfg_string_set(Globals.ctx, &Globals.server_string, s);
600 lpcfg_string_set(Globals.ctx, &Globals.panic_action,
601 "/bin/sleep 999999999");
604 lpcfg_string_set(Globals.ctx, &Globals.socket_options,
605 DEFAULT_SOCKET_OPTIONS);
607 lpcfg_string_set(Globals.ctx, &Globals.logon_drive, "");
608 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
609 lpcfg_string_set(Globals.ctx, &Globals.logon_home, "\\\\%N\\%U");
610 lpcfg_string_set(Globals.ctx, &Globals.logon_path,
611 "\\\\%N\\%U\\profile");
613 Globals.name_resolve_order = str_list_make_v3_const(NULL, "lmhosts wins host bcast", NULL);
614 lpcfg_string_set(Globals.ctx, &Globals.password_server, "*");
616 Globals.algorithmic_rid_base = BASE_RID;
618 Globals.load_printers = true;
619 Globals.printcap_cache_time = 750; /* 12.5 minutes */
621 Globals.config_backend = config_backend;
622 Globals._server_role = ROLE_AUTO;
624 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
625 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
626 Globals.max_xmit = 0x4104;
627 Globals.max_mux = 50; /* This is *needed* for profile support. */
628 Globals.lpq_cache_time = 30; /* changed to handle large print servers better -- jerry */
629 Globals._disable_spoolss = false;
630 Globals.max_smbd_processes = 0;/* no limit specified */
631 Globals.username_level = 0;
632 Globals.deadtime = 0;
633 Globals.getwd_cache = true;
634 Globals.large_readwrite = true;
635 Globals.max_log_size = 5000;
636 Globals.max_open_files = max_open_files();
637 Globals.server_max_protocol = PROTOCOL_SMB3_11;
638 Globals.server_min_protocol = PROTOCOL_LANMAN1;
639 Globals._client_max_protocol = PROTOCOL_DEFAULT;
640 Globals.client_min_protocol = PROTOCOL_CORE;
641 Globals._security = SEC_AUTO;
642 Globals.encrypt_passwords = true;
643 Globals.client_schannel = Auto;
644 Globals.winbind_sealed_pipes = true;
645 Globals.require_strong_key = true;
646 Globals.server_schannel = Auto;
647 Globals.read_raw = true;
648 Globals.write_raw = true;
649 Globals.null_passwords = false;
650 Globals.old_password_allowed_period = 60;
651 Globals.obey_pam_restrictions = false;
653 Globals.syslog_only = false;
654 Globals.timestamp_logs = true;
655 lpcfg_string_set(Globals.ctx, &Globals.log_level, "0");
656 Globals.debug_prefix_timestamp = false;
657 Globals.debug_hires_timestamp = true;
658 Globals.debug_pid = false;
659 Globals.debug_uid = false;
660 Globals.debug_class = false;
661 Globals.enable_core_files = true;
662 Globals.max_ttl = 60 * 60 * 24 * 3; /* 3 days default. */
663 Globals.max_wins_ttl = 60 * 60 * 24 * 6; /* 6 days default. */
664 Globals.min_wins_ttl = 60 * 60 * 6; /* 6 hours default. */
665 Globals.machine_password_timeout = 60 * 60 * 24 * 7; /* 7 days default. */
666 Globals.lm_announce = Auto; /* = Auto: send only if LM clients found */
667 Globals.lm_interval = 60;
668 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
669 Globals.nis_homedir = false;
670 #ifdef WITH_NISPLUS_HOME
671 lpcfg_string_set(Globals.ctx, &Globals.homedir_map,
672 "auto_home.org_dir");
674 lpcfg_string_set(Globals.ctx, &Globals.homedir_map, "auto.home");
677 Globals.time_server = false;
678 Globals.bind_interfaces_only = false;
679 Globals.unix_password_sync = false;
680 Globals.pam_password_change = false;
681 Globals.passwd_chat_debug = false;
682 Globals.passwd_chat_timeout = 2; /* 2 second default. */
683 Globals.nt_pipe_support = true; /* Do NT pipes by default. */
684 Globals.nt_status_support = true; /* Use NT status by default. */
685 Globals.smbd_profiling_level = 0;
686 Globals.stat_cache = true; /* use stat cache by default */
687 Globals.max_stat_cache_size = 256; /* 256k by default */
688 Globals.restrict_anonymous = 0;
689 Globals.client_lanman_auth = false; /* Do NOT use the LanMan hash if it is available */
690 Globals.client_plaintext_auth = false; /* Do NOT use a plaintext password even if is requested by the server */
691 Globals.lanman_auth = false; /* Do NOT use the LanMan hash, even if it is supplied */
692 Globals.ntlm_auth = true; /* Do use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
693 Globals.raw_ntlmv2_auth = false; /* Reject NTLMv2 without NTLMSSP */
694 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 */
695 /* Note, that we will also use NTLM2 session security (which is different), if it is available */
697 Globals.map_to_guest = 0; /* By Default, "Never" */
698 Globals.oplock_break_wait_time = 0; /* By Default, 0 msecs. */
699 Globals.enhanced_browsing = true;
700 Globals.lock_spin_time = WINDOWS_MINIMUM_LOCK_TIMEOUT_MS; /* msec. */
701 #ifdef MMAP_BLACKLIST
702 Globals.use_mmap = false;
704 Globals.use_mmap = true;
706 Globals.unicode = true;
707 Globals.unix_extensions = true;
708 Globals.reset_on_zero_vc = false;
709 Globals.log_writeable_files_on_exit = false;
710 Globals.create_krb5_conf = true;
711 Globals._winbind_max_domain_connections = 1;
713 /* hostname lookups can be very expensive and are broken on
714 a large number of sites (tridge) */
715 Globals.hostname_lookups = false;
717 Globals.change_notify = true,
718 Globals.kernel_change_notify = true,
720 lpcfg_string_set(Globals.ctx, &Globals.passdb_backend, "tdbsam");
721 lpcfg_string_set(Globals.ctx, &Globals.ldap_suffix, "");
722 lpcfg_string_set(Globals.ctx, &Globals._ldap_machine_suffix, "");
723 lpcfg_string_set(Globals.ctx, &Globals._ldap_user_suffix, "");
724 lpcfg_string_set(Globals.ctx, &Globals._ldap_group_suffix, "");
725 lpcfg_string_set(Globals.ctx, &Globals._ldap_idmap_suffix, "");
727 lpcfg_string_set(Globals.ctx, &Globals.ldap_admin_dn, "");
728 Globals.ldap_ssl = LDAP_SSL_START_TLS;
729 Globals.ldap_ssl_ads = false;
730 Globals.ldap_deref = -1;
731 Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
732 Globals.ldap_delete_dn = false;
733 Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
734 Globals.ldap_follow_referral = Auto;
735 Globals.ldap_timeout = LDAP_DEFAULT_TIMEOUT;
736 Globals.ldap_connection_timeout = LDAP_CONNECTION_DEFAULT_TIMEOUT;
737 Globals.ldap_page_size = LDAP_PAGE_SIZE;
739 Globals.ldap_debug_level = 0;
740 Globals.ldap_debug_threshold = 10;
742 Globals.client_ldap_sasl_wrapping = ADS_AUTH_SASL_SIGN;
744 /* This is what we tell the afs client. in reality we set the token
745 * to never expire, though, when this runs out the afs client will
746 * forget the token. Set to 0 to get NEVERDATE.*/
747 Globals.afs_token_lifetime = 604800;
748 Globals.cups_connection_timeout = CUPS_DEFAULT_CONNECTION_TIMEOUT;
750 /* these parameters are set to defaults that are more appropriate
751 for the increasing samba install base:
753 as a member of the workgroup, that will possibly become a
754 _local_ master browser (lm = true). this is opposed to a forced
755 local master browser startup (pm = true).
757 doesn't provide WINS server service by default (wsupp = false),
758 and doesn't provide domain master browser services by default, either.
762 Globals.show_add_printer_wizard = true;
763 Globals.os_level = 20;
764 Globals.local_master = true;
765 Globals._domain_master = Auto; /* depending on _domain_logons */
766 Globals._domain_logons = false;
767 Globals.browse_list = true;
768 Globals.we_are_a_wins_server = false;
769 Globals.wins_proxy = false;
771 TALLOC_FREE(Globals.init_logon_delayed_hosts);
772 Globals.init_logon_delay = 100; /* 100 ms default delay */
774 Globals.wins_dns_proxy = true;
776 Globals.allow_trusted_domains = true;
777 lpcfg_string_set(Globals.ctx, &Globals.idmap_backend, "tdb");
779 lpcfg_string_set(Globals.ctx, &Globals.template_shell, "/bin/false");
780 lpcfg_string_set(Globals.ctx, &Globals.template_homedir,
782 lpcfg_string_set(Globals.ctx, &Globals.winbind_separator, "\\");
783 lpcfg_string_set(Globals.ctx, &Globals.winbindd_socket_directory,
784 dyn_WINBINDD_SOCKET_DIR);
786 lpcfg_string_set(Globals.ctx, &Globals.cups_server, "");
787 lpcfg_string_set(Globals.ctx, &Globals.iprint_server, "");
789 lpcfg_string_set(Globals.ctx, &Globals._ctdbd_socket, "");
791 Globals.cluster_addresses = NULL;
792 Globals.clustering = false;
793 Globals.ctdb_timeout = 0;
794 Globals.ctdb_locktime_warn_threshold = 0;
796 Globals.winbind_cache_time = 300; /* 5 minutes */
797 Globals.winbind_reconnect_delay = 30; /* 30 seconds */
798 Globals.winbind_request_timeout = 60; /* 60 seconds */
799 Globals.winbind_max_clients = 200;
800 Globals.winbind_enum_users = false;
801 Globals.winbind_enum_groups = false;
802 Globals.winbind_use_default_domain = false;
803 Globals.winbind_trusted_domains_only = false;
804 Globals.winbind_nested_groups = true;
805 Globals.winbind_expand_groups = 0;
806 Globals.winbind_nss_info = str_list_make_v3_const(NULL, "template", NULL);
807 Globals.winbind_refresh_tickets = false;
808 Globals.winbind_offline_logon = false;
810 Globals.idmap_cache_time = 86400 * 7; /* a week by default */
811 Globals.idmap_negative_cache_time = 120; /* 2 minutes by default */
813 Globals.passdb_expand_explicit = false;
815 Globals.name_cache_timeout = 660; /* In seconds */
817 Globals.use_spnego = true;
818 Globals.client_use_spnego = true;
820 Globals.client_signing = SMB_SIGNING_DEFAULT;
821 Globals.server_signing = SMB_SIGNING_DEFAULT;
823 Globals.defer_sharing_violations = true;
824 Globals.smb_ports = str_list_make_v3_const(NULL, SMB_PORTS, NULL);
826 Globals.enable_privileges = true;
827 Globals.host_msdfs = true;
828 Globals.enable_asu_support = false;
830 /* User defined shares. */
831 s = talloc_asprintf(talloc_tos(), "%s/usershares", get_dyn_STATEDIR());
833 smb_panic("init_globals: ENOMEM");
835 lpcfg_string_set(Globals.ctx, &Globals.usershare_path, s);
837 lpcfg_string_set(Globals.ctx, &Globals.usershare_template_share, "");
838 Globals.usershare_max_shares = 0;
839 /* By default disallow sharing of directories not owned by the sharer. */
840 Globals.usershare_owner_only = true;
841 /* By default disallow guest access to usershares. */
842 Globals.usershare_allow_guests = false;
844 Globals.keepalive = DEFAULT_KEEPALIVE;
846 /* By default no shares out of the registry */
847 Globals.registry_shares = false;
849 Globals.min_receivefile_size = 0;
851 Globals.map_untrusted_to_domain = false;
852 Globals.multicast_dns_register = true;
854 Globals.smb2_max_read = DEFAULT_SMB2_MAX_READ;
855 Globals.smb2_max_write = DEFAULT_SMB2_MAX_WRITE;
856 Globals.smb2_max_trans = DEFAULT_SMB2_MAX_TRANSACT;
857 Globals.smb2_max_credits = DEFAULT_SMB2_MAX_CREDITS;
858 Globals.smb2_leases = false;
860 lpcfg_string_set(Globals.ctx, &Globals.ncalrpc_dir,
861 get_dyn_NCALRPCDIR());
863 Globals.server_services = str_list_make_v3_const(NULL, "s3fs rpc nbt wrepl ldap cldap kdc drepl winbindd ntp_signd kcc dnsupdate dns", NULL);
865 Globals.dcerpc_endpoint_servers = str_list_make_v3_const(NULL, "epmapper wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi dssetup unixinfo browser eventlog6 backupkey dnsserver", NULL);
867 Globals.tls_enabled = true;
869 lpcfg_string_set(Globals.ctx, &Globals._tls_keyfile, "tls/key.pem");
870 lpcfg_string_set(Globals.ctx, &Globals._tls_certfile, "tls/cert.pem");
871 lpcfg_string_set(Globals.ctx, &Globals._tls_cafile, "tls/ca.pem");
872 lpcfg_string_set(Globals.ctx, &Globals.tls_priority,
873 "NORMAL:-VERS-SSL3.0");
875 lpcfg_string_set(Globals.ctx, &Globals.share_backend, "classic");
877 Globals._preferred_master = Auto;
879 Globals.allow_dns_updates = DNS_UPDATE_SIGNED;
881 lpcfg_string_set(Globals.ctx, &Globals.ntp_signd_socket_directory,
882 get_dyn_NTP_SIGND_SOCKET_DIR());
884 lpcfg_string_set(Globals.ctx,
885 &Globals.winbindd_privileged_socket_directory,
886 get_dyn_WINBINDD_PRIVILEGED_SOCKET_DIR());
888 s = talloc_asprintf(talloc_tos(), "%s/samba_kcc", get_dyn_SCRIPTSBINDIR());
890 smb_panic("init_globals: ENOMEM");
892 Globals.samba_kcc_command = str_list_make_v3_const(NULL, s, NULL);
895 s = talloc_asprintf(talloc_tos(), "%s/samba_dnsupdate", get_dyn_SCRIPTSBINDIR());
897 smb_panic("init_globals: ENOMEM");
899 Globals.dns_update_command = str_list_make_v3_const(NULL, s, NULL);
902 s = talloc_asprintf(talloc_tos(), "%s/samba_spnupdate", get_dyn_SCRIPTSBINDIR());
904 smb_panic("init_globals: ENOMEM");
906 Globals.spn_update_command = str_list_make_v3_const(NULL, s, NULL);
909 Globals.nsupdate_command = str_list_make_v3_const(NULL, "/usr/bin/nsupdate -g", NULL);
911 Globals.rndc_command = str_list_make_v3_const(NULL, "/usr/sbin/rndc", NULL);
913 Globals.cldap_port = 389;
915 Globals.dgram_port = NBT_DGRAM_SERVICE_PORT;
917 Globals.nbt_port = NBT_NAME_SERVICE_PORT;
919 Globals.krb5_port = 88;
921 Globals.kpasswd_port = 464;
923 Globals.web_port = 901;
925 Globals.aio_max_threads = 100;
927 /* Now put back the settings that were set with lp_set_cmdline() */
928 apply_lp_set_cmdline();
931 /* Convenience routine to setup an lp_context with additional s3 variables */
932 static struct loadparm_context *setup_lp_context(TALLOC_CTX *mem_ctx)
934 struct loadparm_context *lp_ctx;
936 lp_ctx = loadparm_init_s3(mem_ctx,
937 loadparm_s3_helpers());
938 if (lp_ctx == NULL) {
939 DEBUG(0, ("loadparm_init_s3 failed\n"));
943 lp_ctx->sDefault = &sDefault;
944 lp_ctx->services = NULL; /* We do not want to access this directly */
945 lp_ctx->bInGlobalSection = bInGlobalSection;
946 lp_ctx->flags = flags_list;
951 /*******************************************************************
952 Convenience routine to grab string parameters into talloced memory
953 and run standard_sub_basic on them. The buffers can be written to by
954 callers without affecting the source string.
955 ********************************************************************/
957 char *lp_string(TALLOC_CTX *ctx, const char *s)
961 /* The follow debug is useful for tracking down memory problems
962 especially if you have an inner loop that is calling a lp_*()
963 function that returns a string. Perhaps this debug should be
964 present all the time? */
967 DEBUG(10, ("lp_string(%s)\n", s));
973 ret = talloc_sub_basic(ctx,
974 get_current_username(),
975 current_user_info.domain,
977 if (trim_char(ret, '\"', '\"')) {
978 if (strchr(ret,'\"') != NULL) {
980 ret = talloc_sub_basic(ctx,
981 get_current_username(),
982 current_user_info.domain,
990 In this section all the functions that are used to access the
991 parameters from the rest of the program are defined
994 #define FN_GLOBAL_STRING(fn_name,ptr) \
995 char *lp_ ## fn_name(TALLOC_CTX *ctx) {return(lp_string((ctx), *(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : ""));}
996 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
997 const char *lp_ ## fn_name(void) {return(*(const char * const *)(&Globals.ptr) ? *(const char * const *)(&Globals.ptr) : "");}
998 #define FN_GLOBAL_LIST(fn_name,ptr) \
999 const char **lp_ ## fn_name(void) {return(*(const char ***)(&Globals.ptr));}
1000 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1001 bool lp_ ## fn_name(void) {return(*(bool *)(&Globals.ptr));}
1002 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1003 char lp_ ## fn_name(void) {return(*(char *)(&Globals.ptr));}
1004 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1005 int lp_ ## fn_name(void) {return(*(int *)(&Globals.ptr));}
1007 #define FN_LOCAL_STRING(fn_name,val) \
1008 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));}
1009 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1010 const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1011 #define FN_LOCAL_LIST(fn_name,val) \
1012 const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1013 #define FN_LOCAL_BOOL(fn_name,val) \
1014 bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1015 #define FN_LOCAL_INTEGER(fn_name,val) \
1016 int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1018 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1019 bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1020 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1021 int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1022 #define FN_LOCAL_PARM_CHAR(fn_name,val) \
1023 char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1025 int lp_winbind_max_domain_connections(void)
1027 if (lp_winbind_offline_logon() &&
1028 lp__winbind_max_domain_connections() > 1) {
1029 DEBUG(1, ("offline logons active, restricting max domain "
1030 "connections to 1\n"));
1033 return MAX(1, lp__winbind_max_domain_connections());
1036 /* These functions remain in source3/param for now */
1038 #include "lib/param/param_functions.c"
1040 FN_LOCAL_STRING(servicename, szService)
1041 FN_LOCAL_CONST_STRING(const_servicename, szService)
1043 /* These functions cannot be auto-generated */
1044 FN_LOCAL_BOOL(autoloaded, autoloaded)
1045 FN_GLOBAL_CONST_STRING(dnsdomain, dnsdomain)
1047 /* local prototypes */
1049 static int map_parameter_canonical(const char *pszParmName, bool *inverse);
1050 static const char *get_boolean(bool bool_value);
1051 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
1053 static bool hash_a_service(const char *name, int number);
1054 static void free_service_byindex(int iService);
1055 static void show_parameter(int parmIndex);
1056 static bool is_synonym_of(int parm1, int parm2, bool *inverse);
1059 * This is a helper function for parametrical options support. It returns a
1060 * pointer to parametrical option value if it exists or NULL otherwise. Actual
1061 * parametrical functions are quite simple
1063 static struct parmlist_entry *get_parametrics(int snum, const char *type,
1066 if (snum >= iNumServices) return NULL;
1069 return get_parametric_helper(NULL, type, option, Globals.param_opt);
1071 return get_parametric_helper(ServicePtrs[snum],
1072 type, option, Globals.param_opt);
1076 static void discard_whitespace(char *str)
1078 size_t len = strlen(str);
1082 if (isspace(str[i])) {
1083 memmove(&str[i], &str[i+1], len-i);
1092 * @brief Go through all global parametric parameters
1094 * @param regex_str A regular expression to scan param for
1095 * @param max_matches Max number of submatches the regexp expects
1096 * @param cb Function to call on match. Should return true
1097 * when it wants wi_scan_global_parametrics to stop
1099 * @param private_data Anonymous pointer passed to cb
1101 * @return 0: success, regcomp/regexec return value on error.
1102 * See "man regexec" for possible errors
1105 int lp_wi_scan_global_parametrics(
1106 const char *regex_str, size_t max_matches,
1107 bool (*cb)(const char *string, regmatch_t matches[],
1108 void *private_data),
1111 struct parmlist_entry *data;
1115 ret = regcomp(®ex, regex_str, REG_ICASE);
1120 for (data = Globals.param_opt; data != NULL; data = data->next) {
1121 size_t keylen = strlen(data->key);
1123 regmatch_t matches[max_matches];
1126 memcpy(key, data->key, sizeof(key));
1127 discard_whitespace(key);
1129 ret = regexec(®ex, key, max_matches, matches, 0);
1130 if (ret == REG_NOMATCH) {
1137 stop = cb(key, matches, private_data);
1150 #define MISSING_PARAMETER(name) \
1151 DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
1153 /*******************************************************************
1154 convenience routine to return enum parameters.
1155 ********************************************************************/
1156 static int lp_enum(const char *s,const struct enum_list *_enum)
1160 if (!s || !*s || !_enum) {
1161 MISSING_PARAMETER(lp_enum);
1165 for (i=0; _enum[i].name; i++) {
1166 if (strequal(_enum[i].name,s))
1167 return _enum[i].value;
1170 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
1174 #undef MISSING_PARAMETER
1176 /* Return parametric option from a given service. Type is a part of option before ':' */
1177 /* Parametric option has following syntax: 'Type: option = value' */
1178 char *lp_parm_talloc_string(TALLOC_CTX *ctx, int snum, const char *type, const char *option, const char *def)
1180 struct parmlist_entry *data = get_parametrics(snum, type, option);
1182 if (data == NULL||data->value==NULL) {
1184 return lp_string(ctx, def);
1190 return lp_string(ctx, data->value);
1193 /* Return parametric option from a given service. Type is a part of option before ':' */
1194 /* Parametric option has following syntax: 'Type: option = value' */
1195 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
1197 struct parmlist_entry *data = get_parametrics(snum, type, option);
1199 if (data == NULL||data->value==NULL)
1206 /* Return parametric option from a given service. Type is a part of option before ':' */
1207 /* Parametric option has following syntax: 'Type: option = value' */
1209 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
1211 struct parmlist_entry *data = get_parametrics(snum, type, option);
1213 if (data == NULL||data->value==NULL)
1214 return (const char **)def;
1216 if (data->list==NULL) {
1217 data->list = str_list_make_v3(NULL, data->value, NULL);
1220 return discard_const_p(const char *, data->list);
1223 /* Return parametric option from a given service. Type is a part of option before ':' */
1224 /* Parametric option has following syntax: 'Type: option = value' */
1226 int lp_parm_int(int snum, const char *type, const char *option, int def)
1228 struct parmlist_entry *data = get_parametrics(snum, type, option);
1230 if (data && data->value && *data->value)
1231 return lp_int(data->value);
1236 /* Return parametric option from a given service. Type is a part of option before ':' */
1237 /* Parametric option has following syntax: 'Type: option = value' */
1239 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
1241 struct parmlist_entry *data = get_parametrics(snum, type, option);
1243 if (data && data->value && *data->value)
1244 return lp_ulong(data->value);
1249 /* Return parametric option from a given service. Type is a part of option before ':' */
1250 /* Parametric option has following syntax: 'Type: option = value' */
1252 unsigned long long lp_parm_ulonglong(int snum, const char *type,
1253 const char *option, unsigned long long def)
1255 struct parmlist_entry *data = get_parametrics(snum, type, option);
1257 if (data && data->value && *data->value) {
1258 return lp_ulonglong(data->value);
1264 /* Return parametric option from a given service. Type is a part of option
1266 /* Parametric option has following syntax: 'Type: option = value' */
1268 bool lp_parm_bool(int snum, const char *type, const char *option, bool def)
1270 struct parmlist_entry *data = get_parametrics(snum, type, option);
1272 if (data && data->value && *data->value)
1273 return lp_bool(data->value);
1278 /* Return parametric option from a given service. Type is a part of option before ':' */
1279 /* Parametric option has following syntax: 'Type: option = value' */
1281 int lp_parm_enum(int snum, const char *type, const char *option,
1282 const struct enum_list *_enum, int def)
1284 struct parmlist_entry *data = get_parametrics(snum, type, option);
1286 if (data && data->value && *data->value && _enum)
1287 return lp_enum(data->value, _enum);
1293 * free a param_opts structure.
1294 * param_opts handling should be moved to talloc;
1295 * then this whole functions reduces to a TALLOC_FREE().
1298 static void free_param_opts(struct parmlist_entry **popts)
1300 struct parmlist_entry *opt, *next_opt;
1302 if (*popts != NULL) {
1303 DEBUG(5, ("Freeing parametrics:\n"));
1306 while (opt != NULL) {
1307 lpcfg_string_free(&opt->key);
1308 lpcfg_string_free(&opt->value);
1309 TALLOC_FREE(opt->list);
1310 next_opt = opt->next;
1317 /***************************************************************************
1318 Free the dynamically allocated parts of a service struct.
1319 ***************************************************************************/
1321 static void free_service(struct loadparm_service *pservice)
1326 if (pservice->szService)
1327 DEBUG(5, ("free_service: Freeing service %s\n",
1328 pservice->szService));
1330 free_parameters(pservice);
1332 lpcfg_string_free(&pservice->szService);
1333 TALLOC_FREE(pservice->copymap);
1335 free_param_opts(&pservice->param_opt);
1337 ZERO_STRUCTP(pservice);
1341 /***************************************************************************
1342 remove a service indexed in the ServicePtrs array from the ServiceHash
1343 and free the dynamically allocated parts
1344 ***************************************************************************/
1346 static void free_service_byindex(int idx)
1348 if ( !LP_SNUM_OK(idx) )
1351 ServicePtrs[idx]->valid = false;
1353 /* we have to cleanup the hash record */
1355 if (ServicePtrs[idx]->szService) {
1356 char *canon_name = canonicalize_servicename(
1358 ServicePtrs[idx]->szService );
1360 dbwrap_delete_bystring(ServiceHash, canon_name );
1361 TALLOC_FREE(canon_name);
1364 free_service(ServicePtrs[idx]);
1365 TALLOC_FREE(ServicePtrs[idx]);
1368 /***************************************************************************
1369 Add a new service to the services array initialising it with the given
1371 ***************************************************************************/
1373 static int add_a_service(const struct loadparm_service *pservice, const char *name)
1376 struct loadparm_service **tsp = NULL;
1378 /* it might already exist */
1380 i = getservicebyname(name, NULL);
1386 /* Re use empty slots if any before allocating new one.*/
1387 for (i=0; i < iNumServices; i++) {
1388 if (ServicePtrs[i] == NULL) {
1392 if (i == iNumServices) {
1393 /* if not, then create one */
1394 tsp = talloc_realloc(NULL, ServicePtrs,
1395 struct loadparm_service *,
1398 DEBUG(0, ("add_a_service: failed to enlarge "
1405 ServicePtrs[i] = talloc_zero(ServicePtrs, struct loadparm_service);
1406 if (!ServicePtrs[i]) {
1407 DEBUG(0,("add_a_service: out of memory!\n"));
1411 ServicePtrs[i]->valid = true;
1413 copy_service(ServicePtrs[i], pservice, NULL);
1415 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->szService,
1418 DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
1419 i, ServicePtrs[i]->szService));
1421 if (!hash_a_service(ServicePtrs[i]->szService, i)) {
1428 /***************************************************************************
1429 Convert a string to uppercase and remove whitespaces.
1430 ***************************************************************************/
1432 char *canonicalize_servicename(TALLOC_CTX *ctx, const char *src)
1437 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
1441 result = talloc_strdup(ctx, src);
1442 SMB_ASSERT(result != NULL);
1444 if (!strlower_m(result)) {
1445 TALLOC_FREE(result);
1451 /***************************************************************************
1452 Add a name/index pair for the services array to the hash table.
1453 ***************************************************************************/
1455 static bool hash_a_service(const char *name, int idx)
1459 if ( !ServiceHash ) {
1460 DEBUG(10,("hash_a_service: creating servicehash\n"));
1461 ServiceHash = db_open_rbt(NULL);
1462 if ( !ServiceHash ) {
1463 DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
1468 DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
1471 canon_name = canonicalize_servicename(talloc_tos(), name );
1473 dbwrap_store_bystring(ServiceHash, canon_name,
1474 make_tdb_data((uint8_t *)&idx, sizeof(idx)),
1477 TALLOC_FREE(canon_name);
1482 /***************************************************************************
1483 Add a new home service, with the specified home directory, defaults coming
1485 ***************************************************************************/
1487 bool lp_add_home(const char *pszHomename, int iDefaultService,
1488 const char *user, const char *pszHomedir)
1492 if (pszHomename == NULL || user == NULL || pszHomedir == NULL ||
1493 pszHomedir[0] == '\0') {
1497 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
1502 if (!(*(ServicePtrs[iDefaultService]->path))
1503 || strequal(ServicePtrs[iDefaultService]->path,
1504 lp_path(talloc_tos(), GLOBAL_SECTION_SNUM))) {
1505 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path,
1509 if (!(*(ServicePtrs[i]->comment))) {
1510 char *comment = talloc_asprintf(talloc_tos(), "Home directory of %s", user);
1511 if (comment == NULL) {
1514 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment,
1516 TALLOC_FREE(comment);
1519 /* set the browseable flag from the global default */
1521 ServicePtrs[i]->browseable = sDefault.browseable;
1522 ServicePtrs[i]->access_based_share_enum = sDefault.access_based_share_enum;
1524 ServicePtrs[i]->autoloaded = true;
1526 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
1527 user, ServicePtrs[i]->path ));
1532 /***************************************************************************
1533 Add a new service, based on an old one.
1534 ***************************************************************************/
1536 int lp_add_service(const char *pszService, int iDefaultService)
1538 if (iDefaultService < 0) {
1539 return add_a_service(&sDefault, pszService);
1542 return (add_a_service(ServicePtrs[iDefaultService], pszService));
1545 /***************************************************************************
1546 Add the IPC service.
1547 ***************************************************************************/
1549 static bool lp_add_ipc(const char *ipc_name, bool guest_ok)
1551 char *comment = NULL;
1552 int i = add_a_service(&sDefault, ipc_name);
1557 comment = talloc_asprintf(talloc_tos(), "IPC Service (%s)",
1558 Globals.server_string);
1559 if (comment == NULL) {
1563 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path, tmpdir());
1564 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->username, "");
1565 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1566 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->fstype, "IPC");
1567 ServicePtrs[i]->max_connections = 0;
1568 ServicePtrs[i]->available = true;
1569 ServicePtrs[i]->read_only = true;
1570 ServicePtrs[i]->guest_only = false;
1571 ServicePtrs[i]->administrative_share = true;
1572 ServicePtrs[i]->guest_ok = guest_ok;
1573 ServicePtrs[i]->printable = false;
1574 ServicePtrs[i]->browseable = sDefault.browseable;
1575 ServicePtrs[i]->autoloaded = true;
1577 DEBUG(3, ("adding IPC service\n"));
1579 TALLOC_FREE(comment);
1583 /***************************************************************************
1584 Add a new printer service, with defaults coming from service iFrom.
1585 ***************************************************************************/
1587 bool lp_add_printer(const char *pszPrintername, int iDefaultService)
1589 const char *comment = "From Printcap";
1590 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
1595 /* note that we do NOT default the availability flag to true - */
1596 /* we take it from the default service passed. This allows all */
1597 /* dynamic printers to be disabled by disabling the [printers] */
1598 /* entry (if/when the 'available' keyword is implemented!). */
1600 /* the printer name is set to the service name. */
1601 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->_printername,
1603 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1605 /* set the browseable flag from the gloabl default */
1606 ServicePtrs[i]->browseable = sDefault.browseable;
1608 /* Printers cannot be read_only. */
1609 ServicePtrs[i]->read_only = false;
1610 /* No oplocks on printer services. */
1611 ServicePtrs[i]->oplocks = false;
1612 /* Printer services must be printable. */
1613 ServicePtrs[i]->printable = true;
1615 DEBUG(3, ("adding printer service %s\n", pszPrintername));
1621 /***************************************************************************
1622 Check whether the given parameter name is valid.
1623 Parametric options (names containing a colon) are considered valid.
1624 ***************************************************************************/
1626 bool lp_parameter_is_valid(const char *pszParmName)
1628 return ((lpcfg_map_parameter(pszParmName) != -1) ||
1629 (strchr(pszParmName, ':') != NULL));
1632 /***************************************************************************
1633 Check whether the given name is the name of a global parameter.
1634 Returns true for strings belonging to parameters of class
1635 P_GLOBAL, false for all other strings, also for parametric options
1636 and strings not belonging to any option.
1637 ***************************************************************************/
1639 bool lp_parameter_is_global(const char *pszParmName)
1641 int num = lpcfg_map_parameter(pszParmName);
1644 return (parm_table[num].p_class == P_GLOBAL);
1650 /**************************************************************************
1651 Determine the canonical name for a parameter.
1652 Indicate when it is an inverse (boolean) synonym instead of a
1654 **************************************************************************/
1656 bool lp_canonicalize_parameter(const char *parm_name, const char **canon_parm,
1661 if (!lp_parameter_is_valid(parm_name)) {
1666 num = map_parameter_canonical(parm_name, inverse);
1668 /* parametric option */
1669 *canon_parm = parm_name;
1671 *canon_parm = parm_table[num].label;
1678 /**************************************************************************
1679 Determine the canonical name for a parameter.
1680 Turn the value given into the inverse boolean expression when
1681 the synonym is an invers boolean synonym.
1683 Return true if parm_name is a valid parameter name and
1684 in case it is an invers boolean synonym, if the val string could
1685 successfully be converted to the reverse bool.
1686 Return false in all other cases.
1687 **************************************************************************/
1689 bool lp_canonicalize_parameter_with_value(const char *parm_name,
1691 const char **canon_parm,
1692 const char **canon_val)
1697 if (!lp_parameter_is_valid(parm_name)) {
1703 num = map_parameter_canonical(parm_name, &inverse);
1705 /* parametric option */
1706 *canon_parm = parm_name;
1709 *canon_parm = parm_table[num].label;
1711 if (!lp_invert_boolean(val, canon_val)) {
1723 /***************************************************************************
1724 Map a parameter's string representation to the index of the canonical
1725 form of the parameter (it might be a synonym).
1726 Returns -1 if the parameter string is not recognised.
1727 ***************************************************************************/
1729 static int map_parameter_canonical(const char *pszParmName, bool *inverse)
1731 int parm_num, canon_num;
1732 bool loc_inverse = false;
1734 parm_num = lpcfg_map_parameter(pszParmName);
1735 if ((parm_num < 0) || !(parm_table[parm_num].flags & FLAG_SYNONYM)) {
1736 /* invalid, parametric or no canidate for synonyms ... */
1740 for (canon_num = 0; parm_table[canon_num].label; canon_num++) {
1741 if (is_synonym_of(parm_num, canon_num, &loc_inverse)) {
1742 parm_num = canon_num;
1748 if (inverse != NULL) {
1749 *inverse = loc_inverse;
1754 /***************************************************************************
1755 return true if parameter number parm1 is a synonym of parameter
1756 number parm2 (parm2 being the principal name).
1757 set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
1759 ***************************************************************************/
1761 static bool is_synonym_of(int parm1, int parm2, bool *inverse)
1763 if ((parm_table[parm1].offset == parm_table[parm2].offset) &&
1764 (parm_table[parm1].p_class == parm_table[parm2].p_class) &&
1765 (parm_table[parm1].flags & FLAG_SYNONYM) &&
1766 !(parm_table[parm2].flags & FLAG_SYNONYM))
1768 if (inverse != NULL) {
1769 if ((parm_table[parm1].type == P_BOOLREV) &&
1770 (parm_table[parm2].type == P_BOOL))
1782 /***************************************************************************
1783 Show one parameter's name, type, [values,] and flags.
1784 (helper functions for show_parameter_list)
1785 ***************************************************************************/
1787 static void show_parameter(int parmIndex)
1789 int enumIndex, flagIndex;
1794 const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
1795 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
1796 "P_ENUM", "P_BYTES", "P_CMDLIST" };
1797 unsigned flags[] = { FLAG_DEPRECATED, FLAG_SYNONYM };
1798 const char *flag_names[] = { "FLAG_DEPRECATED", "FLAG_SYNONYM", NULL};
1800 printf("%s=%s", parm_table[parmIndex].label,
1801 type[parm_table[parmIndex].type]);
1802 if (parm_table[parmIndex].type == P_ENUM) {
1805 parm_table[parmIndex].enum_list[enumIndex].name;
1809 enumIndex ? "|" : "",
1810 parm_table[parmIndex].enum_list[enumIndex].name);
1815 for (flagIndex=0; flag_names[flagIndex]; flagIndex++) {
1816 if (parm_table[parmIndex].flags & flags[flagIndex]) {
1819 flag_names[flagIndex]);
1824 /* output synonyms */
1826 for (parmIndex2=0; parm_table[parmIndex2].label; parmIndex2++) {
1827 if (is_synonym_of(parmIndex, parmIndex2, &inverse)) {
1828 printf(" (%ssynonym of %s)", inverse ? "inverse " : "",
1829 parm_table[parmIndex2].label);
1830 } else if (is_synonym_of(parmIndex2, parmIndex, &inverse)) {
1832 printf(" (synonyms: ");
1837 printf("%s%s", parm_table[parmIndex2].label,
1838 inverse ? "[i]" : "");
1848 /***************************************************************************
1849 Show all parameter's name, type, [values,] and flags.
1850 ***************************************************************************/
1852 void show_parameter_list(void)
1854 int classIndex, parmIndex;
1855 const char *section_names[] = { "local", "global", NULL};
1857 for (classIndex=0; section_names[classIndex]; classIndex++) {
1858 printf("[%s]\n", section_names[classIndex]);
1859 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
1860 if (parm_table[parmIndex].p_class == classIndex) {
1861 show_parameter(parmIndex);
1867 /***************************************************************************
1868 Get the standard string representation of a boolean value ("yes" or "no")
1869 ***************************************************************************/
1871 static const char *get_boolean(bool bool_value)
1873 static const char *yes_str = "yes";
1874 static const char *no_str = "no";
1876 return (bool_value ? yes_str : no_str);
1879 /***************************************************************************
1880 Provide the string of the negated boolean value associated to the boolean
1881 given as a string. Returns false if the passed string does not correctly
1882 represent a boolean.
1883 ***************************************************************************/
1885 bool lp_invert_boolean(const char *str, const char **inverse_str)
1889 if (!set_boolean(str, &val)) {
1893 *inverse_str = get_boolean(!val);
1897 /***************************************************************************
1898 Provide the canonical string representation of a boolean value given
1899 as a string. Return true on success, false if the string given does
1900 not correctly represent a boolean.
1901 ***************************************************************************/
1903 bool lp_canonicalize_boolean(const char *str, const char**canon_str)
1907 if (!set_boolean(str, &val)) {
1911 *canon_str = get_boolean(val);
1915 /***************************************************************************
1916 Find a service by name. Otherwise works like get_service.
1917 ***************************************************************************/
1919 int getservicebyname(const char *pszServiceName, struct loadparm_service *pserviceDest)
1926 if (ServiceHash == NULL) {
1930 canon_name = canonicalize_servicename(talloc_tos(), pszServiceName);
1932 status = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name,
1935 if (NT_STATUS_IS_OK(status) &&
1936 (data.dptr != NULL) &&
1937 (data.dsize == sizeof(iService)))
1939 iService = *(int *)data.dptr;
1942 TALLOC_FREE(canon_name);
1944 if ((iService != -1) && (LP_SNUM_OK(iService))
1945 && (pserviceDest != NULL)) {
1946 copy_service(pserviceDest, ServicePtrs[iService], NULL);
1952 /* Return a pointer to a service by name. Unlike getservicebyname, it does not copy the service */
1953 struct loadparm_service *lp_service(const char *pszServiceName)
1955 int iService = getservicebyname(pszServiceName, NULL);
1956 if (iService == -1 || !LP_SNUM_OK(iService)) {
1959 return ServicePtrs[iService];
1962 struct loadparm_service *lp_servicebynum(int snum)
1964 if ((snum == -1) || !LP_SNUM_OK(snum)) {
1967 return ServicePtrs[snum];
1970 struct loadparm_service *lp_default_loadparm_service()
1975 static struct smbconf_ctx *lp_smbconf_ctx(void)
1978 static struct smbconf_ctx *conf_ctx = NULL;
1980 if (conf_ctx == NULL) {
1981 err = smbconf_init(NULL, &conf_ctx, "registry:");
1982 if (!SBC_ERROR_IS_OK(err)) {
1983 DEBUG(1, ("error initializing registry configuration: "
1984 "%s\n", sbcErrorString(err)));
1992 static bool process_smbconf_service(struct smbconf_service *service)
1997 if (service == NULL) {
2001 ret = lp_do_section(service->name, NULL);
2005 for (count = 0; count < service->num_params; count++) {
2007 if (!bInGlobalSection && bGlobalOnly) {
2010 const char *pszParmName = service->param_names[count];
2011 const char *pszParmValue = service->param_values[count];
2013 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2015 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2016 pszParmName, pszParmValue);
2023 if (iServiceIndex >= 0) {
2024 return lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2030 * load a service from registry and activate it
2032 bool process_registry_service(const char *service_name)
2035 struct smbconf_service *service = NULL;
2036 TALLOC_CTX *mem_ctx = talloc_stackframe();
2037 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2040 if (conf_ctx == NULL) {
2044 DEBUG(5, ("process_registry_service: service name %s\n", service_name));
2046 if (!smbconf_share_exists(conf_ctx, service_name)) {
2048 * Registry does not contain data for this service (yet),
2049 * but make sure lp_load doesn't return false.
2055 err = smbconf_get_share(conf_ctx, mem_ctx, service_name, &service);
2056 if (!SBC_ERROR_IS_OK(err)) {
2060 ret = process_smbconf_service(service);
2066 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2069 TALLOC_FREE(mem_ctx);
2074 * process_registry_globals
2076 static bool process_registry_globals(void)
2080 add_to_file_list(NULL, &file_lists, INCLUDE_REGISTRY_NAME, INCLUDE_REGISTRY_NAME);
2082 if (!bInGlobalSection && bGlobalOnly) {
2085 const char *pszParmName = "registry shares";
2086 const char *pszParmValue = "yes";
2088 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2090 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2091 pszParmName, pszParmValue);
2098 return process_registry_service(GLOBAL_NAME);
2101 bool process_registry_shares(void)
2105 struct smbconf_service **service = NULL;
2106 uint32_t num_shares = 0;
2107 TALLOC_CTX *mem_ctx = talloc_stackframe();
2108 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2111 if (conf_ctx == NULL) {
2115 err = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &service);
2116 if (!SBC_ERROR_IS_OK(err)) {
2122 for (count = 0; count < num_shares; count++) {
2123 if (strequal(service[count]->name, GLOBAL_NAME)) {
2126 ret = process_smbconf_service(service[count]);
2133 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2136 TALLOC_FREE(mem_ctx);
2141 * reload those shares from registry that are already
2142 * activated in the services array.
2144 static bool reload_registry_shares(void)
2149 for (i = 0; i < iNumServices; i++) {
2154 if (ServicePtrs[i]->usershare == USERSHARE_VALID) {
2158 ret = process_registry_service(ServicePtrs[i]->szService);
2169 #define MAX_INCLUDE_DEPTH 100
2171 static uint8_t include_depth;
2174 * Free the file lists
2176 static void free_file_list(void)
2178 struct file_lists *f;
2179 struct file_lists *next;
2192 * Utility function for outsiders to check if we're running on registry.
2194 bool lp_config_backend_is_registry(void)
2196 return (lp_config_backend() == CONFIG_BACKEND_REGISTRY);
2200 * Utility function to check if the config backend is FILE.
2202 bool lp_config_backend_is_file(void)
2204 return (lp_config_backend() == CONFIG_BACKEND_FILE);
2207 /*******************************************************************
2208 Check if a config file has changed date.
2209 ********************************************************************/
2211 bool lp_file_list_changed(void)
2213 struct file_lists *f = file_lists;
2215 DEBUG(6, ("lp_file_list_changed()\n"));
2218 if (strequal(f->name, INCLUDE_REGISTRY_NAME)) {
2219 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2221 if (conf_ctx == NULL) {
2224 if (smbconf_changed(conf_ctx, &conf_last_csn, NULL,
2227 DEBUGADD(6, ("registry config changed\n"));
2234 n2 = talloc_sub_basic(talloc_tos(),
2235 get_current_username(),
2236 current_user_info.domain,
2241 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
2242 f->name, n2, ctime(&f->modtime)));
2244 mod_time = file_modtime(n2);
2247 ((f->modtime != mod_time) ||
2248 (f->subfname == NULL) ||
2249 (strcmp(n2, f->subfname) != 0)))
2252 ("file %s modified: %s\n", n2,
2254 f->modtime = mod_time;
2255 TALLOC_FREE(f->subfname);
2256 f->subfname = talloc_strdup(f, n2);
2257 if (f->subfname == NULL) {
2258 smb_panic("talloc_strdup failed");
2272 * Initialize iconv conversion descriptors.
2274 * This is called the first time it is needed, and also called again
2275 * every time the configuration is reloaded, because the charset or
2276 * codepage might have changed.
2278 static void init_iconv(void)
2280 global_iconv_handle = smb_iconv_handle_reinit(NULL, lp_dos_charset(),
2282 true, global_iconv_handle);
2285 /***************************************************************************
2286 Handle the include operation.
2287 ***************************************************************************/
2288 static bool bAllowIncludeRegistry = true;
2290 bool lp_include(struct loadparm_context *lp_ctx, struct loadparm_service *service,
2291 const char *pszParmValue, char **ptr)
2295 if (include_depth >= MAX_INCLUDE_DEPTH) {
2296 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
2301 if (strequal(pszParmValue, INCLUDE_REGISTRY_NAME)) {
2302 if (!bAllowIncludeRegistry) {
2305 if (lp_ctx->bInGlobalSection) {
2308 ret = process_registry_globals();
2312 DEBUG(1, ("\"include = registry\" only effective "
2313 "in %s section\n", GLOBAL_NAME));
2318 fname = talloc_sub_basic(talloc_tos(), get_current_username(),
2319 current_user_info.domain,
2322 add_to_file_list(NULL, &file_lists, pszParmValue, fname);
2324 if (service == NULL) {
2325 lpcfg_string_set(Globals.ctx, ptr, fname);
2327 lpcfg_string_set(service, ptr, fname);
2330 if (file_exist(fname)) {
2333 ret = pm_process(fname, lp_do_section, do_parameter, lp_ctx);
2339 DEBUG(2, ("Can't find include file %s\n", fname));
2344 bool lp_idmap_range(const char *domain_name, uint32_t *low, uint32_t *high)
2346 char *config_option = NULL;
2347 const char *range = NULL;
2350 SMB_ASSERT(low != NULL);
2351 SMB_ASSERT(high != NULL);
2353 if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2357 config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2359 if (config_option == NULL) {
2360 DEBUG(0, ("out of memory\n"));
2364 range = lp_parm_const_string(-1, config_option, "range", NULL);
2365 if (range == NULL) {
2366 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name));
2370 if (sscanf(range, "%u - %u", low, high) != 2) {
2371 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2372 range, domain_name));
2379 talloc_free(config_option);
2384 bool lp_idmap_default_range(uint32_t *low, uint32_t *high)
2386 return lp_idmap_range("*", low, high);
2389 const char *lp_idmap_backend(const char *domain_name)
2391 char *config_option = NULL;
2392 const char *backend = NULL;
2394 if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2398 config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2400 if (config_option == NULL) {
2401 DEBUG(0, ("out of memory\n"));
2405 backend = lp_parm_const_string(-1, config_option, "backend", NULL);
2406 if (backend == NULL) {
2407 DEBUG(1, ("idmap backend not specified for domain '%s'\n", domain_name));
2412 talloc_free(config_option);
2416 const char *lp_idmap_default_backend(void)
2418 return lp_idmap_backend("*");
2421 /***************************************************************************
2422 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2423 ***************************************************************************/
2425 static const char *append_ldap_suffix(TALLOC_CTX *ctx, const char *str )
2427 const char *suffix_string;
2429 suffix_string = talloc_asprintf(ctx, "%s,%s", str,
2430 Globals.ldap_suffix );
2431 if ( !suffix_string ) {
2432 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2436 return suffix_string;
2439 const char *lp_ldap_machine_suffix(TALLOC_CTX *ctx)
2441 if (Globals._ldap_machine_suffix[0])
2442 return append_ldap_suffix(ctx, Globals._ldap_machine_suffix);
2444 return lp_string(ctx, Globals.ldap_suffix);
2447 const char *lp_ldap_user_suffix(TALLOC_CTX *ctx)
2449 if (Globals._ldap_user_suffix[0])
2450 return append_ldap_suffix(ctx, Globals._ldap_user_suffix);
2452 return lp_string(ctx, Globals.ldap_suffix);
2455 const char *lp_ldap_group_suffix(TALLOC_CTX *ctx)
2457 if (Globals._ldap_group_suffix[0])
2458 return append_ldap_suffix(ctx, Globals._ldap_group_suffix);
2460 return lp_string(ctx, Globals.ldap_suffix);
2463 const char *lp_ldap_idmap_suffix(TALLOC_CTX *ctx)
2465 if (Globals._ldap_idmap_suffix[0])
2466 return append_ldap_suffix(ctx, Globals._ldap_idmap_suffix);
2468 return lp_string(ctx, Globals.ldap_suffix);
2472 return the parameter pointer for a parameter
2474 void *lp_parm_ptr(struct loadparm_service *service, struct parm_struct *parm)
2476 if (service == NULL) {
2477 if (parm->p_class == P_LOCAL)
2478 return (void *)(((char *)&sDefault)+parm->offset);
2479 else if (parm->p_class == P_GLOBAL)
2480 return (void *)(((char *)&Globals)+parm->offset);
2483 return (void *)(((char *)service) + parm->offset);
2487 /***************************************************************************
2488 Process a parameter for a particular service number. If snum < 0
2489 then assume we are in the globals.
2490 ***************************************************************************/
2492 bool lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
2494 TALLOC_CTX *frame = talloc_stackframe();
2495 struct loadparm_context *lp_ctx;
2498 lp_ctx = setup_lp_context(frame);
2499 if (lp_ctx == NULL) {
2505 ok = lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue);
2507 ok = lpcfg_do_service_parameter(lp_ctx, ServicePtrs[snum],
2508 pszParmName, pszParmValue);
2516 /***************************************************************************
2517 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
2518 FLAG_CMDLINE won't be overridden by loads from smb.conf.
2519 ***************************************************************************/
2521 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue)
2524 parmnum = lpcfg_map_parameter(pszParmName);
2526 flags_list[parmnum] &= ~FLAG_CMDLINE;
2527 if (!lp_do_parameter(-1, pszParmName, pszParmValue)) {
2530 flags_list[parmnum] |= FLAG_CMDLINE;
2532 /* we have to also set FLAG_CMDLINE on aliases. Aliases must
2533 * be grouped in the table, so we don't have to search the
2536 i>=0 && parm_table[i].offset == parm_table[parmnum].offset
2537 && parm_table[i].p_class == parm_table[parmnum].p_class;
2539 flags_list[i] |= FLAG_CMDLINE;
2541 for (i=parmnum+1;i<num_parameters() && parm_table[i].offset == parm_table[parmnum].offset
2542 && parm_table[i].p_class == parm_table[parmnum].p_class;i++) {
2543 flags_list[i] |= FLAG_CMDLINE;
2549 /* it might be parametric */
2550 if (strchr(pszParmName, ':') != NULL) {
2551 set_param_opt(NULL, &Globals.param_opt, pszParmName, pszParmValue, FLAG_CMDLINE);
2555 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
2559 bool lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
2562 TALLOC_CTX *frame = talloc_stackframe();
2563 struct loadparm_context *lp_ctx;
2565 lp_ctx = setup_lp_context(frame);
2566 if (lp_ctx == NULL) {
2571 ret = lpcfg_set_cmdline(lp_ctx, pszParmName, pszParmValue);
2577 /***************************************************************************
2578 Process a parameter.
2579 ***************************************************************************/
2581 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
2584 if (!bInGlobalSection && bGlobalOnly)
2587 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2589 if (bInGlobalSection) {
2590 return lpcfg_do_global_parameter(userdata, pszParmName, pszParmValue);
2592 return lpcfg_do_service_parameter(userdata, ServicePtrs[iServiceIndex],
2593 pszParmName, pszParmValue);
2597 /***************************************************************************
2598 Initialize any local variables in the sDefault table, after parsing a
2600 ***************************************************************************/
2602 static void init_locals(void)
2605 * We run this check once the [globals] is parsed, to force
2606 * the VFS objects and other per-share settings we need for
2607 * the standard way a AD DC is operated. We may change these
2608 * as our code evolves, which is why we force these settings.
2610 * We can't do this at the end of lp_load_ex(), as by that
2611 * point the services have been loaded and they will already
2612 * have "" as their vfs objects.
2614 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
2615 const char **vfs_objects = lp_vfs_objects(-1);
2616 if (!vfs_objects || !vfs_objects[0]) {
2617 if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL)) {
2618 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
2619 } else if (lp_parm_const_string(-1, "posix", "eadb", NULL)) {
2620 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
2622 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
2626 lp_do_parameter(-1, "map hidden", "no");
2627 lp_do_parameter(-1, "map system", "no");
2628 lp_do_parameter(-1, "map readonly", "no");
2629 lp_do_parameter(-1, "map archive", "no");
2630 lp_do_parameter(-1, "store dos attributes", "yes");
2634 /***************************************************************************
2635 Process a new section (service). At this stage all sections are services.
2636 Later we'll have special sections that permit server parameters to be set.
2637 Returns true on success, false on failure.
2638 ***************************************************************************/
2640 bool lp_do_section(const char *pszSectionName, void *userdata)
2642 struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
2644 bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
2645 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
2648 /* if we were in a global section then do the local inits */
2649 if (bInGlobalSection && !isglobal)
2652 /* if we've just struck a global section, note the fact. */
2653 bInGlobalSection = isglobal;
2654 if (lp_ctx != NULL) {
2655 lp_ctx->bInGlobalSection = isglobal;
2658 /* check for multiple global sections */
2659 if (bInGlobalSection) {
2660 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
2664 if (!bInGlobalSection && bGlobalOnly)
2667 /* if we have a current service, tidy it up before moving on */
2670 if (iServiceIndex >= 0)
2671 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2673 /* if all is still well, move to the next record in the services array */
2675 /* We put this here to avoid an odd message order if messages are */
2676 /* issued by the post-processing of a previous section. */
2677 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
2679 iServiceIndex = add_a_service(&sDefault, pszSectionName);
2680 if (iServiceIndex < 0) {
2681 DEBUG(0, ("Failed to add a new service\n"));
2684 /* Clean all parametric options for service */
2685 /* They will be added during parsing again */
2686 free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
2692 /***************************************************************************
2693 Display the contents of a parameter of a single services record.
2694 ***************************************************************************/
2696 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
2698 bool result = false;
2699 struct loadparm_context *lp_ctx;
2701 lp_ctx = setup_lp_context(talloc_tos());
2702 if (lp_ctx == NULL) {
2707 result = lpcfg_dump_a_parameter(lp_ctx, NULL, parm_name, f);
2709 result = lpcfg_dump_a_parameter(lp_ctx, ServicePtrs[snum], parm_name, f);
2711 TALLOC_FREE(lp_ctx);
2716 /***************************************************************************
2717 Display the contents of a single copy structure.
2718 ***************************************************************************/
2719 static void dump_copy_map(bool *pcopymap)
2725 printf("\n\tNon-Copied parameters:\n");
2727 for (i = 0; parm_table[i].label; i++)
2728 if (parm_table[i].p_class == P_LOCAL &&
2729 parm_table[i].ptr && !pcopymap[i] &&
2730 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
2732 printf("\t\t%s\n", parm_table[i].label);
2737 /***************************************************************************
2738 Return TRUE if the passed service number is within range.
2739 ***************************************************************************/
2741 bool lp_snum_ok(int iService)
2743 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->available);
2746 /***************************************************************************
2747 Auto-load some home services.
2748 ***************************************************************************/
2750 static void lp_add_auto_services(char *str)
2760 s = talloc_strdup(talloc_tos(), str);
2762 smb_panic("talloc_strdup failed");
2766 homes = lp_servicenumber(HOMES_NAME);
2768 for (p = strtok_r(s, LIST_SEP, &saveptr); p;
2769 p = strtok_r(NULL, LIST_SEP, &saveptr)) {
2772 if (lp_servicenumber(p) >= 0)
2775 home = get_user_home_dir(talloc_tos(), p);
2777 if (home && home[0] && homes >= 0)
2778 lp_add_home(p, homes, p, home);
2785 /***************************************************************************
2786 Auto-load one printer.
2787 ***************************************************************************/
2789 void lp_add_one_printer(const char *name, const char *comment,
2790 const char *location, void *pdata)
2792 int printers = lp_servicenumber(PRINTERS_NAME);
2795 if (lp_servicenumber(name) < 0) {
2796 lp_add_printer(name, printers);
2797 if ((i = lp_servicenumber(name)) >= 0) {
2798 lpcfg_string_set(ServicePtrs[i],
2799 &ServicePtrs[i]->comment, comment);
2800 ServicePtrs[i]->autoloaded = true;
2805 /***************************************************************************
2806 Have we loaded a services file yet?
2807 ***************************************************************************/
2809 bool lp_loaded(void)
2814 /***************************************************************************
2815 Unload unused services.
2816 ***************************************************************************/
2818 void lp_killunused(struct smbd_server_connection *sconn,
2819 bool (*snumused) (struct smbd_server_connection *, int))
2822 for (i = 0; i < iNumServices; i++) {
2826 /* don't kill autoloaded or usershare services */
2827 if ( ServicePtrs[i]->autoloaded ||
2828 ServicePtrs[i]->usershare == USERSHARE_VALID) {
2832 if (!snumused || !snumused(sconn, i)) {
2833 free_service_byindex(i);
2839 * Kill all except autoloaded and usershare services - convenience wrapper
2841 void lp_kill_all_services(void)
2843 lp_killunused(NULL, NULL);
2846 /***************************************************************************
2848 ***************************************************************************/
2850 void lp_killservice(int iServiceIn)
2852 if (VALID(iServiceIn)) {
2853 free_service_byindex(iServiceIn);
2857 /***************************************************************************
2858 Save the curent values of all global and sDefault parameters into the
2859 defaults union. This allows testparm to show only the
2860 changed (ie. non-default) parameters.
2861 ***************************************************************************/
2863 static void lp_save_defaults(void)
2866 struct parmlist_entry * parm;
2867 for (i = 0; parm_table[i].label; i++) {
2868 if (!(flags_list[i] & FLAG_CMDLINE)) {
2869 flags_list[i] |= FLAG_DEFAULT;
2872 if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
2873 && parm_table[i].p_class == parm_table[i - 1].p_class)
2875 switch (parm_table[i].type) {
2878 parm_table[i].def.lvalue = str_list_copy(
2879 NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
2885 &parm_table[i].def.svalue,
2886 *(char **)lp_parm_ptr(
2887 NULL, &parm_table[i]));
2888 if (parm_table[i].def.svalue == NULL) {
2889 smb_panic("lpcfg_string_set() failed");
2894 parm_table[i].def.bvalue =
2895 *(bool *)lp_parm_ptr(NULL, &parm_table[i]);
2898 parm_table[i].def.cvalue =
2899 *(char *)lp_parm_ptr(NULL, &parm_table[i]);
2905 parm_table[i].def.ivalue =
2906 *(int *)lp_parm_ptr(NULL, &parm_table[i]);
2911 for (parm=Globals.param_opt; parm; parm=parm->next) {
2912 if (!(parm->priority & FLAG_CMDLINE)) {
2913 parm->priority |= FLAG_DEFAULT;
2917 for (parm=sDefault.param_opt; parm; parm=parm->next) {
2918 if (!(parm->priority & FLAG_CMDLINE)) {
2919 parm->priority |= FLAG_DEFAULT;
2923 defaults_saved = true;
2926 /***********************************************************
2927 If we should send plaintext/LANMAN passwords in the clinet
2928 ************************************************************/
2930 static void set_allowed_client_auth(void)
2932 if (Globals.client_ntlmv2_auth) {
2933 Globals.client_lanman_auth = false;
2935 if (!Globals.client_lanman_auth) {
2936 Globals.client_plaintext_auth = false;
2940 /***************************************************************************
2942 The following code allows smbd to read a user defined share file.
2943 Yes, this is my intent. Yes, I'm comfortable with that...
2945 THE FOLLOWING IS SECURITY CRITICAL CODE.
2947 It washes your clothes, it cleans your house, it guards you while you sleep...
2948 Do not f%^k with it....
2949 ***************************************************************************/
2951 #define MAX_USERSHARE_FILE_SIZE (10*1024)
2953 /***************************************************************************
2954 Check allowed stat state of a usershare file.
2955 Ensure we print out who is dicking with us so the admin can
2956 get their sorry ass fired.
2957 ***************************************************************************/
2959 static bool check_usershare_stat(const char *fname,
2960 const SMB_STRUCT_STAT *psbuf)
2962 if (!S_ISREG(psbuf->st_ex_mode)) {
2963 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
2964 "not a regular file\n",
2965 fname, (unsigned int)psbuf->st_ex_uid ));
2969 /* Ensure this doesn't have the other write bit set. */
2970 if (psbuf->st_ex_mode & S_IWOTH) {
2971 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
2972 "public write. Refusing to allow as a usershare file.\n",
2973 fname, (unsigned int)psbuf->st_ex_uid ));
2977 /* Should be 10k or less. */
2978 if (psbuf->st_ex_size > MAX_USERSHARE_FILE_SIZE) {
2979 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
2980 "too large (%u) to be a user share file.\n",
2981 fname, (unsigned int)psbuf->st_ex_uid,
2982 (unsigned int)psbuf->st_ex_size ));
2989 /***************************************************************************
2990 Parse the contents of a usershare file.
2991 ***************************************************************************/
2993 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
2994 SMB_STRUCT_STAT *psbuf,
2995 const char *servicename,
2999 char **pp_sharepath,
3001 char **pp_cp_servicename,
3002 struct security_descriptor **ppsd,
3005 const char **prefixallowlist = lp_usershare_prefix_allow_list();
3006 const char **prefixdenylist = lp_usershare_prefix_deny_list();
3009 SMB_STRUCT_STAT sbuf;
3010 char *sharepath = NULL;
3011 char *comment = NULL;
3013 *pp_sharepath = NULL;
3016 *pallow_guest = false;
3019 return USERSHARE_MALFORMED_FILE;
3022 if (strcmp(lines[0], "#VERSION 1") == 0) {
3024 } else if (strcmp(lines[0], "#VERSION 2") == 0) {
3027 return USERSHARE_MALFORMED_FILE;
3030 return USERSHARE_BAD_VERSION;
3033 if (strncmp(lines[1], "path=", 5) != 0) {
3034 return USERSHARE_MALFORMED_PATH;
3037 sharepath = talloc_strdup(ctx, &lines[1][5]);
3039 return USERSHARE_POSIX_ERR;
3041 trim_string(sharepath, " ", " ");
3043 if (strncmp(lines[2], "comment=", 8) != 0) {
3044 return USERSHARE_MALFORMED_COMMENT_DEF;
3047 comment = talloc_strdup(ctx, &lines[2][8]);
3049 return USERSHARE_POSIX_ERR;
3051 trim_string(comment, " ", " ");
3052 trim_char(comment, '"', '"');
3054 if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
3055 return USERSHARE_MALFORMED_ACL_DEF;
3058 if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
3059 return USERSHARE_ACL_ERR;
3063 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
3064 return USERSHARE_MALFORMED_ACL_DEF;
3066 if (lines[4][9] == 'y') {
3067 *pallow_guest = true;
3070 /* Backwards compatible extension to file version #2. */
3072 if (strncmp(lines[5], "sharename=", 10) != 0) {
3073 return USERSHARE_MALFORMED_SHARENAME_DEF;
3075 if (!strequal(&lines[5][10], servicename)) {
3076 return USERSHARE_BAD_SHARENAME;
3078 *pp_cp_servicename = talloc_strdup(ctx, &lines[5][10]);
3079 if (!*pp_cp_servicename) {
3080 return USERSHARE_POSIX_ERR;
3085 if (*pp_cp_servicename == NULL) {
3086 *pp_cp_servicename = talloc_strdup(ctx, servicename);
3087 if (!*pp_cp_servicename) {
3088 return USERSHARE_POSIX_ERR;
3092 if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->path) == 0)) {
3093 /* Path didn't change, no checks needed. */
3094 *pp_sharepath = sharepath;
3095 *pp_comment = comment;
3096 return USERSHARE_OK;
3099 /* The path *must* be absolute. */
3100 if (sharepath[0] != '/') {
3101 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
3102 servicename, sharepath));
3103 return USERSHARE_PATH_NOT_ABSOLUTE;
3106 /* If there is a usershare prefix deny list ensure one of these paths
3107 doesn't match the start of the user given path. */
3108 if (prefixdenylist) {
3110 for ( i=0; prefixdenylist[i]; i++ ) {
3111 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
3112 servicename, i, prefixdenylist[i], sharepath ));
3113 if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
3114 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
3115 "usershare prefix deny list entries.\n",
3116 servicename, sharepath));
3117 return USERSHARE_PATH_IS_DENIED;
3122 /* If there is a usershare prefix allow list ensure one of these paths
3123 does match the start of the user given path. */
3125 if (prefixallowlist) {
3127 for ( i=0; prefixallowlist[i]; i++ ) {
3128 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
3129 servicename, i, prefixallowlist[i], sharepath ));
3130 if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
3134 if (prefixallowlist[i] == NULL) {
3135 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
3136 "usershare prefix allow list entries.\n",
3137 servicename, sharepath));
3138 return USERSHARE_PATH_NOT_ALLOWED;
3142 /* Ensure this is pointing to a directory. */
3143 dp = opendir(sharepath);
3146 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3147 servicename, sharepath));
3148 return USERSHARE_PATH_NOT_DIRECTORY;
3151 /* Ensure the owner of the usershare file has permission to share
3154 if (sys_stat(sharepath, &sbuf, false) == -1) {
3155 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
3156 servicename, sharepath, strerror(errno) ));
3158 return USERSHARE_POSIX_ERR;
3163 if (!S_ISDIR(sbuf.st_ex_mode)) {
3164 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3165 servicename, sharepath ));
3166 return USERSHARE_PATH_NOT_DIRECTORY;
3169 /* Check if sharing is restricted to owner-only. */
3170 /* psbuf is the stat of the usershare definition file,
3171 sbuf is the stat of the target directory to be shared. */
3173 if (lp_usershare_owner_only()) {
3174 /* root can share anything. */
3175 if ((psbuf->st_ex_uid != 0) && (sbuf.st_ex_uid != psbuf->st_ex_uid)) {
3176 return USERSHARE_PATH_NOT_ALLOWED;
3180 *pp_sharepath = sharepath;
3181 *pp_comment = comment;
3182 return USERSHARE_OK;
3185 /***************************************************************************
3186 Deal with a usershare file.
3189 -1 - Bad name, invalid contents.
3190 - service name already existed and not a usershare, problem
3191 with permissions to share directory etc.
3192 ***************************************************************************/
3194 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
3196 SMB_STRUCT_STAT sbuf;
3197 SMB_STRUCT_STAT lsbuf;
3199 char *sharepath = NULL;
3200 char *comment = NULL;
3201 char *cp_service_name = NULL;
3202 char **lines = NULL;
3206 TALLOC_CTX *ctx = talloc_stackframe();
3207 struct security_descriptor *psd = NULL;
3208 bool guest_ok = false;
3209 char *canon_name = NULL;
3210 bool added_service = false;
3213 /* Ensure share name doesn't contain invalid characters. */
3214 if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
3215 DEBUG(0,("process_usershare_file: share name %s contains "
3216 "invalid characters (any of %s)\n",
3217 file_name, INVALID_SHARENAME_CHARS ));
3221 canon_name = canonicalize_servicename(ctx, file_name);
3226 fname = talloc_asprintf(ctx, "%s/%s", dir_name, file_name);
3231 /* Minimize the race condition by doing an lstat before we
3232 open and fstat. Ensure this isn't a symlink link. */
3234 if (sys_lstat(fname, &lsbuf, false) != 0) {
3235 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
3236 fname, strerror(errno) ));
3240 /* This must be a regular file, not a symlink, directory or
3241 other strange filetype. */
3242 if (!check_usershare_stat(fname, &lsbuf)) {
3250 status = dbwrap_fetch_bystring(ServiceHash, canon_name,
3255 if (NT_STATUS_IS_OK(status) &&
3256 (data.dptr != NULL) &&
3257 (data.dsize == sizeof(iService))) {
3258 memcpy(&iService, data.dptr, sizeof(iService));
3262 if (iService != -1 &&
3263 timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
3264 &lsbuf.st_ex_mtime) == 0) {
3265 /* Nothing changed - Mark valid and return. */
3266 DEBUG(10,("process_usershare_file: service %s not changed.\n",
3268 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3273 /* Try and open the file read only - no symlinks allowed. */
3275 fd = open(fname, O_RDONLY|O_NOFOLLOW, 0);
3277 fd = open(fname, O_RDONLY, 0);
3281 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
3282 fname, strerror(errno) ));
3286 /* Now fstat to be *SURE* it's a regular file. */
3287 if (sys_fstat(fd, &sbuf, false) != 0) {
3289 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
3290 fname, strerror(errno) ));
3294 /* Is it the same dev/inode as was lstated ? */
3295 if (!check_same_stat(&lsbuf, &sbuf)) {
3297 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
3298 "Symlink spoofing going on ?\n", fname ));
3302 /* This must be a regular file, not a symlink, directory or
3303 other strange filetype. */
3304 if (!check_usershare_stat(fname, &sbuf)) {
3309 lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE, NULL);
3312 if (lines == NULL) {
3313 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
3314 fname, (unsigned int)sbuf.st_ex_uid ));
3318 if (parse_usershare_file(ctx, &sbuf, file_name,
3319 iService, lines, numlines, &sharepath,
3320 &comment, &cp_service_name,
3321 &psd, &guest_ok) != USERSHARE_OK) {
3325 /* Everything ok - add the service possibly using a template. */
3327 const struct loadparm_service *sp = &sDefault;
3328 if (snum_template != -1) {
3329 sp = ServicePtrs[snum_template];
3332 if ((iService = add_a_service(sp, cp_service_name)) < 0) {
3333 DEBUG(0, ("process_usershare_file: Failed to add "
3334 "new service %s\n", cp_service_name));
3338 added_service = true;
3340 /* Read only is controlled by usershare ACL below. */
3341 ServicePtrs[iService]->read_only = false;
3344 /* Write the ACL of the new/modified share. */
3345 if (!set_share_security(canon_name, psd)) {
3346 DEBUG(0, ("process_usershare_file: Failed to set share "
3347 "security for user share %s\n",
3352 /* If from a template it may be marked invalid. */
3353 ServicePtrs[iService]->valid = true;
3355 /* Set the service as a valid usershare. */
3356 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3358 /* Set guest access. */
3359 if (lp_usershare_allow_guests()) {
3360 ServicePtrs[iService]->guest_ok = guest_ok;
3363 /* And note when it was loaded. */
3364 ServicePtrs[iService]->usershare_last_mod = sbuf.st_ex_mtime;
3365 lpcfg_string_set(ServicePtrs[iService], &ServicePtrs[iService]->path,
3367 lpcfg_string_set(ServicePtrs[iService],
3368 &ServicePtrs[iService]->comment, comment);
3374 if (ret == -1 && iService != -1 && added_service) {
3375 lp_remove_service(iService);
3383 /***************************************************************************
3384 Checks if a usershare entry has been modified since last load.
3385 ***************************************************************************/
3387 static bool usershare_exists(int iService, struct timespec *last_mod)
3389 SMB_STRUCT_STAT lsbuf;
3390 const char *usersharepath = Globals.usershare_path;
3393 fname = talloc_asprintf(talloc_tos(),
3396 ServicePtrs[iService]->szService);
3397 if (fname == NULL) {
3401 if (sys_lstat(fname, &lsbuf, false) != 0) {
3406 if (!S_ISREG(lsbuf.st_ex_mode)) {
3412 *last_mod = lsbuf.st_ex_mtime;
3416 /***************************************************************************
3417 Load a usershare service by name. Returns a valid servicenumber or -1.
3418 ***************************************************************************/
3420 int load_usershare_service(const char *servicename)
3422 SMB_STRUCT_STAT sbuf;
3423 const char *usersharepath = Globals.usershare_path;
3424 int max_user_shares = Globals.usershare_max_shares;
3425 int snum_template = -1;
3427 if (*usersharepath == 0 || max_user_shares == 0) {
3431 if (sys_stat(usersharepath, &sbuf, false) != 0) {
3432 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
3433 usersharepath, strerror(errno) ));
3437 if (!S_ISDIR(sbuf.st_ex_mode)) {
3438 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
3444 * This directory must be owned by root, and have the 't' bit set.
3445 * It also must not be writable by "other".
3449 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3451 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3453 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
3454 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3459 /* Ensure the template share exists if it's set. */
3460 if (Globals.usershare_template_share[0]) {
3461 /* We can't use lp_servicenumber here as we are recommending that
3462 template shares have -valid=false set. */
3463 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3464 if (ServicePtrs[snum_template]->szService &&
3465 strequal(ServicePtrs[snum_template]->szService,
3466 Globals.usershare_template_share)) {
3471 if (snum_template == -1) {
3472 DEBUG(0,("load_usershare_service: usershare template share %s "
3473 "does not exist.\n",
3474 Globals.usershare_template_share ));
3479 return process_usershare_file(usersharepath, servicename, snum_template);
3482 /***************************************************************************
3483 Load all user defined shares from the user share directory.
3484 We only do this if we're enumerating the share list.
3485 This is the function that can delete usershares that have
3487 ***************************************************************************/
3489 int load_usershare_shares(struct smbd_server_connection *sconn,
3490 bool (*snumused) (struct smbd_server_connection *, int))
3493 SMB_STRUCT_STAT sbuf;
3495 int num_usershares = 0;
3496 int max_user_shares = Globals.usershare_max_shares;
3497 unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
3498 unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
3499 unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
3501 int snum_template = -1;
3502 const char *usersharepath = Globals.usershare_path;
3503 int ret = lp_numservices();
3504 TALLOC_CTX *tmp_ctx;
3506 if (max_user_shares == 0 || *usersharepath == '\0') {
3507 return lp_numservices();
3510 if (sys_stat(usersharepath, &sbuf, false) != 0) {
3511 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
3512 usersharepath, strerror(errno) ));
3517 * This directory must be owned by root, and have the 't' bit set.
3518 * It also must not be writable by "other".
3522 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3524 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3526 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
3527 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3532 /* Ensure the template share exists if it's set. */
3533 if (Globals.usershare_template_share[0]) {
3534 /* We can't use lp_servicenumber here as we are recommending that
3535 template shares have -valid=false set. */
3536 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3537 if (ServicePtrs[snum_template]->szService &&
3538 strequal(ServicePtrs[snum_template]->szService,
3539 Globals.usershare_template_share)) {
3544 if (snum_template == -1) {
3545 DEBUG(0,("load_usershare_shares: usershare template share %s "
3546 "does not exist.\n",
3547 Globals.usershare_template_share ));
3552 /* Mark all existing usershares as pending delete. */
3553 for (iService = iNumServices - 1; iService >= 0; iService--) {
3554 if (VALID(iService) && ServicePtrs[iService]->usershare) {
3555 ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
3559 dp = opendir(usersharepath);
3561 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
3562 usersharepath, strerror(errno) ));
3566 for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
3568 num_dir_entries++ ) {
3570 const char *n = de->d_name;
3572 /* Ignore . and .. */
3574 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
3580 /* Temporary file used when creating a share. */
3581 num_tmp_dir_entries++;
3584 /* Allow 20% tmp entries. */
3585 if (num_tmp_dir_entries > allowed_tmp_entries) {
3586 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
3587 "in directory %s\n",
3588 num_tmp_dir_entries, usersharepath));
3592 r = process_usershare_file(usersharepath, n, snum_template);
3594 /* Update the services count. */
3596 if (num_usershares >= max_user_shares) {
3597 DEBUG(0,("load_usershare_shares: max user shares reached "
3598 "on file %s in directory %s\n",
3599 n, usersharepath ));
3602 } else if (r == -1) {
3603 num_bad_dir_entries++;
3606 /* Allow 20% bad entries. */
3607 if (num_bad_dir_entries > allowed_bad_entries) {
3608 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
3609 "in directory %s\n",
3610 num_bad_dir_entries, usersharepath));
3614 /* Allow 20% bad entries. */
3615 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
3616 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
3617 "in directory %s\n",
3618 num_dir_entries, usersharepath));
3625 /* Sweep through and delete any non-refreshed usershares that are
3626 not currently in use. */
3627 tmp_ctx = talloc_stackframe();
3628 for (iService = iNumServices - 1; iService >= 0; iService--) {
3629 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
3632 if (snumused && snumused(sconn, iService)) {
3636 servname = lp_servicename(tmp_ctx, iService);
3638 /* Remove from the share ACL db. */
3639 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
3641 delete_share_security(servname);
3642 free_service_byindex(iService);
3645 talloc_free(tmp_ctx);
3647 return lp_numservices();
3650 /********************************************************
3651 Destroy global resources allocated in this file
3652 ********************************************************/
3654 void gfree_loadparm(void)
3660 /* Free resources allocated to services */
3662 for ( i = 0; i < iNumServices; i++ ) {
3664 free_service_byindex(i);
3668 TALLOC_FREE( ServicePtrs );
3671 /* Now release all resources allocated to global
3672 parameters and the default service */
3674 free_global_parameters();
3678 /***************************************************************************
3679 Allow client apps to specify that they are a client
3680 ***************************************************************************/
3681 static void lp_set_in_client(bool b)
3687 /***************************************************************************
3688 Determine if we're running in a client app
3689 ***************************************************************************/
3690 static bool lp_is_in_client(void)
3695 static void lp_enforce_ad_dc_settings(void)
3697 lp_do_parameter(GLOBAL_SECTION_SNUM, "passdb backend", "samba_dsdb");
3698 lp_do_parameter(GLOBAL_SECTION_SNUM,
3699 "winbindd:use external pipes", "true");
3700 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:default", "external");
3701 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:svcctl", "embedded");
3702 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:srvsvc", "embedded");
3703 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:eventlog", "embedded");
3704 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:ntsvcs", "embedded");
3705 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:winreg", "embedded");
3706 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:spoolss", "embedded");
3707 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_daemon:spoolssd", "embedded");
3708 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:tcpip", "no");
3711 /***************************************************************************
3712 Load the services array from the services file. Return true on success,
3714 ***************************************************************************/
3716 static bool lp_load_ex(const char *pszFname,
3720 bool reinit_globals,
3721 bool allow_include_registry,
3722 bool load_all_shares)
3726 TALLOC_CTX *frame = talloc_stackframe();
3727 struct loadparm_context *lp_ctx;
3731 DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
3733 bInGlobalSection = true;
3734 bGlobalOnly = global_only;
3735 bAllowIncludeRegistry = allow_include_registry;
3737 lp_ctx = setup_lp_context(talloc_tos());
3739 init_globals(lp_ctx, reinit_globals);
3743 if (save_defaults) {
3748 if (!reinit_globals) {
3749 free_param_opts(&Globals.param_opt);
3750 apply_lp_set_cmdline();
3753 lp_do_parameter(-1, "idmap config * : backend", Globals.idmap_backend);
3755 /* We get sections first, so have to start 'behind' to make up */
3758 if (lp_config_backend_is_file()) {
3759 n2 = talloc_sub_basic(talloc_tos(), get_current_username(),
3760 current_user_info.domain,
3763 smb_panic("lp_load_ex: out of memory");
3766 add_to_file_list(NULL, &file_lists, pszFname, n2);
3768 bRetval = pm_process(n2, lp_do_section, do_parameter, lp_ctx);
3771 /* finish up the last section */
3772 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
3774 if (iServiceIndex >= 0) {
3775 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
3779 if (lp_config_backend_is_registry()) {
3781 /* config backend changed to registry in config file */
3783 * We need to use this extra global variable here to
3784 * survive restart: init_globals uses this as a default
3785 * for config_backend. Otherwise, init_globals would
3786 * send us into an endless loop here.
3789 config_backend = CONFIG_BACKEND_REGISTRY;
3791 DEBUG(1, ("lp_load_ex: changing to config backend "
3793 init_globals(lp_ctx, true);
3795 TALLOC_FREE(lp_ctx);
3797 lp_kill_all_services();
3798 ok = lp_load_ex(pszFname, global_only, save_defaults,
3799 add_ipc, reinit_globals,
3800 allow_include_registry,
3805 } else if (lp_config_backend_is_registry()) {
3806 bRetval = process_registry_globals();
3808 DEBUG(0, ("Illegal config backend given: %d\n",
3809 lp_config_backend()));
3813 if (bRetval && lp_registry_shares()) {
3814 if (load_all_shares) {
3815 bRetval = process_registry_shares();
3817 bRetval = reload_registry_shares();
3822 char *serv = lp_auto_services(talloc_tos());
3823 lp_add_auto_services(serv);
3828 /* When 'restrict anonymous = 2' guest connections to ipc$
3830 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
3831 if ( lp_enable_asu_support() ) {
3832 lp_add_ipc("ADMIN$", false);
3836 set_allowed_client_auth();
3838 if (lp_security() == SEC_ADS && strchr(lp_password_server(), ':')) {
3839 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
3840 lp_password_server()));
3845 /* Now we check we_are_a_wins_server and set szWINSserver to 127.0.0.1 */
3846 /* if we_are_a_wins_server is true and we are in the client */
3847 if (lp_is_in_client() && Globals.we_are_a_wins_server) {
3848 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
3853 fault_configure(smb_panic_s3);
3856 * We run this check once the whole smb.conf is parsed, to
3857 * force some settings for the standard way a AD DC is
3858 * operated. We may change these as our code evolves, which
3859 * is why we force these settings.
3861 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
3862 lp_enforce_ad_dc_settings();
3865 bAllowIncludeRegistry = true;
3871 static bool lp_load(const char *pszFname,
3875 bool reinit_globals)
3877 return lp_load_ex(pszFname,
3882 true, /* allow_include_registry */
3883 false); /* load_all_shares*/
3886 bool lp_load_initial_only(const char *pszFname)
3888 return lp_load_ex(pszFname,
3889 true, /* global only */
3890 true, /* save_defaults */
3891 false, /* add_ipc */
3892 true, /* reinit_globals */
3893 false, /* allow_include_registry */
3894 false); /* load_all_shares*/
3898 * most common lp_load wrapper, loading only the globals
3900 bool lp_load_global(const char *file_name)
3902 return lp_load(file_name,
3903 true, /* global_only */
3904 false, /* save_defaults */
3905 false, /* add_ipc */
3906 true); /* reinit_globals */
3910 * The typical lp_load wrapper with shares, loads global and
3911 * shares, including IPC, but does not force immediate
3912 * loading of all shares from registry.
3914 bool lp_load_with_shares(const char *file_name)
3916 return lp_load(file_name,
3917 false, /* global_only */
3918 false, /* save_defaults */
3920 true); /* reinit_globals */
3924 * lp_load wrapper, especially for clients
3926 bool lp_load_client(const char *file_name)
3928 lp_set_in_client(true);
3930 return lp_load_global(file_name);
3934 * lp_load wrapper, loading only globals, but intended
3935 * for subsequent calls, not reinitializing the globals
3938 bool lp_load_global_no_reinit(const char *file_name)
3940 return lp_load(file_name,
3941 true, /* global_only */
3942 false, /* save_defaults */
3943 false, /* add_ipc */
3944 false); /* reinit_globals */
3948 * lp_load wrapper, loading globals and shares,
3949 * intended for subsequent calls, i.e. not reinitializing
3950 * the globals to default values.
3952 bool lp_load_no_reinit(const char *file_name)
3954 return lp_load(file_name,
3955 false, /* global_only */
3956 false, /* save_defaults */
3957 false, /* add_ipc */
3958 false); /* reinit_globals */
3963 * lp_load wrapper, especially for clients, no reinitialization
3965 bool lp_load_client_no_reinit(const char *file_name)
3967 lp_set_in_client(true);
3969 return lp_load_global_no_reinit(file_name);
3972 bool lp_load_with_registry_shares(const char *pszFname)
3974 return lp_load_ex(pszFname,
3975 false, /* global_only */
3976 true, /* save_defaults */
3977 false, /* add_ipc */
3978 false, /* reinit_globals */
3979 true, /* allow_include_registry */
3980 true); /* load_all_shares*/
3983 /***************************************************************************
3984 Return the max number of services.
3985 ***************************************************************************/
3987 int lp_numservices(void)
3989 return (iNumServices);
3992 /***************************************************************************
3993 Display the contents of the services array in human-readable form.
3994 ***************************************************************************/
3996 void lp_dump(FILE *f, bool show_defaults, int maxtoprint)
3999 struct loadparm_context *lp_ctx;
4002 defaults_saved = false;
4004 lp_ctx = setup_lp_context(talloc_tos());
4005 if (lp_ctx == NULL) {
4009 lpcfg_dump_globals(lp_ctx, f, !defaults_saved);
4011 lpcfg_dump_a_service(&sDefault, &sDefault, f, flags_list, show_defaults);
4013 for (iService = 0; iService < maxtoprint; iService++) {
4015 lp_dump_one(f, show_defaults, iService);
4019 /***************************************************************************
4020 Display the contents of one service in human-readable form.
4021 ***************************************************************************/
4023 void lp_dump_one(FILE * f, bool show_defaults, int snum)
4026 if (ServicePtrs[snum]->szService[0] == '\0')
4028 lpcfg_dump_a_service(ServicePtrs[snum], &sDefault, f,
4029 flags_list, show_defaults);
4033 /***************************************************************************
4034 Return the number of the service with the given name, or -1 if it doesn't
4035 exist. Note that this is a DIFFERENT ANIMAL from the internal function
4036 getservicebyname()! This works ONLY if all services have been loaded, and
4037 does not copy the found service.
4038 ***************************************************************************/
4040 int lp_servicenumber(const char *pszServiceName)
4043 fstring serviceName;
4045 if (!pszServiceName) {
4046 return GLOBAL_SECTION_SNUM;
4049 for (iService = iNumServices - 1; iService >= 0; iService--) {
4050 if (VALID(iService) && ServicePtrs[iService]->szService) {
4052 * The substitution here is used to support %U in
4055 fstrcpy(serviceName, ServicePtrs[iService]->szService);
4056 standard_sub_basic(get_current_username(),
4057 current_user_info.domain,
4058 serviceName,sizeof(serviceName));
4059 if (strequal(serviceName, pszServiceName)) {
4065 if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
4066 struct timespec last_mod;
4068 if (!usershare_exists(iService, &last_mod)) {
4069 /* Remove the share security tdb entry for it. */
4070 delete_share_security(lp_servicename(talloc_tos(), iService));
4071 /* Remove it from the array. */
4072 free_service_byindex(iService);
4073 /* Doesn't exist anymore. */
4074 return GLOBAL_SECTION_SNUM;
4077 /* Has it been modified ? If so delete and reload. */
4078 if (timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
4080 /* Remove it from the array. */
4081 free_service_byindex(iService);
4082 /* and now reload it. */
4083 iService = load_usershare_service(pszServiceName);
4088 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
4089 return GLOBAL_SECTION_SNUM;
4095 /*******************************************************************
4096 A useful volume label function.
4097 ********************************************************************/
4099 const char *volume_label(TALLOC_CTX *ctx, int snum)
4102 const char *label = lp_volume(ctx, snum);
4104 label = lp_servicename(ctx, snum);
4107 /* This returns a 33 byte guarenteed null terminated string. */
4108 ret = talloc_strndup(ctx, label, 32);
4115 /*******************************************************************
4116 Get the default server type we will announce as via nmbd.
4117 ********************************************************************/
4119 int lp_default_server_announce(void)
4121 int default_server_announce = 0;
4122 default_server_announce |= SV_TYPE_WORKSTATION;
4123 default_server_announce |= SV_TYPE_SERVER;
4124 default_server_announce |= SV_TYPE_SERVER_UNIX;
4126 /* note that the flag should be set only if we have a
4127 printer service but nmbd doesn't actually load the
4128 services so we can't tell --jerry */
4130 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
4132 default_server_announce |= SV_TYPE_SERVER_NT;
4133 default_server_announce |= SV_TYPE_NT;
4135 switch (lp_server_role()) {
4136 case ROLE_DOMAIN_MEMBER:
4137 default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
4139 case ROLE_DOMAIN_PDC:
4140 default_server_announce |= SV_TYPE_DOMAIN_CTRL;
4142 case ROLE_DOMAIN_BDC:
4143 default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
4145 case ROLE_STANDALONE:
4149 if (lp_time_server())
4150 default_server_announce |= SV_TYPE_TIME_SOURCE;
4152 if (lp_host_msdfs())
4153 default_server_announce |= SV_TYPE_DFS_SERVER;
4155 return default_server_announce;
4158 /***********************************************************
4159 If we are PDC then prefer us as DMB
4160 ************************************************************/
4162 bool lp_domain_master(void)
4164 if (Globals._domain_master == Auto)
4165 return (lp_server_role() == ROLE_DOMAIN_PDC);
4167 return (bool)Globals._domain_master;
4170 /***********************************************************
4171 If we are PDC then prefer us as DMB
4172 ************************************************************/
4174 static bool lp_domain_master_true_or_auto(void)
4176 if (Globals._domain_master) /* auto or yes */
4182 /***********************************************************
4183 If we are DMB then prefer us as LMB
4184 ************************************************************/
4186 bool lp_preferred_master(void)
4188 int preferred_master = lp__preferred_master();
4190 if (preferred_master == Auto)
4191 return (lp_local_master() && lp_domain_master());
4193 return (bool)preferred_master;
4196 /*******************************************************************
4198 ********************************************************************/
4200 void lp_remove_service(int snum)
4202 ServicePtrs[snum]->valid = false;
4205 const char *lp_printername(TALLOC_CTX *ctx, int snum)
4207 const char *ret = lp__printername(ctx, snum);
4208 if (ret == NULL || *ret == '\0') {
4209 ret = lp_const_servicename(snum);
4216 /***********************************************************
4217 Allow daemons such as winbindd to fix their logfile name.
4218 ************************************************************/
4220 void lp_set_logfile(const char *name)
4222 lpcfg_string_set(Globals.ctx, &Globals.logfile, name);
4223 debug_set_logfile(name);
4226 /*******************************************************************
4227 Return the max print jobs per queue.
4228 ********************************************************************/
4230 int lp_maxprintjobs(int snum)
4232 int maxjobs = lp_max_print_jobs(snum);
4234 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
4235 maxjobs = PRINT_MAX_JOBID - 1;
4240 const char *lp_printcapname(void)
4242 const char *printcap_name = lp_printcap_name();
4244 if ((printcap_name != NULL) &&
4245 (printcap_name[0] != '\0'))
4246 return printcap_name;
4248 if (sDefault.printing == PRINT_CUPS) {
4252 if (sDefault.printing == PRINT_BSD)
4253 return "/etc/printcap";
4255 return PRINTCAP_NAME;
4258 static uint32_t spoolss_state;
4260 bool lp_disable_spoolss( void )
4262 if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
4263 spoolss_state = lp__disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4265 return spoolss_state == SVCCTL_STOPPED ? true : false;
4268 void lp_set_spoolss_state( uint32_t state )
4270 SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
4272 spoolss_state = state;
4275 uint32_t lp_get_spoolss_state( void )
4277 return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4280 /*******************************************************************
4281 Ensure we don't use sendfile if server smb signing is active.
4282 ********************************************************************/
4284 bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state)
4286 bool sign_active = false;
4288 /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
4289 if (get_Protocol() < PROTOCOL_NT1) {
4292 if (signing_state) {
4293 sign_active = smb_signing_is_active(signing_state);
4295 return (lp__use_sendfile(snum) &&
4296 (get_remote_arch() != RA_WIN95) &&
4300 /*******************************************************************
4301 Turn off sendfile if we find the underlying OS doesn't support it.
4302 ********************************************************************/
4304 void set_use_sendfile(int snum, bool val)
4306 if (LP_SNUM_OK(snum))
4307 ServicePtrs[snum]->_use_sendfile = val;
4309 sDefault._use_sendfile = val;
4312 void lp_set_mangling_method(const char *new_method)
4314 lpcfg_string_set(Globals.ctx, &Globals.mangling_method, new_method);
4317 /*******************************************************************
4318 Global state for POSIX pathname processing.
4319 ********************************************************************/
4321 static bool posix_pathnames;
4323 bool lp_posix_pathnames(void)
4325 return posix_pathnames;
4328 /*******************************************************************
4329 Change everything needed to ensure POSIX pathname processing (currently
4331 ********************************************************************/
4333 void lp_set_posix_pathnames(void)
4335 posix_pathnames = true;
4338 /*******************************************************************
4339 Global state for POSIX lock processing - CIFS unix extensions.
4340 ********************************************************************/
4342 bool posix_default_lock_was_set;
4343 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
4345 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
4347 if (posix_default_lock_was_set) {
4348 return posix_cifsx_locktype;
4350 return (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
4351 POSIX_LOCK : WINDOWS_LOCK;
4355 /*******************************************************************
4356 ********************************************************************/
4358 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
4360 posix_default_lock_was_set = true;
4361 posix_cifsx_locktype = val;
4364 int lp_min_receive_file_size(void)
4366 int min_receivefile_size = lp_min_receivefile_size();
4368 if (min_receivefile_size < 0) {
4371 return min_receivefile_size;
4374 /*******************************************************************
4375 Safe wide links checks.
4376 This helper function always verify the validity of wide links,
4377 even after a configuration file reload.
4378 ********************************************************************/
4380 void widelinks_warning(int snum)
4382 if (lp_allow_insecure_wide_links()) {
4386 if (lp_unix_extensions() && lp_wide_links(snum)) {
4387 DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
4388 "These parameters are incompatible. "
4389 "Wide links will be disabled for this share.\n",
4390 lp_servicename(talloc_tos(), snum) ));
4394 bool lp_widelinks(int snum)
4396 /* wide links is always incompatible with unix extensions */
4397 if (lp_unix_extensions()) {
4399 * Unless we have "allow insecure widelinks"
4402 if (!lp_allow_insecure_wide_links()) {
4407 return lp_wide_links(snum);
4410 int lp_server_role(void)
4412 return lp_find_server_role(lp__server_role(),
4414 lp__domain_logons(),
4415 lp_domain_master_true_or_auto());
4418 int lp_security(void)
4420 return lp_find_security(lp__server_role(),
4424 int lp_client_max_protocol(void)
4426 int client_max_protocol = lp__client_max_protocol();
4427 if (client_max_protocol == PROTOCOL_DEFAULT) {
4428 return PROTOCOL_NT1;
4430 return client_max_protocol;
4433 int lp_winbindd_max_protocol(void)
4435 int client_max_protocol = lp__client_max_protocol();
4436 if (client_max_protocol == PROTOCOL_DEFAULT) {
4437 return PROTOCOL_LATEST;
4439 return client_max_protocol;
4442 struct loadparm_global * get_globals(void)
4447 unsigned int * get_flags(void)
4449 if (flags_list == NULL) {
4450 flags_list = talloc_zero_array(NULL, unsigned int, num_parameters());