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) && (ServicePtrs != NULL) && ServicePtrs[(i)]->valid)
97 #define VALID(i) (ServicePtrs != NULL && ServicePtrs[i]->valid)
99 #define USERSHARE_VALID 1
100 #define USERSHARE_PENDING_DELETE 2
102 static bool defaults_saved = false;
104 #include "lib/param/param_global.h"
106 static struct loadparm_global Globals;
108 /* This is a default service used to prime a services structure */
109 static struct loadparm_service sDefault =
114 .usershare_last_mod = {0, 0},
118 .invalid_users = NULL,
125 .root_preexec = NULL,
126 .root_postexec = NULL,
127 .cups_options = NULL,
128 .print_command = NULL,
130 .lprm_command = NULL,
131 .lppause_command = NULL,
132 .lpresume_command = NULL,
133 .queuepause_command = NULL,
134 .queueresume_command = NULL,
135 ._printername = NULL,
136 .printjob_username = NULL,
137 .dont_descend = NULL,
140 .magic_script = NULL,
141 .magic_output = NULL,
144 .veto_oplock_files = NULL,
154 .aio_write_behind = NULL,
155 .dfree_command = NULL,
156 .min_print_space = 0,
157 .max_print_jobs = 1000,
158 .max_reported_print_jobs = 0,
159 .write_cache_size = 0,
161 .force_create_mode = 0,
162 .directory_mask = 0755,
163 .force_directory_mode = 0,
164 .max_connections = 0,
165 .default_case = CASE_LOWER,
166 .printing = DEFAULT_PRINTING,
167 .oplock_contention_limit = 2,
170 .dfree_cache_time = 0,
171 .preexec_close = false,
172 .root_preexec_close = false,
173 .case_sensitive = Auto,
174 .preserve_case = true,
175 .short_preserve_case = true,
176 .hide_dot_files = true,
177 .hide_special_files = false,
178 .hide_unreadable = false,
179 .hide_unwriteable_files = false,
181 .access_based_share_enum = false,
186 .administrative_share = false,
189 .print_notify_backchannel = false,
193 .store_dos_attributes = false,
194 .dmapi_support = false,
196 .strict_locking = Auto,
197 .posix_locking = true,
199 .kernel_oplocks = false,
200 .level2_oplocks = true,
202 .mangled_names = true,
204 .follow_symlinks = true,
205 .sync_always = false,
206 .strict_allocate = false,
207 .strict_rename = false,
208 .strict_sync = false,
209 .mangling_char = '~',
211 .delete_readonly = false,
212 .fake_oplocks = false,
213 .delete_veto_files = false,
214 .dos_filemode = false,
215 .dos_filetimes = true,
216 .dos_filetime_resolution = false,
217 .fake_directory_create_times = false,
218 .blocking_locks = true,
219 .inherit_permissions = false,
220 .inherit_acls = false,
221 .inherit_owner = false,
223 .msdfs_shuffle_referrals = false,
224 .use_client_driver = false,
225 .default_devmode = true,
226 .force_printername = false,
227 .nt_acl_support = true,
228 .force_unknown_acl_user = false,
229 ._use_sendfile = false,
230 .profile_acls = false,
231 .map_acl_inherit = false,
234 .acl_check_permissions = true,
235 .acl_map_full_control = true,
236 .acl_group_control = false,
237 .acl_allow_execute_always = false,
238 .allocation_roundup_size = SMB_ROUNDUP_ALLOCATION_SIZE,
241 .map_readonly = MAP_READONLY_YES,
242 .directory_name_cache_size = 100,
243 .smb_encrypt = SMB_SIGNING_DEFAULT,
244 .kernel_share_modes = true,
245 .durable_handles = true,
250 /* local variables */
251 static struct loadparm_service **ServicePtrs = NULL;
252 static int iNumServices = 0;
253 static int iServiceIndex = 0;
254 static struct db_context *ServiceHash;
255 static bool bInGlobalSection = true;
256 static bool bGlobalOnly = false;
257 static struct file_lists *file_lists = NULL;
258 static unsigned int *flags_list = NULL;
260 static void set_allowed_client_auth(void);
262 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue);
263 static void free_param_opts(struct parmlist_entry **popts);
266 * Function to return the default value for the maximum number of open
267 * file descriptors permitted. This function tries to consult the
268 * kernel-level (sysctl) and ulimit (getrlimit()) values and goes
269 * the smaller of those.
271 static int max_open_files(void)
273 int sysctl_max = MAX_OPEN_FILES;
274 int rlimit_max = MAX_OPEN_FILES;
276 #ifdef HAVE_SYSCTLBYNAME
278 size_t size = sizeof(sysctl_max);
279 sysctlbyname("kern.maxfilesperproc", &sysctl_max, &size, NULL,
284 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
290 if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
291 rlimit_max = rl.rlim_cur;
293 #if defined(RLIM_INFINITY)
294 if(rl.rlim_cur == RLIM_INFINITY)
295 rlimit_max = MAX_OPEN_FILES;
300 if (sysctl_max < MIN_OPEN_FILES_WINDOWS) {
301 DEBUG(2,("max_open_files: increasing sysctl_max (%d) to "
302 "minimum Windows limit (%d)\n",
304 MIN_OPEN_FILES_WINDOWS));
305 sysctl_max = MIN_OPEN_FILES_WINDOWS;
308 if (rlimit_max < MIN_OPEN_FILES_WINDOWS) {
309 DEBUG(2,("rlimit_max: increasing rlimit_max (%d) to "
310 "minimum Windows limit (%d)\n",
312 MIN_OPEN_FILES_WINDOWS));
313 rlimit_max = MIN_OPEN_FILES_WINDOWS;
316 return MIN(sysctl_max, rlimit_max);
320 * Common part of freeing allocated data for one parameter.
322 static void free_one_parameter_common(void *parm_ptr,
323 struct parm_struct parm)
325 if ((parm.type == P_STRING) ||
326 (parm.type == P_USTRING))
328 lpcfg_string_free((char**)parm_ptr);
329 } else if (parm.type == P_LIST || parm.type == P_CMDLIST) {
330 TALLOC_FREE(*((char***)parm_ptr));
335 * Free the allocated data for one parameter for a share
336 * given as a service struct.
338 static void free_one_parameter(struct loadparm_service *service,
339 struct parm_struct parm)
343 if (parm.p_class != P_LOCAL) {
347 parm_ptr = lp_parm_ptr(service, &parm);
349 free_one_parameter_common(parm_ptr, parm);
353 * Free the allocated parameter data of a share given
354 * as a service struct.
356 static void free_parameters(struct loadparm_service *service)
360 for (i=0; parm_table[i].label; i++) {
361 free_one_parameter(service, parm_table[i]);
366 * Free the allocated data for one parameter for a given share
367 * specified by an snum.
369 static void free_one_parameter_by_snum(int snum, struct parm_struct parm)
374 parm_ptr = lp_parm_ptr(NULL, &parm);
375 } else if (parm.p_class != P_LOCAL) {
378 parm_ptr = lp_parm_ptr(ServicePtrs[snum], &parm);
381 free_one_parameter_common(parm_ptr, parm);
385 * Free the allocated parameter data for a share specified
388 static void free_parameters_by_snum(int snum)
392 for (i=0; parm_table[i].label; i++) {
393 free_one_parameter_by_snum(snum, parm_table[i]);
398 * Free the allocated global parameters.
400 static void free_global_parameters(void)
403 struct parm_struct *parm;
405 free_param_opts(&Globals.param_opt);
406 free_parameters_by_snum(GLOBAL_SECTION_SNUM);
408 /* Reset references in the defaults because the context is going to be freed */
409 for (i=0; parm_table[i].label; i++) {
410 parm = &parm_table[i];
411 if ((parm->type == P_STRING) ||
412 (parm->type == P_USTRING)) {
413 if ((parm->def.svalue != NULL) &&
414 (*(parm->def.svalue) != '\0')) {
415 if (talloc_parent(parm->def.svalue) == Globals.ctx) {
416 parm->def.svalue = NULL;
421 TALLOC_FREE(Globals.ctx);
424 struct lp_stored_option {
425 struct lp_stored_option *prev, *next;
430 static struct lp_stored_option *stored_options;
433 save options set by lp_set_cmdline() into a list. This list is
434 re-applied when we do a globals reset, so that cmdline set options
435 are sticky across reloads of smb.conf
437 bool store_lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
439 struct lp_stored_option *entry, *entry_next;
440 for (entry = stored_options; entry != NULL; entry = entry_next) {
441 entry_next = entry->next;
442 if (strcmp(pszParmName, entry->label) == 0) {
443 DLIST_REMOVE(stored_options, entry);
449 entry = talloc(NULL, struct lp_stored_option);
454 entry->label = talloc_strdup(entry, pszParmName);
460 entry->value = talloc_strdup(entry, pszParmValue);
466 DLIST_ADD_END(stored_options, entry, struct lp_stored_option);
471 static bool apply_lp_set_cmdline(void)
473 struct lp_stored_option *entry = NULL;
474 for (entry = stored_options; entry != NULL; entry = entry->next) {
475 if (!lp_set_cmdline_helper(entry->label, entry->value)) {
476 DEBUG(0, ("Failed to re-apply cmdline parameter %s = %s\n",
477 entry->label, entry->value));
484 /***************************************************************************
485 Initialise the global parameter structure.
486 ***************************************************************************/
488 static void init_globals(struct loadparm_context *lp_ctx, bool reinit_globals)
490 static bool done_init = false;
494 /* If requested to initialize only once and we've already done it... */
495 if (!reinit_globals && done_init) {
496 /* ... then we have nothing more to do */
501 /* The logfile can be set before this is invoked. Free it if so. */
502 lpcfg_string_free(&Globals.logfile);
505 free_global_parameters();
508 /* This memset and the free_global_parameters() above will
509 * wipe out smb.conf options set with lp_set_cmdline(). The
510 * apply_lp_set_cmdline() call puts these values back in the
511 * table once the defaults are set */
512 ZERO_STRUCT(Globals);
514 Globals.ctx = talloc_pooled_object(NULL, char, 272, 2048);
516 /* Initialize the flags list if necessary */
517 if (flags_list == NULL) {
521 for (i = 0; parm_table[i].label; i++) {
522 if ((parm_table[i].type == P_STRING ||
523 parm_table[i].type == P_USTRING))
527 (char **)lp_parm_ptr(NULL, &parm_table[i]),
533 lpcfg_string_set(Globals.ctx, &sDefault.fstype, FSTYPE_STRING);
534 lpcfg_string_set(Globals.ctx, &sDefault.printjob_username, "%U");
536 init_printer_values(lp_ctx, Globals.ctx, &sDefault);
538 sDefault.ntvfs_handler = str_list_make_v3_const(NULL, "unixuid default", NULL);
540 DEBUG(3, ("Initialising global parameters\n"));
542 /* Must manually force to upper case here, as this does not go via the handler */
543 lpcfg_string_set(Globals.ctx, &Globals.netbios_name,
546 lpcfg_string_set(Globals.ctx, &Globals.smb_passwd_file,
547 get_dyn_SMB_PASSWD_FILE());
548 lpcfg_string_set(Globals.ctx, &Globals.private_dir,
549 get_dyn_PRIVATE_DIR());
551 /* use the new 'hash2' method by default, with a prefix of 1 */
552 lpcfg_string_set(Globals.ctx, &Globals.mangling_method, "hash2");
553 Globals.mangle_prefix = 1;
555 lpcfg_string_set(Globals.ctx, &Globals.guest_account, GUEST_ACCOUNT);
557 /* using UTF8 by default allows us to support all chars */
558 lpcfg_string_set(Globals.ctx, &Globals.unix_charset,
559 DEFAULT_UNIX_CHARSET);
561 /* Use codepage 850 as a default for the dos character set */
562 lpcfg_string_set(Globals.ctx, &Globals.dos_charset,
563 DEFAULT_DOS_CHARSET);
566 * Allow the default PASSWD_CHAT to be overridden in local.h.
568 lpcfg_string_set(Globals.ctx, &Globals.passwd_chat,
569 DEFAULT_PASSWD_CHAT);
571 lpcfg_string_set(Globals.ctx, &Globals.workgroup, DEFAULT_WORKGROUP);
573 lpcfg_string_set(Globals.ctx, &Globals.passwd_program, "");
574 lpcfg_string_set(Globals.ctx, &Globals.lock_directory,
576 lpcfg_string_set(Globals.ctx, &Globals.state_directory,
578 lpcfg_string_set(Globals.ctx, &Globals.cache_directory,
580 lpcfg_string_set(Globals.ctx, &Globals.pid_directory,
582 lpcfg_string_set(Globals.ctx, &Globals.nbt_client_socket_address,
585 * By default support explicit binding to broadcast
588 Globals.nmbd_bind_explicit_broadcast = true;
590 s = talloc_asprintf(talloc_tos(), "Samba %s", samba_version_string());
592 smb_panic("init_globals: ENOMEM");
594 lpcfg_string_set(Globals.ctx, &Globals.server_string, s);
597 lpcfg_string_set(Globals.ctx, &Globals.panic_action,
598 "/bin/sleep 999999999");
601 lpcfg_string_set(Globals.ctx, &Globals.socket_options,
602 DEFAULT_SOCKET_OPTIONS);
604 lpcfg_string_set(Globals.ctx, &Globals.logon_drive, "");
605 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
606 lpcfg_string_set(Globals.ctx, &Globals.logon_home, "\\\\%N\\%U");
607 lpcfg_string_set(Globals.ctx, &Globals.logon_path,
608 "\\\\%N\\%U\\profile");
610 Globals.name_resolve_order = str_list_make_v3_const(NULL, "lmhosts wins host bcast", NULL);
611 lpcfg_string_set(Globals.ctx, &Globals.password_server, "*");
613 Globals.algorithmic_rid_base = BASE_RID;
615 Globals.load_printers = true;
616 Globals.printcap_cache_time = 750; /* 12.5 minutes */
618 Globals.config_backend = config_backend;
619 Globals._server_role = ROLE_AUTO;
621 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
622 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
623 Globals.max_xmit = 0x4104;
624 Globals.max_mux = 50; /* This is *needed* for profile support. */
625 Globals.lpq_cache_time = 30; /* changed to handle large print servers better -- jerry */
626 Globals._disable_spoolss = false;
627 Globals.max_smbd_processes = 0;/* no limit specified */
628 Globals.username_level = 0;
629 Globals.deadtime = 0;
630 Globals.getwd_cache = true;
631 Globals.large_readwrite = true;
632 Globals.max_log_size = 5000;
633 Globals.max_open_files = max_open_files();
634 Globals.server_max_protocol = PROTOCOL_SMB3_11;
635 Globals.server_min_protocol = PROTOCOL_LANMAN1;
636 Globals._client_max_protocol = PROTOCOL_DEFAULT;
637 Globals.client_min_protocol = PROTOCOL_CORE;
638 Globals._security = SEC_AUTO;
639 Globals.encrypt_passwords = true;
640 Globals.client_schannel = Auto;
641 Globals.winbind_sealed_pipes = true;
642 Globals.require_strong_key = true;
643 Globals.server_schannel = Auto;
644 Globals.read_raw = true;
645 Globals.write_raw = true;
646 Globals.null_passwords = false;
647 Globals.old_password_allowed_period = 60;
648 Globals.obey_pam_restrictions = false;
650 Globals.syslog_only = false;
651 Globals.timestamp_logs = true;
652 lpcfg_string_set(Globals.ctx, &Globals.log_level, "0");
653 Globals.debug_prefix_timestamp = false;
654 Globals.debug_hires_timestamp = true;
655 Globals.debug_pid = false;
656 Globals.debug_uid = false;
657 Globals.debug_class = false;
658 Globals.enable_core_files = true;
659 Globals.max_ttl = 60 * 60 * 24 * 3; /* 3 days default. */
660 Globals.max_wins_ttl = 60 * 60 * 24 * 6; /* 6 days default. */
661 Globals.min_wins_ttl = 60 * 60 * 6; /* 6 hours default. */
662 Globals.machine_password_timeout = 60 * 60 * 24 * 7; /* 7 days default. */
663 Globals.lm_announce = Auto; /* = Auto: send only if LM clients found */
664 Globals.lm_interval = 60;
665 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
666 Globals.nis_homedir = false;
667 #ifdef WITH_NISPLUS_HOME
668 lpcfg_string_set(Globals.ctx, &Globals.homedir_map,
669 "auto_home.org_dir");
671 lpcfg_string_set(Globals.ctx, &Globals.homedir_map, "auto.home");
674 Globals.time_server = false;
675 Globals.bind_interfaces_only = false;
676 Globals.unix_password_sync = false;
677 Globals.pam_password_change = false;
678 Globals.passwd_chat_debug = false;
679 Globals.passwd_chat_timeout = 2; /* 2 second default. */
680 Globals.nt_pipe_support = true; /* Do NT pipes by default. */
681 Globals.nt_status_support = true; /* Use NT status by default. */
682 Globals.smbd_profiling_level = 0;
683 Globals.stat_cache = true; /* use stat cache by default */
684 Globals.max_stat_cache_size = 256; /* 256k by default */
685 Globals.restrict_anonymous = 0;
686 Globals.client_lanman_auth = false; /* Do NOT use the LanMan hash if it is available */
687 Globals.client_plaintext_auth = false; /* Do NOT use a plaintext password even if is requested by the server */
688 Globals.lanman_auth = false; /* Do NOT use the LanMan hash, even if it is supplied */
689 Globals.ntlm_auth = true; /* Do use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
690 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 */
691 /* Note, that we will also use NTLM2 session security (which is different), if it is available */
693 Globals.map_to_guest = 0; /* By Default, "Never" */
694 Globals.oplock_break_wait_time = 0; /* By Default, 0 msecs. */
695 Globals.enhanced_browsing = true;
696 Globals.lock_spin_time = WINDOWS_MINIMUM_LOCK_TIMEOUT_MS; /* msec. */
697 #ifdef MMAP_BLACKLIST
698 Globals.use_mmap = false;
700 Globals.use_mmap = true;
702 Globals.unicode = true;
703 Globals.unix_extensions = true;
704 Globals.reset_on_zero_vc = false;
705 Globals.log_writeable_files_on_exit = false;
706 Globals.create_krb5_conf = true;
707 Globals._winbind_max_domain_connections = 1;
709 /* hostname lookups can be very expensive and are broken on
710 a large number of sites (tridge) */
711 Globals.hostname_lookups = false;
713 Globals.change_notify = true,
714 Globals.kernel_change_notify = true,
716 lpcfg_string_set(Globals.ctx, &Globals.passdb_backend, "tdbsam");
717 lpcfg_string_set(Globals.ctx, &Globals.ldap_suffix, "");
718 lpcfg_string_set(Globals.ctx, &Globals._ldap_machine_suffix, "");
719 lpcfg_string_set(Globals.ctx, &Globals._ldap_user_suffix, "");
720 lpcfg_string_set(Globals.ctx, &Globals._ldap_group_suffix, "");
721 lpcfg_string_set(Globals.ctx, &Globals._ldap_idmap_suffix, "");
723 lpcfg_string_set(Globals.ctx, &Globals.ldap_admin_dn, "");
724 Globals.ldap_ssl = LDAP_SSL_START_TLS;
725 Globals.ldap_ssl_ads = false;
726 Globals.ldap_deref = -1;
727 Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
728 Globals.ldap_delete_dn = false;
729 Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
730 Globals.ldap_follow_referral = Auto;
731 Globals.ldap_timeout = LDAP_DEFAULT_TIMEOUT;
732 Globals.ldap_connection_timeout = LDAP_CONNECTION_DEFAULT_TIMEOUT;
733 Globals.ldap_page_size = LDAP_PAGE_SIZE;
735 Globals.ldap_debug_level = 0;
736 Globals.ldap_debug_threshold = 10;
738 Globals.client_ldap_sasl_wrapping = ADS_AUTH_SASL_SIGN;
740 /* This is what we tell the afs client. in reality we set the token
741 * to never expire, though, when this runs out the afs client will
742 * forget the token. Set to 0 to get NEVERDATE.*/
743 Globals.afs_token_lifetime = 604800;
744 Globals.cups_connection_timeout = CUPS_DEFAULT_CONNECTION_TIMEOUT;
746 /* these parameters are set to defaults that are more appropriate
747 for the increasing samba install base:
749 as a member of the workgroup, that will possibly become a
750 _local_ master browser (lm = true). this is opposed to a forced
751 local master browser startup (pm = true).
753 doesn't provide WINS server service by default (wsupp = false),
754 and doesn't provide domain master browser services by default, either.
758 Globals.show_add_printer_wizard = true;
759 Globals.os_level = 20;
760 Globals.local_master = true;
761 Globals._domain_master = Auto; /* depending on _domain_logons */
762 Globals._domain_logons = false;
763 Globals.browse_list = true;
764 Globals.we_are_a_wins_server = false;
765 Globals.wins_proxy = false;
767 TALLOC_FREE(Globals.init_logon_delayed_hosts);
768 Globals.init_logon_delay = 100; /* 100 ms default delay */
770 Globals.wins_dns_proxy = true;
772 Globals.allow_trusted_domains = true;
773 lpcfg_string_set(Globals.ctx, &Globals.idmap_backend, "tdb");
775 lpcfg_string_set(Globals.ctx, &Globals.template_shell, "/bin/false");
776 lpcfg_string_set(Globals.ctx, &Globals.template_homedir,
778 lpcfg_string_set(Globals.ctx, &Globals.winbind_separator, "\\");
779 lpcfg_string_set(Globals.ctx, &Globals.winbindd_socket_directory,
780 dyn_WINBINDD_SOCKET_DIR);
782 lpcfg_string_set(Globals.ctx, &Globals.cups_server, "");
783 lpcfg_string_set(Globals.ctx, &Globals.iprint_server, "");
785 lpcfg_string_set(Globals.ctx, &Globals._ctdbd_socket, "");
787 Globals.cluster_addresses = NULL;
788 Globals.clustering = false;
789 Globals.ctdb_timeout = 0;
790 Globals.ctdb_locktime_warn_threshold = 0;
792 Globals.winbind_cache_time = 300; /* 5 minutes */
793 Globals.winbind_reconnect_delay = 30; /* 30 seconds */
794 Globals.winbind_request_timeout = 60; /* 60 seconds */
795 Globals.winbind_max_clients = 200;
796 Globals.winbind_enum_users = false;
797 Globals.winbind_enum_groups = false;
798 Globals.winbind_use_default_domain = false;
799 Globals.winbind_trusted_domains_only = false;
800 Globals.winbind_nested_groups = true;
801 Globals.winbind_expand_groups = 0;
802 Globals.winbind_nss_info = str_list_make_v3_const(NULL, "template", NULL);
803 Globals.winbind_refresh_tickets = false;
804 Globals.winbind_offline_logon = false;
806 Globals.idmap_cache_time = 86400 * 7; /* a week by default */
807 Globals.idmap_negative_cache_time = 120; /* 2 minutes by default */
809 Globals.passdb_expand_explicit = false;
811 Globals.name_cache_timeout = 660; /* In seconds */
813 Globals.use_spnego = true;
814 Globals.client_use_spnego = true;
816 Globals.client_signing = SMB_SIGNING_DEFAULT;
817 Globals.server_signing = SMB_SIGNING_DEFAULT;
819 Globals.defer_sharing_violations = true;
820 Globals.smb_ports = str_list_make_v3_const(NULL, SMB_PORTS, NULL);
822 Globals.enable_privileges = true;
823 Globals.host_msdfs = true;
824 Globals.enable_asu_support = false;
826 /* User defined shares. */
827 s = talloc_asprintf(talloc_tos(), "%s/usershares", get_dyn_STATEDIR());
829 smb_panic("init_globals: ENOMEM");
831 lpcfg_string_set(Globals.ctx, &Globals.usershare_path, s);
833 lpcfg_string_set(Globals.ctx, &Globals.usershare_template_share, "");
834 Globals.usershare_max_shares = 0;
835 /* By default disallow sharing of directories not owned by the sharer. */
836 Globals.usershare_owner_only = true;
837 /* By default disallow guest access to usershares. */
838 Globals.usershare_allow_guests = false;
840 Globals.keepalive = DEFAULT_KEEPALIVE;
842 /* By default no shares out of the registry */
843 Globals.registry_shares = false;
845 Globals.min_receivefile_size = 0;
847 Globals.map_untrusted_to_domain = false;
848 Globals.multicast_dns_register = true;
850 Globals.smb2_max_read = DEFAULT_SMB2_MAX_READ;
851 Globals.smb2_max_write = DEFAULT_SMB2_MAX_WRITE;
852 Globals.smb2_max_trans = DEFAULT_SMB2_MAX_TRANSACT;
853 Globals.smb2_max_credits = DEFAULT_SMB2_MAX_CREDITS;
854 Globals.smb2_leases = false;
856 lpcfg_string_set(Globals.ctx, &Globals.ncalrpc_dir,
857 get_dyn_NCALRPCDIR());
859 Globals.server_services = str_list_make_v3_const(NULL, "s3fs rpc nbt wrepl ldap cldap kdc drepl winbindd ntp_signd kcc dnsupdate dns", NULL);
861 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);
863 Globals.tls_enabled = true;
865 lpcfg_string_set(Globals.ctx, &Globals._tls_keyfile, "tls/key.pem");
866 lpcfg_string_set(Globals.ctx, &Globals._tls_certfile, "tls/cert.pem");
867 lpcfg_string_set(Globals.ctx, &Globals._tls_cafile, "tls/ca.pem");
868 lpcfg_string_set(Globals.ctx, &Globals.tls_priority,
869 "NORMAL:-VERS-SSL3.0");
871 lpcfg_string_set(Globals.ctx, &Globals.share_backend, "classic");
873 Globals._preferred_master = Auto;
875 Globals.allow_dns_updates = DNS_UPDATE_SIGNED;
877 lpcfg_string_set(Globals.ctx, &Globals.ntp_signd_socket_directory,
878 get_dyn_NTP_SIGND_SOCKET_DIR());
880 lpcfg_string_set(Globals.ctx,
881 &Globals.winbindd_privileged_socket_directory,
882 get_dyn_WINBINDD_PRIVILEGED_SOCKET_DIR());
884 s = talloc_asprintf(talloc_tos(), "%s/samba_kcc", get_dyn_SCRIPTSBINDIR());
886 smb_panic("init_globals: ENOMEM");
888 Globals.samba_kcc_command = str_list_make_v3_const(NULL, s, NULL);
891 s = talloc_asprintf(talloc_tos(), "%s/samba_dnsupdate", get_dyn_SCRIPTSBINDIR());
893 smb_panic("init_globals: ENOMEM");
895 Globals.dns_update_command = str_list_make_v3_const(NULL, s, NULL);
898 s = talloc_asprintf(talloc_tos(), "%s/samba_spnupdate", get_dyn_SCRIPTSBINDIR());
900 smb_panic("init_globals: ENOMEM");
902 Globals.spn_update_command = str_list_make_v3_const(NULL, s, NULL);
905 Globals.nsupdate_command = str_list_make_v3_const(NULL, "/usr/bin/nsupdate -g", NULL);
907 Globals.rndc_command = str_list_make_v3_const(NULL, "/usr/sbin/rndc", NULL);
909 Globals.cldap_port = 389;
911 Globals.dgram_port = NBT_DGRAM_SERVICE_PORT;
913 Globals.nbt_port = NBT_NAME_SERVICE_PORT;
915 Globals.krb5_port = 88;
917 Globals.kpasswd_port = 464;
919 Globals.web_port = 901;
921 Globals.aio_max_threads = 100;
923 /* Now put back the settings that were set with lp_set_cmdline() */
924 apply_lp_set_cmdline();
927 /* Convenience routine to setup an lp_context with additional s3 variables */
928 static struct loadparm_context *setup_lp_context(TALLOC_CTX *mem_ctx)
930 struct loadparm_context *lp_ctx;
932 lp_ctx = loadparm_init_s3(mem_ctx,
933 loadparm_s3_helpers());
934 if (lp_ctx == NULL) {
935 DEBUG(0, ("loadparm_init_s3 failed\n"));
939 lp_ctx->sDefault = &sDefault;
940 lp_ctx->services = NULL; /* We do not want to access this directly */
941 lp_ctx->bInGlobalSection = bInGlobalSection;
942 lp_ctx->flags = flags_list;
947 /*******************************************************************
948 Convenience routine to grab string parameters into talloced memory
949 and run standard_sub_basic on them. The buffers can be written to by
950 callers without affecting the source string.
951 ********************************************************************/
953 char *lp_string(TALLOC_CTX *ctx, const char *s)
957 /* The follow debug is useful for tracking down memory problems
958 especially if you have an inner loop that is calling a lp_*()
959 function that returns a string. Perhaps this debug should be
960 present all the time? */
963 DEBUG(10, ("lp_string(%s)\n", s));
969 ret = talloc_sub_basic(ctx,
970 get_current_username(),
971 current_user_info.domain,
973 if (trim_char(ret, '\"', '\"')) {
974 if (strchr(ret,'\"') != NULL) {
976 ret = talloc_sub_basic(ctx,
977 get_current_username(),
978 current_user_info.domain,
986 In this section all the functions that are used to access the
987 parameters from the rest of the program are defined
990 #define FN_GLOBAL_STRING(fn_name,ptr) \
991 char *lp_ ## fn_name(TALLOC_CTX *ctx) {return(lp_string((ctx), *(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : ""));}
992 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
993 const char *lp_ ## fn_name(void) {return(*(const char * const *)(&Globals.ptr) ? *(const char * const *)(&Globals.ptr) : "");}
994 #define FN_GLOBAL_LIST(fn_name,ptr) \
995 const char **lp_ ## fn_name(void) {return(*(const char ***)(&Globals.ptr));}
996 #define FN_GLOBAL_BOOL(fn_name,ptr) \
997 bool lp_ ## fn_name(void) {return(*(bool *)(&Globals.ptr));}
998 #define FN_GLOBAL_CHAR(fn_name,ptr) \
999 char lp_ ## fn_name(void) {return(*(char *)(&Globals.ptr));}
1000 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1001 int lp_ ## fn_name(void) {return(*(int *)(&Globals.ptr));}
1003 #define FN_LOCAL_STRING(fn_name,val) \
1004 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));}
1005 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1006 const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1007 #define FN_LOCAL_LIST(fn_name,val) \
1008 const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1009 #define FN_LOCAL_BOOL(fn_name,val) \
1010 bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1011 #define FN_LOCAL_INTEGER(fn_name,val) \
1012 int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1014 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1015 bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1016 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1017 int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1018 #define FN_LOCAL_PARM_CHAR(fn_name,val) \
1019 char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1021 int lp_winbind_max_domain_connections(void)
1023 if (lp_winbind_offline_logon() &&
1024 lp__winbind_max_domain_connections() > 1) {
1025 DEBUG(1, ("offline logons active, restricting max domain "
1026 "connections to 1\n"));
1029 return MAX(1, lp__winbind_max_domain_connections());
1032 /* These functions remain in source3/param for now */
1034 #include "lib/param/param_functions.c"
1036 FN_LOCAL_STRING(servicename, szService)
1037 FN_LOCAL_CONST_STRING(const_servicename, szService)
1039 /* These functions cannot be auto-generated */
1040 FN_LOCAL_BOOL(autoloaded, autoloaded)
1041 FN_GLOBAL_CONST_STRING(dnsdomain, dnsdomain)
1043 /* local prototypes */
1045 static int map_parameter_canonical(const char *pszParmName, bool *inverse);
1046 static const char *get_boolean(bool bool_value);
1047 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
1049 static bool hash_a_service(const char *name, int number);
1050 static void free_service_byindex(int iService);
1051 static void show_parameter(int parmIndex);
1052 static bool is_synonym_of(int parm1, int parm2, bool *inverse);
1055 * This is a helper function for parametrical options support. It returns a
1056 * pointer to parametrical option value if it exists or NULL otherwise. Actual
1057 * parametrical functions are quite simple
1059 static struct parmlist_entry *get_parametrics(int snum, const char *type,
1062 if (snum >= iNumServices) return NULL;
1065 return get_parametric_helper(NULL, type, option, Globals.param_opt);
1067 return get_parametric_helper(ServicePtrs[snum],
1068 type, option, Globals.param_opt);
1072 static void discard_whitespace(char *str)
1074 size_t len = strlen(str);
1078 if (isspace(str[i])) {
1079 memmove(&str[i], &str[i+1], len-i);
1088 * @brief Go through all global parametric parameters
1090 * @param regex_str A regular expression to scan param for
1091 * @param max_matches Max number of submatches the regexp expects
1092 * @param cb Function to call on match. Should return true
1093 * when it wants wi_scan_global_parametrics to stop
1095 * @param private_data Anonymous pointer passed to cb
1097 * @return 0: success, regcomp/regexec return value on error.
1098 * See "man regexec" for possible errors
1101 int lp_wi_scan_global_parametrics(
1102 const char *regex_str, size_t max_matches,
1103 bool (*cb)(const char *string, regmatch_t matches[],
1104 void *private_data),
1107 struct parmlist_entry *data;
1111 ret = regcomp(®ex, regex_str, REG_ICASE);
1116 for (data = Globals.param_opt; data != NULL; data = data->next) {
1117 size_t keylen = strlen(data->key);
1119 regmatch_t matches[max_matches];
1122 memcpy(key, data->key, sizeof(key));
1123 discard_whitespace(key);
1125 ret = regexec(®ex, key, max_matches, matches, 0);
1126 if (ret == REG_NOMATCH) {
1133 stop = cb(key, matches, private_data);
1146 #define MISSING_PARAMETER(name) \
1147 DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
1149 /*******************************************************************
1150 convenience routine to return enum parameters.
1151 ********************************************************************/
1152 static int lp_enum(const char *s,const struct enum_list *_enum)
1156 if (!s || !*s || !_enum) {
1157 MISSING_PARAMETER(lp_enum);
1161 for (i=0; _enum[i].name; i++) {
1162 if (strequal(_enum[i].name,s))
1163 return _enum[i].value;
1166 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
1170 #undef MISSING_PARAMETER
1172 /* Return parametric option from a given service. Type is a part of option before ':' */
1173 /* Parametric option has following syntax: 'Type: option = value' */
1174 char *lp_parm_talloc_string(TALLOC_CTX *ctx, int snum, const char *type, const char *option, const char *def)
1176 struct parmlist_entry *data = get_parametrics(snum, type, option);
1178 if (data == NULL||data->value==NULL) {
1180 return lp_string(ctx, def);
1186 return lp_string(ctx, data->value);
1189 /* Return parametric option from a given service. Type is a part of option before ':' */
1190 /* Parametric option has following syntax: 'Type: option = value' */
1191 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
1193 struct parmlist_entry *data = get_parametrics(snum, type, option);
1195 if (data == NULL||data->value==NULL)
1202 /* Return parametric option from a given service. Type is a part of option before ':' */
1203 /* Parametric option has following syntax: 'Type: option = value' */
1205 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
1207 struct parmlist_entry *data = get_parametrics(snum, type, option);
1209 if (data == NULL||data->value==NULL)
1210 return (const char **)def;
1212 if (data->list==NULL) {
1213 data->list = str_list_make_v3(NULL, data->value, NULL);
1216 return discard_const_p(const char *, data->list);
1219 /* Return parametric option from a given service. Type is a part of option before ':' */
1220 /* Parametric option has following syntax: 'Type: option = value' */
1222 int lp_parm_int(int snum, const char *type, const char *option, int def)
1224 struct parmlist_entry *data = get_parametrics(snum, type, option);
1226 if (data && data->value && *data->value)
1227 return lp_int(data->value);
1232 /* Return parametric option from a given service. Type is a part of option before ':' */
1233 /* Parametric option has following syntax: 'Type: option = value' */
1235 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
1237 struct parmlist_entry *data = get_parametrics(snum, type, option);
1239 if (data && data->value && *data->value)
1240 return lp_ulong(data->value);
1245 /* Return parametric option from a given service. Type is a part of option before ':' */
1246 /* Parametric option has following syntax: 'Type: option = value' */
1248 unsigned long long lp_parm_ulonglong(int snum, const char *type,
1249 const char *option, unsigned long long def)
1251 struct parmlist_entry *data = get_parametrics(snum, type, option);
1253 if (data && data->value && *data->value) {
1254 return lp_ulonglong(data->value);
1260 /* Return parametric option from a given service. Type is a part of option
1262 /* Parametric option has following syntax: 'Type: option = value' */
1264 bool lp_parm_bool(int snum, const char *type, const char *option, bool def)
1266 struct parmlist_entry *data = get_parametrics(snum, type, option);
1268 if (data && data->value && *data->value)
1269 return lp_bool(data->value);
1274 /* Return parametric option from a given service. Type is a part of option before ':' */
1275 /* Parametric option has following syntax: 'Type: option = value' */
1277 int lp_parm_enum(int snum, const char *type, const char *option,
1278 const struct enum_list *_enum, int def)
1280 struct parmlist_entry *data = get_parametrics(snum, type, option);
1282 if (data && data->value && *data->value && _enum)
1283 return lp_enum(data->value, _enum);
1289 * free a param_opts structure.
1290 * param_opts handling should be moved to talloc;
1291 * then this whole functions reduces to a TALLOC_FREE().
1294 static void free_param_opts(struct parmlist_entry **popts)
1296 struct parmlist_entry *opt, *next_opt;
1298 if (*popts != NULL) {
1299 DEBUG(5, ("Freeing parametrics:\n"));
1302 while (opt != NULL) {
1303 lpcfg_string_free(&opt->key);
1304 lpcfg_string_free(&opt->value);
1305 TALLOC_FREE(opt->list);
1306 next_opt = opt->next;
1313 /***************************************************************************
1314 Free the dynamically allocated parts of a service struct.
1315 ***************************************************************************/
1317 static void free_service(struct loadparm_service *pservice)
1322 if (pservice->szService)
1323 DEBUG(5, ("free_service: Freeing service %s\n",
1324 pservice->szService));
1326 free_parameters(pservice);
1328 lpcfg_string_free(&pservice->szService);
1329 TALLOC_FREE(pservice->copymap);
1331 free_param_opts(&pservice->param_opt);
1333 ZERO_STRUCTP(pservice);
1337 /***************************************************************************
1338 remove a service indexed in the ServicePtrs array from the ServiceHash
1339 and free the dynamically allocated parts
1340 ***************************************************************************/
1342 static void free_service_byindex(int idx)
1344 if ( !LP_SNUM_OK(idx) )
1347 ServicePtrs[idx]->valid = false;
1349 /* we have to cleanup the hash record */
1351 if (ServicePtrs[idx]->szService) {
1352 char *canon_name = canonicalize_servicename(
1354 ServicePtrs[idx]->szService );
1356 dbwrap_delete_bystring(ServiceHash, canon_name );
1357 TALLOC_FREE(canon_name);
1360 free_service(ServicePtrs[idx]);
1361 talloc_free_children(ServicePtrs[idx]);
1364 /***************************************************************************
1365 Add a new service to the services array initialising it with the given
1367 ***************************************************************************/
1369 static int add_a_service(const struct loadparm_service *pservice, const char *name)
1372 int num_to_alloc = iNumServices + 1;
1373 struct loadparm_service **tsp = NULL;
1375 /* it might already exist */
1377 i = getservicebyname(name, NULL);
1383 /* if not, then create one */
1385 tsp = talloc_realloc(NULL, ServicePtrs, struct loadparm_service *, num_to_alloc);
1387 DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
1391 ServicePtrs[iNumServices] = talloc_zero(ServicePtrs, struct loadparm_service);
1392 if (!ServicePtrs[iNumServices]) {
1393 DEBUG(0,("add_a_service: out of memory!\n"));
1398 ServicePtrs[i]->valid = true;
1400 copy_service(ServicePtrs[i], pservice, NULL);
1402 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->szService,
1405 DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
1406 i, ServicePtrs[i]->szService));
1408 if (!hash_a_service(ServicePtrs[i]->szService, i)) {
1415 /***************************************************************************
1416 Convert a string to uppercase and remove whitespaces.
1417 ***************************************************************************/
1419 char *canonicalize_servicename(TALLOC_CTX *ctx, const char *src)
1424 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
1428 result = talloc_strdup(ctx, src);
1429 SMB_ASSERT(result != NULL);
1431 if (!strlower_m(result)) {
1432 TALLOC_FREE(result);
1438 /***************************************************************************
1439 Add a name/index pair for the services array to the hash table.
1440 ***************************************************************************/
1442 static bool hash_a_service(const char *name, int idx)
1446 if ( !ServiceHash ) {
1447 DEBUG(10,("hash_a_service: creating servicehash\n"));
1448 ServiceHash = db_open_rbt(NULL);
1449 if ( !ServiceHash ) {
1450 DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
1455 DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
1458 canon_name = canonicalize_servicename(talloc_tos(), name );
1460 dbwrap_store_bystring(ServiceHash, canon_name,
1461 make_tdb_data((uint8_t *)&idx, sizeof(idx)),
1464 TALLOC_FREE(canon_name);
1469 /***************************************************************************
1470 Add a new home service, with the specified home directory, defaults coming
1472 ***************************************************************************/
1474 bool lp_add_home(const char *pszHomename, int iDefaultService,
1475 const char *user, const char *pszHomedir)
1479 if (pszHomename == NULL || user == NULL || pszHomedir == NULL ||
1480 pszHomedir[0] == '\0') {
1484 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
1489 if (!(*(ServicePtrs[iDefaultService]->path))
1490 || strequal(ServicePtrs[iDefaultService]->path,
1491 lp_path(talloc_tos(), GLOBAL_SECTION_SNUM))) {
1492 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path,
1496 if (!(*(ServicePtrs[i]->comment))) {
1497 char *comment = talloc_asprintf(talloc_tos(), "Home directory of %s", user);
1498 if (comment == NULL) {
1501 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment,
1503 TALLOC_FREE(comment);
1506 /* set the browseable flag from the global default */
1508 ServicePtrs[i]->browseable = sDefault.browseable;
1509 ServicePtrs[i]->access_based_share_enum = sDefault.access_based_share_enum;
1511 ServicePtrs[i]->autoloaded = true;
1513 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
1514 user, ServicePtrs[i]->path ));
1519 /***************************************************************************
1520 Add a new service, based on an old one.
1521 ***************************************************************************/
1523 int lp_add_service(const char *pszService, int iDefaultService)
1525 if (iDefaultService < 0) {
1526 return add_a_service(&sDefault, pszService);
1529 return (add_a_service(ServicePtrs[iDefaultService], pszService));
1532 /***************************************************************************
1533 Add the IPC service.
1534 ***************************************************************************/
1536 static bool lp_add_ipc(const char *ipc_name, bool guest_ok)
1538 char *comment = NULL;
1539 int i = add_a_service(&sDefault, ipc_name);
1544 comment = talloc_asprintf(talloc_tos(), "IPC Service (%s)",
1545 Globals.server_string);
1546 if (comment == NULL) {
1550 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path, tmpdir());
1551 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->username, "");
1552 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1553 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->fstype, "IPC");
1554 ServicePtrs[i]->max_connections = 0;
1555 ServicePtrs[i]->available = true;
1556 ServicePtrs[i]->read_only = true;
1557 ServicePtrs[i]->guest_only = false;
1558 ServicePtrs[i]->administrative_share = true;
1559 ServicePtrs[i]->guest_ok = guest_ok;
1560 ServicePtrs[i]->printable = false;
1561 ServicePtrs[i]->browseable = sDefault.browseable;
1563 DEBUG(3, ("adding IPC service\n"));
1565 TALLOC_FREE(comment);
1569 /***************************************************************************
1570 Add a new printer service, with defaults coming from service iFrom.
1571 ***************************************************************************/
1573 bool lp_add_printer(const char *pszPrintername, int iDefaultService)
1575 const char *comment = "From Printcap";
1576 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
1581 /* note that we do NOT default the availability flag to true - */
1582 /* we take it from the default service passed. This allows all */
1583 /* dynamic printers to be disabled by disabling the [printers] */
1584 /* entry (if/when the 'available' keyword is implemented!). */
1586 /* the printer name is set to the service name. */
1587 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->_printername,
1589 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1591 /* set the browseable flag from the gloabl default */
1592 ServicePtrs[i]->browseable = sDefault.browseable;
1594 /* Printers cannot be read_only. */
1595 ServicePtrs[i]->read_only = false;
1596 /* No oplocks on printer services. */
1597 ServicePtrs[i]->oplocks = false;
1598 /* Printer services must be printable. */
1599 ServicePtrs[i]->printable = true;
1601 DEBUG(3, ("adding printer service %s\n", pszPrintername));
1607 /***************************************************************************
1608 Check whether the given parameter name is valid.
1609 Parametric options (names containing a colon) are considered valid.
1610 ***************************************************************************/
1612 bool lp_parameter_is_valid(const char *pszParmName)
1614 return ((lpcfg_map_parameter(pszParmName) != -1) ||
1615 (strchr(pszParmName, ':') != NULL));
1618 /***************************************************************************
1619 Check whether the given name is the name of a global parameter.
1620 Returns true for strings belonging to parameters of class
1621 P_GLOBAL, false for all other strings, also for parametric options
1622 and strings not belonging to any option.
1623 ***************************************************************************/
1625 bool lp_parameter_is_global(const char *pszParmName)
1627 int num = lpcfg_map_parameter(pszParmName);
1630 return (parm_table[num].p_class == P_GLOBAL);
1636 /**************************************************************************
1637 Determine the canonical name for a parameter.
1638 Indicate when it is an inverse (boolean) synonym instead of a
1640 **************************************************************************/
1642 bool lp_canonicalize_parameter(const char *parm_name, const char **canon_parm,
1647 if (!lp_parameter_is_valid(parm_name)) {
1652 num = map_parameter_canonical(parm_name, inverse);
1654 /* parametric option */
1655 *canon_parm = parm_name;
1657 *canon_parm = parm_table[num].label;
1664 /**************************************************************************
1665 Determine the canonical name for a parameter.
1666 Turn the value given into the inverse boolean expression when
1667 the synonym is an invers boolean synonym.
1669 Return true if parm_name is a valid parameter name and
1670 in case it is an invers boolean synonym, if the val string could
1671 successfully be converted to the reverse bool.
1672 Return false in all other cases.
1673 **************************************************************************/
1675 bool lp_canonicalize_parameter_with_value(const char *parm_name,
1677 const char **canon_parm,
1678 const char **canon_val)
1683 if (!lp_parameter_is_valid(parm_name)) {
1689 num = map_parameter_canonical(parm_name, &inverse);
1691 /* parametric option */
1692 *canon_parm = parm_name;
1695 *canon_parm = parm_table[num].label;
1697 if (!lp_invert_boolean(val, canon_val)) {
1709 /***************************************************************************
1710 Map a parameter's string representation to the index of the canonical
1711 form of the parameter (it might be a synonym).
1712 Returns -1 if the parameter string is not recognised.
1713 ***************************************************************************/
1715 static int map_parameter_canonical(const char *pszParmName, bool *inverse)
1717 int parm_num, canon_num;
1718 bool loc_inverse = false;
1720 parm_num = lpcfg_map_parameter(pszParmName);
1721 if ((parm_num < 0) || !(parm_table[parm_num].flags & FLAG_SYNONYM)) {
1722 /* invalid, parametric or no canidate for synonyms ... */
1726 for (canon_num = 0; parm_table[canon_num].label; canon_num++) {
1727 if (is_synonym_of(parm_num, canon_num, &loc_inverse)) {
1728 parm_num = canon_num;
1734 if (inverse != NULL) {
1735 *inverse = loc_inverse;
1740 /***************************************************************************
1741 return true if parameter number parm1 is a synonym of parameter
1742 number parm2 (parm2 being the principal name).
1743 set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
1745 ***************************************************************************/
1747 static bool is_synonym_of(int parm1, int parm2, bool *inverse)
1749 if ((parm_table[parm1].offset == parm_table[parm2].offset) &&
1750 (parm_table[parm1].p_class == parm_table[parm2].p_class) &&
1751 (parm_table[parm1].flags & FLAG_SYNONYM) &&
1752 !(parm_table[parm2].flags & FLAG_SYNONYM))
1754 if (inverse != NULL) {
1755 if ((parm_table[parm1].type == P_BOOLREV) &&
1756 (parm_table[parm2].type == P_BOOL))
1768 /***************************************************************************
1769 Show one parameter's name, type, [values,] and flags.
1770 (helper functions for show_parameter_list)
1771 ***************************************************************************/
1773 static void show_parameter(int parmIndex)
1775 int enumIndex, flagIndex;
1780 const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
1781 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
1782 "P_ENUM", "P_BYTES", "P_CMDLIST" };
1783 unsigned flags[] = { FLAG_DEPRECATED, FLAG_SYNONYM };
1784 const char *flag_names[] = { "FLAG_DEPRECATED", "FLAG_SYNONYM", NULL};
1786 printf("%s=%s", parm_table[parmIndex].label,
1787 type[parm_table[parmIndex].type]);
1788 if (parm_table[parmIndex].type == P_ENUM) {
1791 parm_table[parmIndex].enum_list[enumIndex].name;
1795 enumIndex ? "|" : "",
1796 parm_table[parmIndex].enum_list[enumIndex].name);
1801 for (flagIndex=0; flag_names[flagIndex]; flagIndex++) {
1802 if (parm_table[parmIndex].flags & flags[flagIndex]) {
1805 flag_names[flagIndex]);
1810 /* output synonyms */
1812 for (parmIndex2=0; parm_table[parmIndex2].label; parmIndex2++) {
1813 if (is_synonym_of(parmIndex, parmIndex2, &inverse)) {
1814 printf(" (%ssynonym of %s)", inverse ? "inverse " : "",
1815 parm_table[parmIndex2].label);
1816 } else if (is_synonym_of(parmIndex2, parmIndex, &inverse)) {
1818 printf(" (synonyms: ");
1823 printf("%s%s", parm_table[parmIndex2].label,
1824 inverse ? "[i]" : "");
1834 /***************************************************************************
1835 Show all parameter's name, type, [values,] and flags.
1836 ***************************************************************************/
1838 void show_parameter_list(void)
1840 int classIndex, parmIndex;
1841 const char *section_names[] = { "local", "global", NULL};
1843 for (classIndex=0; section_names[classIndex]; classIndex++) {
1844 printf("[%s]\n", section_names[classIndex]);
1845 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
1846 if (parm_table[parmIndex].p_class == classIndex) {
1847 show_parameter(parmIndex);
1853 /***************************************************************************
1854 Get the standard string representation of a boolean value ("yes" or "no")
1855 ***************************************************************************/
1857 static const char *get_boolean(bool bool_value)
1859 static const char *yes_str = "yes";
1860 static const char *no_str = "no";
1862 return (bool_value ? yes_str : no_str);
1865 /***************************************************************************
1866 Provide the string of the negated boolean value associated to the boolean
1867 given as a string. Returns false if the passed string does not correctly
1868 represent a boolean.
1869 ***************************************************************************/
1871 bool lp_invert_boolean(const char *str, const char **inverse_str)
1875 if (!set_boolean(str, &val)) {
1879 *inverse_str = get_boolean(!val);
1883 /***************************************************************************
1884 Provide the canonical string representation of a boolean value given
1885 as a string. Return true on success, false if the string given does
1886 not correctly represent a boolean.
1887 ***************************************************************************/
1889 bool lp_canonicalize_boolean(const char *str, const char**canon_str)
1893 if (!set_boolean(str, &val)) {
1897 *canon_str = get_boolean(val);
1901 /***************************************************************************
1902 Find a service by name. Otherwise works like get_service.
1903 ***************************************************************************/
1905 int getservicebyname(const char *pszServiceName, struct loadparm_service *pserviceDest)
1912 if (ServiceHash == NULL) {
1916 canon_name = canonicalize_servicename(talloc_tos(), pszServiceName);
1918 status = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name,
1921 if (NT_STATUS_IS_OK(status) &&
1922 (data.dptr != NULL) &&
1923 (data.dsize == sizeof(iService)))
1925 iService = *(int *)data.dptr;
1928 TALLOC_FREE(canon_name);
1930 if ((iService != -1) && (LP_SNUM_OK(iService))
1931 && (pserviceDest != NULL)) {
1932 copy_service(pserviceDest, ServicePtrs[iService], NULL);
1938 /* Return a pointer to a service by name. Unlike getservicebyname, it does not copy the service */
1939 struct loadparm_service *lp_service(const char *pszServiceName)
1941 int iService = getservicebyname(pszServiceName, NULL);
1942 if (iService == -1 || !LP_SNUM_OK(iService)) {
1945 return ServicePtrs[iService];
1948 struct loadparm_service *lp_servicebynum(int snum)
1950 if ((snum == -1) || !LP_SNUM_OK(snum)) {
1953 return ServicePtrs[snum];
1956 struct loadparm_service *lp_default_loadparm_service()
1961 static struct smbconf_ctx *lp_smbconf_ctx(void)
1964 static struct smbconf_ctx *conf_ctx = NULL;
1966 if (conf_ctx == NULL) {
1967 err = smbconf_init(NULL, &conf_ctx, "registry:");
1968 if (!SBC_ERROR_IS_OK(err)) {
1969 DEBUG(1, ("error initializing registry configuration: "
1970 "%s\n", sbcErrorString(err)));
1978 static bool process_smbconf_service(struct smbconf_service *service)
1983 if (service == NULL) {
1987 ret = lp_do_section(service->name, NULL);
1991 for (count = 0; count < service->num_params; count++) {
1993 if (!bInGlobalSection && bGlobalOnly) {
1996 const char *pszParmName = service->param_names[count];
1997 const char *pszParmValue = service->param_values[count];
1999 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2001 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2002 pszParmName, pszParmValue);
2009 if (iServiceIndex >= 0) {
2010 return lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2016 * load a service from registry and activate it
2018 bool process_registry_service(const char *service_name)
2021 struct smbconf_service *service = NULL;
2022 TALLOC_CTX *mem_ctx = talloc_stackframe();
2023 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2026 if (conf_ctx == NULL) {
2030 DEBUG(5, ("process_registry_service: service name %s\n", service_name));
2032 if (!smbconf_share_exists(conf_ctx, service_name)) {
2034 * Registry does not contain data for this service (yet),
2035 * but make sure lp_load doesn't return false.
2041 err = smbconf_get_share(conf_ctx, mem_ctx, service_name, &service);
2042 if (!SBC_ERROR_IS_OK(err)) {
2046 ret = process_smbconf_service(service);
2052 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2055 TALLOC_FREE(mem_ctx);
2060 * process_registry_globals
2062 static bool process_registry_globals(void)
2066 add_to_file_list(NULL, &file_lists, INCLUDE_REGISTRY_NAME, INCLUDE_REGISTRY_NAME);
2068 if (!bInGlobalSection && bGlobalOnly) {
2071 const char *pszParmName = "registry shares";
2072 const char *pszParmValue = "yes";
2074 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2076 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2077 pszParmName, pszParmValue);
2084 return process_registry_service(GLOBAL_NAME);
2087 bool process_registry_shares(void)
2091 struct smbconf_service **service = NULL;
2092 uint32_t num_shares = 0;
2093 TALLOC_CTX *mem_ctx = talloc_stackframe();
2094 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2097 if (conf_ctx == NULL) {
2101 err = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &service);
2102 if (!SBC_ERROR_IS_OK(err)) {
2108 for (count = 0; count < num_shares; count++) {
2109 if (strequal(service[count]->name, GLOBAL_NAME)) {
2112 ret = process_smbconf_service(service[count]);
2119 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2122 TALLOC_FREE(mem_ctx);
2127 * reload those shares from registry that are already
2128 * activated in the services array.
2130 static bool reload_registry_shares(void)
2135 for (i = 0; i < iNumServices; i++) {
2140 if (ServicePtrs[i]->usershare == USERSHARE_VALID) {
2144 ret = process_registry_service(ServicePtrs[i]->szService);
2155 #define MAX_INCLUDE_DEPTH 100
2157 static uint8_t include_depth;
2160 * Free the file lists
2162 static void free_file_list(void)
2164 struct file_lists *f;
2165 struct file_lists *next;
2178 * Utility function for outsiders to check if we're running on registry.
2180 bool lp_config_backend_is_registry(void)
2182 return (lp_config_backend() == CONFIG_BACKEND_REGISTRY);
2186 * Utility function to check if the config backend is FILE.
2188 bool lp_config_backend_is_file(void)
2190 return (lp_config_backend() == CONFIG_BACKEND_FILE);
2193 /*******************************************************************
2194 Check if a config file has changed date.
2195 ********************************************************************/
2197 bool lp_file_list_changed(void)
2199 struct file_lists *f = file_lists;
2201 DEBUG(6, ("lp_file_list_changed()\n"));
2204 if (strequal(f->name, INCLUDE_REGISTRY_NAME)) {
2205 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2207 if (conf_ctx == NULL) {
2210 if (smbconf_changed(conf_ctx, &conf_last_csn, NULL,
2213 DEBUGADD(6, ("registry config changed\n"));
2220 n2 = talloc_sub_basic(talloc_tos(),
2221 get_current_username(),
2222 current_user_info.domain,
2227 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
2228 f->name, n2, ctime(&f->modtime)));
2230 mod_time = file_modtime(n2);
2233 ((f->modtime != mod_time) ||
2234 (f->subfname == NULL) ||
2235 (strcmp(n2, f->subfname) != 0)))
2238 ("file %s modified: %s\n", n2,
2240 f->modtime = mod_time;
2241 TALLOC_FREE(f->subfname);
2242 f->subfname = talloc_strdup(f, n2);
2243 if (f->subfname == NULL) {
2244 smb_panic("talloc_strdup failed");
2258 * Initialize iconv conversion descriptors.
2260 * This is called the first time it is needed, and also called again
2261 * every time the configuration is reloaded, because the charset or
2262 * codepage might have changed.
2264 static void init_iconv(void)
2266 global_iconv_handle = smb_iconv_handle_reinit(NULL, lp_dos_charset(),
2268 true, global_iconv_handle);
2271 /***************************************************************************
2272 Handle the include operation.
2273 ***************************************************************************/
2274 static bool bAllowIncludeRegistry = true;
2276 bool lp_include(struct loadparm_context *lp_ctx, struct loadparm_service *service,
2277 const char *pszParmValue, char **ptr)
2281 if (include_depth >= MAX_INCLUDE_DEPTH) {
2282 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
2287 if (strequal(pszParmValue, INCLUDE_REGISTRY_NAME)) {
2288 if (!bAllowIncludeRegistry) {
2291 if (lp_ctx->bInGlobalSection) {
2294 ret = process_registry_globals();
2298 DEBUG(1, ("\"include = registry\" only effective "
2299 "in %s section\n", GLOBAL_NAME));
2304 fname = talloc_sub_basic(talloc_tos(), get_current_username(),
2305 current_user_info.domain,
2308 add_to_file_list(NULL, &file_lists, pszParmValue, fname);
2310 if (service == NULL) {
2311 lpcfg_string_set(Globals.ctx, ptr, fname);
2313 lpcfg_string_set(service, ptr, fname);
2316 if (file_exist(fname)) {
2319 ret = pm_process(fname, lp_do_section, do_parameter, lp_ctx);
2325 DEBUG(2, ("Can't find include file %s\n", fname));
2330 bool lp_idmap_range(const char *domain_name, uint32_t *low, uint32_t *high)
2332 char *config_option = NULL;
2333 const char *range = NULL;
2336 SMB_ASSERT(low != NULL);
2337 SMB_ASSERT(high != NULL);
2339 if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2343 config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2345 if (config_option == NULL) {
2346 DEBUG(0, ("out of memory\n"));
2350 range = lp_parm_const_string(-1, config_option, "range", NULL);
2351 if (range == NULL) {
2352 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name));
2356 if (sscanf(range, "%u - %u", low, high) != 2) {
2357 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2358 range, domain_name));
2365 talloc_free(config_option);
2370 bool lp_idmap_default_range(uint32_t *low, uint32_t *high)
2372 return lp_idmap_range("*", low, high);
2375 const char *lp_idmap_backend(const char *domain_name)
2377 char *config_option = NULL;
2378 const char *backend = NULL;
2380 if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2384 config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2386 if (config_option == NULL) {
2387 DEBUG(0, ("out of memory\n"));
2391 backend = lp_parm_const_string(-1, config_option, "backend", NULL);
2392 if (backend == NULL) {
2393 DEBUG(1, ("idmap backend not specified for domain '%s'\n", domain_name));
2398 talloc_free(config_option);
2402 const char *lp_idmap_default_backend(void)
2404 return lp_idmap_backend("*");
2407 /***************************************************************************
2408 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2409 ***************************************************************************/
2411 static const char *append_ldap_suffix(TALLOC_CTX *ctx, const char *str )
2413 const char *suffix_string;
2415 suffix_string = talloc_asprintf(ctx, "%s,%s", str,
2416 Globals.ldap_suffix );
2417 if ( !suffix_string ) {
2418 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2422 return suffix_string;
2425 const char *lp_ldap_machine_suffix(TALLOC_CTX *ctx)
2427 if (Globals._ldap_machine_suffix[0])
2428 return append_ldap_suffix(ctx, Globals._ldap_machine_suffix);
2430 return lp_string(ctx, Globals.ldap_suffix);
2433 const char *lp_ldap_user_suffix(TALLOC_CTX *ctx)
2435 if (Globals._ldap_user_suffix[0])
2436 return append_ldap_suffix(ctx, Globals._ldap_user_suffix);
2438 return lp_string(ctx, Globals.ldap_suffix);
2441 const char *lp_ldap_group_suffix(TALLOC_CTX *ctx)
2443 if (Globals._ldap_group_suffix[0])
2444 return append_ldap_suffix(ctx, Globals._ldap_group_suffix);
2446 return lp_string(ctx, Globals.ldap_suffix);
2449 const char *lp_ldap_idmap_suffix(TALLOC_CTX *ctx)
2451 if (Globals._ldap_idmap_suffix[0])
2452 return append_ldap_suffix(ctx, Globals._ldap_idmap_suffix);
2454 return lp_string(ctx, Globals.ldap_suffix);
2458 return the parameter pointer for a parameter
2460 void *lp_parm_ptr(struct loadparm_service *service, struct parm_struct *parm)
2462 if (service == NULL) {
2463 if (parm->p_class == P_LOCAL)
2464 return (void *)(((char *)&sDefault)+parm->offset);
2465 else if (parm->p_class == P_GLOBAL)
2466 return (void *)(((char *)&Globals)+parm->offset);
2469 return (void *)(((char *)service) + parm->offset);
2473 /***************************************************************************
2474 Process a parameter for a particular service number. If snum < 0
2475 then assume we are in the globals.
2476 ***************************************************************************/
2478 bool lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
2480 TALLOC_CTX *frame = talloc_stackframe();
2481 struct loadparm_context *lp_ctx;
2484 lp_ctx = setup_lp_context(frame);
2485 if (lp_ctx == NULL) {
2491 ok = lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue);
2493 ok = lpcfg_do_service_parameter(lp_ctx, ServicePtrs[snum],
2494 pszParmName, pszParmValue);
2502 /***************************************************************************
2503 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
2504 FLAG_CMDLINE won't be overridden by loads from smb.conf.
2505 ***************************************************************************/
2507 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue)
2510 parmnum = lpcfg_map_parameter(pszParmName);
2512 flags_list[parmnum] &= ~FLAG_CMDLINE;
2513 if (!lp_do_parameter(-1, pszParmName, pszParmValue)) {
2516 flags_list[parmnum] |= FLAG_CMDLINE;
2518 /* we have to also set FLAG_CMDLINE on aliases. Aliases must
2519 * be grouped in the table, so we don't have to search the
2522 i>=0 && parm_table[i].offset == parm_table[parmnum].offset
2523 && parm_table[i].p_class == parm_table[parmnum].p_class;
2525 flags_list[i] |= FLAG_CMDLINE;
2527 for (i=parmnum+1;i<num_parameters() && parm_table[i].offset == parm_table[parmnum].offset
2528 && parm_table[i].p_class == parm_table[parmnum].p_class;i++) {
2529 flags_list[i] |= FLAG_CMDLINE;
2535 /* it might be parametric */
2536 if (strchr(pszParmName, ':') != NULL) {
2537 set_param_opt(NULL, &Globals.param_opt, pszParmName, pszParmValue, FLAG_CMDLINE);
2541 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
2545 bool lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
2548 TALLOC_CTX *frame = talloc_stackframe();
2549 struct loadparm_context *lp_ctx;
2551 lp_ctx = setup_lp_context(frame);
2552 if (lp_ctx == NULL) {
2557 ret = lpcfg_set_cmdline(lp_ctx, pszParmName, pszParmValue);
2563 /***************************************************************************
2564 Process a parameter.
2565 ***************************************************************************/
2567 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
2570 if (!bInGlobalSection && bGlobalOnly)
2573 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2575 if (bInGlobalSection) {
2576 return lpcfg_do_global_parameter(userdata, pszParmName, pszParmValue);
2578 return lpcfg_do_service_parameter(userdata, ServicePtrs[iServiceIndex],
2579 pszParmName, pszParmValue);
2583 /***************************************************************************
2584 Initialize any local variables in the sDefault table, after parsing a
2586 ***************************************************************************/
2588 static void init_locals(void)
2591 * We run this check once the [globals] is parsed, to force
2592 * the VFS objects and other per-share settings we need for
2593 * the standard way a AD DC is operated. We may change these
2594 * as our code evolves, which is why we force these settings.
2596 * We can't do this at the end of lp_load_ex(), as by that
2597 * point the services have been loaded and they will already
2598 * have "" as their vfs objects.
2600 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
2601 const char **vfs_objects = lp_vfs_objects(-1);
2602 if (!vfs_objects || !vfs_objects[0]) {
2603 if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL)) {
2604 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
2605 } else if (lp_parm_const_string(-1, "posix", "eadb", NULL)) {
2606 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
2608 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
2612 lp_do_parameter(-1, "map hidden", "no");
2613 lp_do_parameter(-1, "map system", "no");
2614 lp_do_parameter(-1, "map readonly", "no");
2615 lp_do_parameter(-1, "map archive", "no");
2616 lp_do_parameter(-1, "store dos attributes", "yes");
2620 /***************************************************************************
2621 Process a new section (service). At this stage all sections are services.
2622 Later we'll have special sections that permit server parameters to be set.
2623 Returns true on success, false on failure.
2624 ***************************************************************************/
2626 bool lp_do_section(const char *pszSectionName, void *userdata)
2628 struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
2630 bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
2631 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
2634 /* if we were in a global section then do the local inits */
2635 if (bInGlobalSection && !isglobal)
2638 /* if we've just struck a global section, note the fact. */
2639 bInGlobalSection = isglobal;
2640 if (lp_ctx != NULL) {
2641 lp_ctx->bInGlobalSection = isglobal;
2644 /* check for multiple global sections */
2645 if (bInGlobalSection) {
2646 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
2650 if (!bInGlobalSection && bGlobalOnly)
2653 /* if we have a current service, tidy it up before moving on */
2656 if (iServiceIndex >= 0)
2657 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2659 /* if all is still well, move to the next record in the services array */
2661 /* We put this here to avoid an odd message order if messages are */
2662 /* issued by the post-processing of a previous section. */
2663 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
2665 iServiceIndex = add_a_service(&sDefault, pszSectionName);
2666 if (iServiceIndex < 0) {
2667 DEBUG(0, ("Failed to add a new service\n"));
2670 /* Clean all parametric options for service */
2671 /* They will be added during parsing again */
2672 free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
2678 /***************************************************************************
2679 Display the contents of a parameter of a single services record.
2680 ***************************************************************************/
2682 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
2684 bool result = false;
2685 struct loadparm_context *lp_ctx;
2687 lp_ctx = setup_lp_context(talloc_tos());
2688 if (lp_ctx == NULL) {
2693 result = lpcfg_dump_a_parameter(lp_ctx, NULL, parm_name, f);
2695 result = lpcfg_dump_a_parameter(lp_ctx, ServicePtrs[snum], parm_name, f);
2697 TALLOC_FREE(lp_ctx);
2702 /***************************************************************************
2703 Display the contents of a single copy structure.
2704 ***************************************************************************/
2705 static void dump_copy_map(bool *pcopymap)
2711 printf("\n\tNon-Copied parameters:\n");
2713 for (i = 0; parm_table[i].label; i++)
2714 if (parm_table[i].p_class == P_LOCAL &&
2715 parm_table[i].ptr && !pcopymap[i] &&
2716 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
2718 printf("\t\t%s\n", parm_table[i].label);
2723 /***************************************************************************
2724 Return TRUE if the passed service number is within range.
2725 ***************************************************************************/
2727 bool lp_snum_ok(int iService)
2729 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->available);
2732 /***************************************************************************
2733 Auto-load some home services.
2734 ***************************************************************************/
2736 static void lp_add_auto_services(char *str)
2746 s = talloc_strdup(talloc_tos(), str);
2748 smb_panic("talloc_strdup failed");
2752 homes = lp_servicenumber(HOMES_NAME);
2754 for (p = strtok_r(s, LIST_SEP, &saveptr); p;
2755 p = strtok_r(NULL, LIST_SEP, &saveptr)) {
2758 if (lp_servicenumber(p) >= 0)
2761 home = get_user_home_dir(talloc_tos(), p);
2763 if (home && home[0] && homes >= 0)
2764 lp_add_home(p, homes, p, home);
2771 /***************************************************************************
2772 Auto-load one printer.
2773 ***************************************************************************/
2775 void lp_add_one_printer(const char *name, const char *comment,
2776 const char *location, void *pdata)
2778 int printers = lp_servicenumber(PRINTERS_NAME);
2781 if (lp_servicenumber(name) < 0) {
2782 lp_add_printer(name, printers);
2783 if ((i = lp_servicenumber(name)) >= 0) {
2784 lpcfg_string_set(ServicePtrs[i],
2785 &ServicePtrs[i]->comment, comment);
2786 ServicePtrs[i]->autoloaded = true;
2791 /***************************************************************************
2792 Have we loaded a services file yet?
2793 ***************************************************************************/
2795 bool lp_loaded(void)
2800 /***************************************************************************
2801 Unload unused services.
2802 ***************************************************************************/
2804 void lp_killunused(struct smbd_server_connection *sconn,
2805 bool (*snumused) (struct smbd_server_connection *, int))
2808 for (i = 0; i < iNumServices; i++) {
2812 /* don't kill autoloaded or usershare services */
2813 if ( ServicePtrs[i]->autoloaded ||
2814 ServicePtrs[i]->usershare == USERSHARE_VALID) {
2818 if (!snumused || !snumused(sconn, i)) {
2819 free_service_byindex(i);
2825 * Kill all except autoloaded and usershare services - convenience wrapper
2827 void lp_kill_all_services(void)
2829 lp_killunused(NULL, NULL);
2832 /***************************************************************************
2834 ***************************************************************************/
2836 void lp_killservice(int iServiceIn)
2838 if (VALID(iServiceIn)) {
2839 free_service_byindex(iServiceIn);
2843 /***************************************************************************
2844 Save the curent values of all global and sDefault parameters into the
2845 defaults union. This allows testparm to show only the
2846 changed (ie. non-default) parameters.
2847 ***************************************************************************/
2849 static void lp_save_defaults(void)
2852 struct parmlist_entry * parm;
2853 for (i = 0; parm_table[i].label; i++) {
2854 if (!(flags_list[i] & FLAG_CMDLINE)) {
2855 flags_list[i] |= FLAG_DEFAULT;
2858 if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
2859 && parm_table[i].p_class == parm_table[i - 1].p_class)
2861 switch (parm_table[i].type) {
2864 parm_table[i].def.lvalue = str_list_copy(
2865 NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
2871 &parm_table[i].def.svalue,
2872 *(char **)lp_parm_ptr(
2873 NULL, &parm_table[i]));
2874 if (parm_table[i].def.svalue == NULL) {
2875 smb_panic("lpcfg_string_set() failed");
2880 parm_table[i].def.bvalue =
2881 *(bool *)lp_parm_ptr(NULL, &parm_table[i]);
2884 parm_table[i].def.cvalue =
2885 *(char *)lp_parm_ptr(NULL, &parm_table[i]);
2891 parm_table[i].def.ivalue =
2892 *(int *)lp_parm_ptr(NULL, &parm_table[i]);
2897 for (parm=Globals.param_opt; parm; parm=parm->next) {
2898 if (!(parm->priority & FLAG_CMDLINE)) {
2899 parm->priority |= FLAG_DEFAULT;
2903 for (parm=sDefault.param_opt; parm; parm=parm->next) {
2904 if (!(parm->priority & FLAG_CMDLINE)) {
2905 parm->priority |= FLAG_DEFAULT;
2909 defaults_saved = true;
2912 /***********************************************************
2913 If we should send plaintext/LANMAN passwords in the clinet
2914 ************************************************************/
2916 static void set_allowed_client_auth(void)
2918 if (Globals.client_ntlmv2_auth) {
2919 Globals.client_lanman_auth = false;
2921 if (!Globals.client_lanman_auth) {
2922 Globals.client_plaintext_auth = false;
2926 /***************************************************************************
2928 The following code allows smbd to read a user defined share file.
2929 Yes, this is my intent. Yes, I'm comfortable with that...
2931 THE FOLLOWING IS SECURITY CRITICAL CODE.
2933 It washes your clothes, it cleans your house, it guards you while you sleep...
2934 Do not f%^k with it....
2935 ***************************************************************************/
2937 #define MAX_USERSHARE_FILE_SIZE (10*1024)
2939 /***************************************************************************
2940 Check allowed stat state of a usershare file.
2941 Ensure we print out who is dicking with us so the admin can
2942 get their sorry ass fired.
2943 ***************************************************************************/
2945 static bool check_usershare_stat(const char *fname,
2946 const SMB_STRUCT_STAT *psbuf)
2948 if (!S_ISREG(psbuf->st_ex_mode)) {
2949 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
2950 "not a regular file\n",
2951 fname, (unsigned int)psbuf->st_ex_uid ));
2955 /* Ensure this doesn't have the other write bit set. */
2956 if (psbuf->st_ex_mode & S_IWOTH) {
2957 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
2958 "public write. Refusing to allow as a usershare file.\n",
2959 fname, (unsigned int)psbuf->st_ex_uid ));
2963 /* Should be 10k or less. */
2964 if (psbuf->st_ex_size > MAX_USERSHARE_FILE_SIZE) {
2965 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
2966 "too large (%u) to be a user share file.\n",
2967 fname, (unsigned int)psbuf->st_ex_uid,
2968 (unsigned int)psbuf->st_ex_size ));
2975 /***************************************************************************
2976 Parse the contents of a usershare file.
2977 ***************************************************************************/
2979 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
2980 SMB_STRUCT_STAT *psbuf,
2981 const char *servicename,
2985 char **pp_sharepath,
2987 char **pp_cp_servicename,
2988 struct security_descriptor **ppsd,
2991 const char **prefixallowlist = lp_usershare_prefix_allow_list();
2992 const char **prefixdenylist = lp_usershare_prefix_deny_list();
2995 SMB_STRUCT_STAT sbuf;
2996 char *sharepath = NULL;
2997 char *comment = NULL;
2999 *pp_sharepath = NULL;
3002 *pallow_guest = false;
3005 return USERSHARE_MALFORMED_FILE;
3008 if (strcmp(lines[0], "#VERSION 1") == 0) {
3010 } else if (strcmp(lines[0], "#VERSION 2") == 0) {
3013 return USERSHARE_MALFORMED_FILE;
3016 return USERSHARE_BAD_VERSION;
3019 if (strncmp(lines[1], "path=", 5) != 0) {
3020 return USERSHARE_MALFORMED_PATH;
3023 sharepath = talloc_strdup(ctx, &lines[1][5]);
3025 return USERSHARE_POSIX_ERR;
3027 trim_string(sharepath, " ", " ");
3029 if (strncmp(lines[2], "comment=", 8) != 0) {
3030 return USERSHARE_MALFORMED_COMMENT_DEF;
3033 comment = talloc_strdup(ctx, &lines[2][8]);
3035 return USERSHARE_POSIX_ERR;
3037 trim_string(comment, " ", " ");
3038 trim_char(comment, '"', '"');
3040 if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
3041 return USERSHARE_MALFORMED_ACL_DEF;
3044 if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
3045 return USERSHARE_ACL_ERR;
3049 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
3050 return USERSHARE_MALFORMED_ACL_DEF;
3052 if (lines[4][9] == 'y') {
3053 *pallow_guest = true;
3056 /* Backwards compatible extension to file version #2. */
3058 if (strncmp(lines[5], "sharename=", 10) != 0) {
3059 return USERSHARE_MALFORMED_SHARENAME_DEF;
3061 if (!strequal(&lines[5][10], servicename)) {
3062 return USERSHARE_BAD_SHARENAME;
3064 *pp_cp_servicename = talloc_strdup(ctx, &lines[5][10]);
3065 if (!*pp_cp_servicename) {
3066 return USERSHARE_POSIX_ERR;
3071 if (*pp_cp_servicename == NULL) {
3072 *pp_cp_servicename = talloc_strdup(ctx, servicename);
3073 if (!*pp_cp_servicename) {
3074 return USERSHARE_POSIX_ERR;
3078 if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->path) == 0)) {
3079 /* Path didn't change, no checks needed. */
3080 *pp_sharepath = sharepath;
3081 *pp_comment = comment;
3082 return USERSHARE_OK;
3085 /* The path *must* be absolute. */
3086 if (sharepath[0] != '/') {
3087 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
3088 servicename, sharepath));
3089 return USERSHARE_PATH_NOT_ABSOLUTE;
3092 /* If there is a usershare prefix deny list ensure one of these paths
3093 doesn't match the start of the user given path. */
3094 if (prefixdenylist) {
3096 for ( i=0; prefixdenylist[i]; i++ ) {
3097 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
3098 servicename, i, prefixdenylist[i], sharepath ));
3099 if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
3100 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
3101 "usershare prefix deny list entries.\n",
3102 servicename, sharepath));
3103 return USERSHARE_PATH_IS_DENIED;
3108 /* If there is a usershare prefix allow list ensure one of these paths
3109 does match the start of the user given path. */
3111 if (prefixallowlist) {
3113 for ( i=0; prefixallowlist[i]; i++ ) {
3114 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
3115 servicename, i, prefixallowlist[i], sharepath ));
3116 if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
3120 if (prefixallowlist[i] == NULL) {
3121 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
3122 "usershare prefix allow list entries.\n",
3123 servicename, sharepath));
3124 return USERSHARE_PATH_NOT_ALLOWED;
3128 /* Ensure this is pointing to a directory. */
3129 dp = opendir(sharepath);
3132 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3133 servicename, sharepath));
3134 return USERSHARE_PATH_NOT_DIRECTORY;
3137 /* Ensure the owner of the usershare file has permission to share
3140 if (sys_stat(sharepath, &sbuf, false) == -1) {
3141 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
3142 servicename, sharepath, strerror(errno) ));
3144 return USERSHARE_POSIX_ERR;
3149 if (!S_ISDIR(sbuf.st_ex_mode)) {
3150 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3151 servicename, sharepath ));
3152 return USERSHARE_PATH_NOT_DIRECTORY;
3155 /* Check if sharing is restricted to owner-only. */
3156 /* psbuf is the stat of the usershare definition file,
3157 sbuf is the stat of the target directory to be shared. */
3159 if (lp_usershare_owner_only()) {
3160 /* root can share anything. */
3161 if ((psbuf->st_ex_uid != 0) && (sbuf.st_ex_uid != psbuf->st_ex_uid)) {
3162 return USERSHARE_PATH_NOT_ALLOWED;
3166 *pp_sharepath = sharepath;
3167 *pp_comment = comment;
3168 return USERSHARE_OK;
3171 /***************************************************************************
3172 Deal with a usershare file.
3175 -1 - Bad name, invalid contents.
3176 - service name already existed and not a usershare, problem
3177 with permissions to share directory etc.
3178 ***************************************************************************/
3180 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
3182 SMB_STRUCT_STAT sbuf;
3183 SMB_STRUCT_STAT lsbuf;
3185 char *sharepath = NULL;
3186 char *comment = NULL;
3187 char *cp_service_name = NULL;
3188 char **lines = NULL;
3192 TALLOC_CTX *ctx = talloc_stackframe();
3193 struct security_descriptor *psd = NULL;
3194 bool guest_ok = false;
3195 char *canon_name = NULL;
3196 bool added_service = false;
3199 /* Ensure share name doesn't contain invalid characters. */
3200 if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
3201 DEBUG(0,("process_usershare_file: share name %s contains "
3202 "invalid characters (any of %s)\n",
3203 file_name, INVALID_SHARENAME_CHARS ));
3207 canon_name = canonicalize_servicename(ctx, file_name);
3212 fname = talloc_asprintf(ctx, "%s/%s", dir_name, file_name);
3217 /* Minimize the race condition by doing an lstat before we
3218 open and fstat. Ensure this isn't a symlink link. */
3220 if (sys_lstat(fname, &lsbuf, false) != 0) {
3221 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
3222 fname, strerror(errno) ));
3226 /* This must be a regular file, not a symlink, directory or
3227 other strange filetype. */
3228 if (!check_usershare_stat(fname, &lsbuf)) {
3236 status = dbwrap_fetch_bystring(ServiceHash, canon_name,
3241 if (NT_STATUS_IS_OK(status) &&
3242 (data.dptr != NULL) &&
3243 (data.dsize == sizeof(iService))) {
3244 memcpy(&iService, data.dptr, sizeof(iService));
3248 if (iService != -1 &&
3249 timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
3250 &lsbuf.st_ex_mtime) == 0) {
3251 /* Nothing changed - Mark valid and return. */
3252 DEBUG(10,("process_usershare_file: service %s not changed.\n",
3254 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3259 /* Try and open the file read only - no symlinks allowed. */
3261 fd = open(fname, O_RDONLY|O_NOFOLLOW, 0);
3263 fd = open(fname, O_RDONLY, 0);
3267 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
3268 fname, strerror(errno) ));
3272 /* Now fstat to be *SURE* it's a regular file. */
3273 if (sys_fstat(fd, &sbuf, false) != 0) {
3275 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
3276 fname, strerror(errno) ));
3280 /* Is it the same dev/inode as was lstated ? */
3281 if (!check_same_stat(&lsbuf, &sbuf)) {
3283 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
3284 "Symlink spoofing going on ?\n", fname ));
3288 /* This must be a regular file, not a symlink, directory or
3289 other strange filetype. */
3290 if (!check_usershare_stat(fname, &sbuf)) {
3295 lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE, NULL);
3298 if (lines == NULL) {
3299 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
3300 fname, (unsigned int)sbuf.st_ex_uid ));
3304 if (parse_usershare_file(ctx, &sbuf, file_name,
3305 iService, lines, numlines, &sharepath,
3306 &comment, &cp_service_name,
3307 &psd, &guest_ok) != USERSHARE_OK) {
3311 /* Everything ok - add the service possibly using a template. */
3313 const struct loadparm_service *sp = &sDefault;
3314 if (snum_template != -1) {
3315 sp = ServicePtrs[snum_template];
3318 if ((iService = add_a_service(sp, cp_service_name)) < 0) {
3319 DEBUG(0, ("process_usershare_file: Failed to add "
3320 "new service %s\n", cp_service_name));
3324 added_service = true;
3326 /* Read only is controlled by usershare ACL below. */
3327 ServicePtrs[iService]->read_only = false;
3330 /* Write the ACL of the new/modified share. */
3331 if (!set_share_security(canon_name, psd)) {
3332 DEBUG(0, ("process_usershare_file: Failed to set share "
3333 "security for user share %s\n",
3338 /* If from a template it may be marked invalid. */
3339 ServicePtrs[iService]->valid = true;
3341 /* Set the service as a valid usershare. */
3342 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3344 /* Set guest access. */
3345 if (lp_usershare_allow_guests()) {
3346 ServicePtrs[iService]->guest_ok = guest_ok;
3349 /* And note when it was loaded. */
3350 ServicePtrs[iService]->usershare_last_mod = sbuf.st_ex_mtime;
3351 lpcfg_string_set(ServicePtrs[iService], &ServicePtrs[iService]->path,
3353 lpcfg_string_set(ServicePtrs[iService],
3354 &ServicePtrs[iService]->comment, comment);
3360 if (ret == -1 && iService != -1 && added_service) {
3361 lp_remove_service(iService);
3369 /***************************************************************************
3370 Checks if a usershare entry has been modified since last load.
3371 ***************************************************************************/
3373 static bool usershare_exists(int iService, struct timespec *last_mod)
3375 SMB_STRUCT_STAT lsbuf;
3376 const char *usersharepath = Globals.usershare_path;
3379 fname = talloc_asprintf(talloc_tos(),
3382 ServicePtrs[iService]->szService);
3383 if (fname == NULL) {
3387 if (sys_lstat(fname, &lsbuf, false) != 0) {
3392 if (!S_ISREG(lsbuf.st_ex_mode)) {
3398 *last_mod = lsbuf.st_ex_mtime;
3402 /***************************************************************************
3403 Load a usershare service by name. Returns a valid servicenumber or -1.
3404 ***************************************************************************/
3406 int load_usershare_service(const char *servicename)
3408 SMB_STRUCT_STAT sbuf;
3409 const char *usersharepath = Globals.usershare_path;
3410 int max_user_shares = Globals.usershare_max_shares;
3411 int snum_template = -1;
3413 if (*usersharepath == 0 || max_user_shares == 0) {
3417 if (sys_stat(usersharepath, &sbuf, false) != 0) {
3418 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
3419 usersharepath, strerror(errno) ));
3423 if (!S_ISDIR(sbuf.st_ex_mode)) {
3424 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
3430 * This directory must be owned by root, and have the 't' bit set.
3431 * It also must not be writable by "other".
3435 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3437 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3439 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
3440 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3445 /* Ensure the template share exists if it's set. */
3446 if (Globals.usershare_template_share[0]) {
3447 /* We can't use lp_servicenumber here as we are recommending that
3448 template shares have -valid=false set. */
3449 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3450 if (ServicePtrs[snum_template]->szService &&
3451 strequal(ServicePtrs[snum_template]->szService,
3452 Globals.usershare_template_share)) {
3457 if (snum_template == -1) {
3458 DEBUG(0,("load_usershare_service: usershare template share %s "
3459 "does not exist.\n",
3460 Globals.usershare_template_share ));
3465 return process_usershare_file(usersharepath, servicename, snum_template);
3468 /***************************************************************************
3469 Load all user defined shares from the user share directory.
3470 We only do this if we're enumerating the share list.
3471 This is the function that can delete usershares that have
3473 ***************************************************************************/
3475 int load_usershare_shares(struct smbd_server_connection *sconn,
3476 bool (*snumused) (struct smbd_server_connection *, int))
3479 SMB_STRUCT_STAT sbuf;
3481 int num_usershares = 0;
3482 int max_user_shares = Globals.usershare_max_shares;
3483 unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
3484 unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
3485 unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
3487 int snum_template = -1;
3488 const char *usersharepath = Globals.usershare_path;
3489 int ret = lp_numservices();
3490 TALLOC_CTX *tmp_ctx;
3492 if (max_user_shares == 0 || *usersharepath == '\0') {
3493 return lp_numservices();
3496 if (sys_stat(usersharepath, &sbuf, false) != 0) {
3497 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
3498 usersharepath, strerror(errno) ));
3503 * This directory must be owned by root, and have the 't' bit set.
3504 * It also must not be writable by "other".
3508 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3510 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3512 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
3513 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3518 /* Ensure the template share exists if it's set. */
3519 if (Globals.usershare_template_share[0]) {
3520 /* We can't use lp_servicenumber here as we are recommending that
3521 template shares have -valid=false set. */
3522 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3523 if (ServicePtrs[snum_template]->szService &&
3524 strequal(ServicePtrs[snum_template]->szService,
3525 Globals.usershare_template_share)) {
3530 if (snum_template == -1) {
3531 DEBUG(0,("load_usershare_shares: usershare template share %s "
3532 "does not exist.\n",
3533 Globals.usershare_template_share ));
3538 /* Mark all existing usershares as pending delete. */
3539 for (iService = iNumServices - 1; iService >= 0; iService--) {
3540 if (VALID(iService) && ServicePtrs[iService]->usershare) {
3541 ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
3545 dp = opendir(usersharepath);
3547 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
3548 usersharepath, strerror(errno) ));
3552 for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
3554 num_dir_entries++ ) {
3556 const char *n = de->d_name;
3558 /* Ignore . and .. */
3560 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
3566 /* Temporary file used when creating a share. */
3567 num_tmp_dir_entries++;
3570 /* Allow 20% tmp entries. */
3571 if (num_tmp_dir_entries > allowed_tmp_entries) {
3572 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
3573 "in directory %s\n",
3574 num_tmp_dir_entries, usersharepath));
3578 r = process_usershare_file(usersharepath, n, snum_template);
3580 /* Update the services count. */
3582 if (num_usershares >= max_user_shares) {
3583 DEBUG(0,("load_usershare_shares: max user shares reached "
3584 "on file %s in directory %s\n",
3585 n, usersharepath ));
3588 } else if (r == -1) {
3589 num_bad_dir_entries++;
3592 /* Allow 20% bad entries. */
3593 if (num_bad_dir_entries > allowed_bad_entries) {
3594 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
3595 "in directory %s\n",
3596 num_bad_dir_entries, usersharepath));
3600 /* Allow 20% bad entries. */
3601 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
3602 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
3603 "in directory %s\n",
3604 num_dir_entries, usersharepath));
3611 /* Sweep through and delete any non-refreshed usershares that are
3612 not currently in use. */
3613 tmp_ctx = talloc_stackframe();
3614 for (iService = iNumServices - 1; iService >= 0; iService--) {
3615 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
3618 if (snumused && snumused(sconn, iService)) {
3622 servname = lp_servicename(tmp_ctx, iService);
3624 /* Remove from the share ACL db. */
3625 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
3627 delete_share_security(servname);
3628 free_service_byindex(iService);
3631 talloc_free(tmp_ctx);
3633 return lp_numservices();
3636 /********************************************************
3637 Destroy global resources allocated in this file
3638 ********************************************************/
3640 void gfree_loadparm(void)
3646 /* Free resources allocated to services */
3648 for ( i = 0; i < iNumServices; i++ ) {
3650 free_service_byindex(i);
3654 TALLOC_FREE( ServicePtrs );
3657 /* Now release all resources allocated to global
3658 parameters and the default service */
3660 free_global_parameters();
3664 /***************************************************************************
3665 Allow client apps to specify that they are a client
3666 ***************************************************************************/
3667 static void lp_set_in_client(bool b)
3673 /***************************************************************************
3674 Determine if we're running in a client app
3675 ***************************************************************************/
3676 static bool lp_is_in_client(void)
3681 static void lp_enforce_ad_dc_settings(void)
3683 lp_do_parameter(GLOBAL_SECTION_SNUM, "passdb backend", "samba_dsdb");
3684 lp_do_parameter(GLOBAL_SECTION_SNUM,
3685 "winbindd:use external pipes", "true");
3686 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:default", "external");
3687 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:svcctl", "embedded");
3688 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:srvsvc", "embedded");
3689 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:eventlog", "embedded");
3690 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:ntsvcs", "embedded");
3691 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:winreg", "embedded");
3692 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:spoolss", "embedded");
3693 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_daemon:spoolssd", "embedded");
3694 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:tcpip", "no");
3697 /***************************************************************************
3698 Load the services array from the services file. Return true on success,
3700 ***************************************************************************/
3702 static bool lp_load_ex(const char *pszFname,
3706 bool reinit_globals,
3707 bool allow_include_registry,
3708 bool load_all_shares)
3712 TALLOC_CTX *frame = talloc_stackframe();
3713 struct loadparm_context *lp_ctx;
3717 DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
3719 bInGlobalSection = true;
3720 bGlobalOnly = global_only;
3721 bAllowIncludeRegistry = allow_include_registry;
3723 lp_ctx = setup_lp_context(talloc_tos());
3725 init_globals(lp_ctx, reinit_globals);
3729 if (save_defaults) {
3734 if (!reinit_globals) {
3735 free_param_opts(&Globals.param_opt);
3736 apply_lp_set_cmdline();
3739 lp_do_parameter(-1, "idmap config * : backend", Globals.idmap_backend);
3741 /* We get sections first, so have to start 'behind' to make up */
3744 if (lp_config_backend_is_file()) {
3745 n2 = talloc_sub_basic(talloc_tos(), get_current_username(),
3746 current_user_info.domain,
3749 smb_panic("lp_load_ex: out of memory");
3752 add_to_file_list(NULL, &file_lists, pszFname, n2);
3754 bRetval = pm_process(n2, lp_do_section, do_parameter, lp_ctx);
3757 /* finish up the last section */
3758 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
3760 if (iServiceIndex >= 0) {
3761 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
3765 if (lp_config_backend_is_registry()) {
3767 /* config backend changed to registry in config file */
3769 * We need to use this extra global variable here to
3770 * survive restart: init_globals uses this as a default
3771 * for config_backend. Otherwise, init_globals would
3772 * send us into an endless loop here.
3775 config_backend = CONFIG_BACKEND_REGISTRY;
3777 DEBUG(1, ("lp_load_ex: changing to config backend "
3779 init_globals(lp_ctx, true);
3781 TALLOC_FREE(lp_ctx);
3783 lp_kill_all_services();
3784 ok = lp_load_ex(pszFname, global_only, save_defaults,
3785 add_ipc, reinit_globals,
3786 allow_include_registry,
3791 } else if (lp_config_backend_is_registry()) {
3792 bRetval = process_registry_globals();
3794 DEBUG(0, ("Illegal config backend given: %d\n",
3795 lp_config_backend()));
3799 if (bRetval && lp_registry_shares()) {
3800 if (load_all_shares) {
3801 bRetval = process_registry_shares();
3803 bRetval = reload_registry_shares();
3808 char *serv = lp_auto_services(talloc_tos());
3809 lp_add_auto_services(serv);
3814 /* When 'restrict anonymous = 2' guest connections to ipc$
3816 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
3817 if ( lp_enable_asu_support() ) {
3818 lp_add_ipc("ADMIN$", false);
3822 set_allowed_client_auth();
3824 if (lp_security() == SEC_ADS && strchr(lp_password_server(), ':')) {
3825 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
3826 lp_password_server()));
3831 /* Now we check we_are_a_wins_server and set szWINSserver to 127.0.0.1 */
3832 /* if we_are_a_wins_server is true and we are in the client */
3833 if (lp_is_in_client() && Globals.we_are_a_wins_server) {
3834 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
3839 fault_configure(smb_panic_s3);
3842 * We run this check once the whole smb.conf is parsed, to
3843 * force some settings for the standard way a AD DC is
3844 * operated. We may change these as our code evolves, which
3845 * is why we force these settings.
3847 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
3848 lp_enforce_ad_dc_settings();
3851 bAllowIncludeRegistry = true;
3857 static bool lp_load(const char *pszFname,
3861 bool reinit_globals)
3863 return lp_load_ex(pszFname,
3868 true, /* allow_include_registry */
3869 false); /* load_all_shares*/
3872 bool lp_load_initial_only(const char *pszFname)
3874 return lp_load_ex(pszFname,
3875 true, /* global only */
3876 true, /* save_defaults */
3877 false, /* add_ipc */
3878 true, /* reinit_globals */
3879 false, /* allow_include_registry */
3880 false); /* load_all_shares*/
3884 * most common lp_load wrapper, loading only the globals
3886 bool lp_load_global(const char *file_name)
3888 return lp_load(file_name,
3889 true, /* global_only */
3890 false, /* save_defaults */
3891 false, /* add_ipc */
3892 true); /* reinit_globals */
3896 * The typical lp_load wrapper with shares, loads global and
3897 * shares, including IPC, but does not force immediate
3898 * loading of all shares from registry.
3900 bool lp_load_with_shares(const char *file_name)
3902 return lp_load(file_name,
3903 false, /* global_only */
3904 false, /* save_defaults */
3906 true); /* reinit_globals */
3910 * lp_load wrapper, especially for clients
3912 bool lp_load_client(const char *file_name)
3914 lp_set_in_client(true);
3916 return lp_load_global(file_name);
3920 * lp_load wrapper, loading only globals, but intended
3921 * for subsequent calls, not reinitializing the globals
3924 bool lp_load_global_no_reinit(const char *file_name)
3926 return lp_load(file_name,
3927 true, /* global_only */
3928 false, /* save_defaults */
3929 false, /* add_ipc */
3930 false); /* reinit_globals */
3934 * lp_load wrapper, loading globals and shares,
3935 * intended for subsequent calls, i.e. not reinitializing
3936 * the globals to default values.
3938 bool lp_load_no_reinit(const char *file_name)
3940 return lp_load(file_name,
3941 false, /* global_only */
3942 false, /* save_defaults */
3943 false, /* add_ipc */
3944 false); /* reinit_globals */
3949 * lp_load wrapper, especially for clients, no reinitialization
3951 bool lp_load_client_no_reinit(const char *file_name)
3953 lp_set_in_client(true);
3955 return lp_load_global_no_reinit(file_name);
3958 bool lp_load_with_registry_shares(const char *pszFname)
3960 return lp_load_ex(pszFname,
3961 false, /* global_only */
3962 true, /* save_defaults */
3963 false, /* add_ipc */
3964 false, /* reinit_globals */
3965 true, /* allow_include_registry */
3966 true); /* load_all_shares*/
3969 /***************************************************************************
3970 Return the max number of services.
3971 ***************************************************************************/
3973 int lp_numservices(void)
3975 return (iNumServices);
3978 /***************************************************************************
3979 Display the contents of the services array in human-readable form.
3980 ***************************************************************************/
3982 void lp_dump(FILE *f, bool show_defaults, int maxtoprint)
3985 struct loadparm_context *lp_ctx;
3988 defaults_saved = false;
3990 lp_ctx = setup_lp_context(talloc_tos());
3991 if (lp_ctx == NULL) {
3995 lpcfg_dump_globals(lp_ctx, f, !defaults_saved);
3997 lpcfg_dump_a_service(&sDefault, &sDefault, f, flags_list, show_defaults);
3999 for (iService = 0; iService < maxtoprint; iService++) {
4001 lp_dump_one(f, show_defaults, iService);
4005 /***************************************************************************
4006 Display the contents of one service in human-readable form.
4007 ***************************************************************************/
4009 void lp_dump_one(FILE * f, bool show_defaults, int snum)
4012 if (ServicePtrs[snum]->szService[0] == '\0')
4014 lpcfg_dump_a_service(ServicePtrs[snum], &sDefault, f,
4015 flags_list, show_defaults);
4019 /***************************************************************************
4020 Return the number of the service with the given name, or -1 if it doesn't
4021 exist. Note that this is a DIFFERENT ANIMAL from the internal function
4022 getservicebyname()! This works ONLY if all services have been loaded, and
4023 does not copy the found service.
4024 ***************************************************************************/
4026 int lp_servicenumber(const char *pszServiceName)
4029 fstring serviceName;
4031 if (!pszServiceName) {
4032 return GLOBAL_SECTION_SNUM;
4035 for (iService = iNumServices - 1; iService >= 0; iService--) {
4036 if (VALID(iService) && ServicePtrs[iService]->szService) {
4038 * The substitution here is used to support %U in
4041 fstrcpy(serviceName, ServicePtrs[iService]->szService);
4042 standard_sub_basic(get_current_username(),
4043 current_user_info.domain,
4044 serviceName,sizeof(serviceName));
4045 if (strequal(serviceName, pszServiceName)) {
4051 if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
4052 struct timespec last_mod;
4054 if (!usershare_exists(iService, &last_mod)) {
4055 /* Remove the share security tdb entry for it. */
4056 delete_share_security(lp_servicename(talloc_tos(), iService));
4057 /* Remove it from the array. */
4058 free_service_byindex(iService);
4059 /* Doesn't exist anymore. */
4060 return GLOBAL_SECTION_SNUM;
4063 /* Has it been modified ? If so delete and reload. */
4064 if (timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
4066 /* Remove it from the array. */
4067 free_service_byindex(iService);
4068 /* and now reload it. */
4069 iService = load_usershare_service(pszServiceName);
4074 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
4075 return GLOBAL_SECTION_SNUM;
4081 /*******************************************************************
4082 A useful volume label function.
4083 ********************************************************************/
4085 const char *volume_label(TALLOC_CTX *ctx, int snum)
4088 const char *label = lp_volume(ctx, snum);
4090 label = lp_servicename(ctx, snum);
4093 /* This returns a 33 byte guarenteed null terminated string. */
4094 ret = talloc_strndup(ctx, label, 32);
4101 /*******************************************************************
4102 Get the default server type we will announce as via nmbd.
4103 ********************************************************************/
4105 int lp_default_server_announce(void)
4107 int default_server_announce = 0;
4108 default_server_announce |= SV_TYPE_WORKSTATION;
4109 default_server_announce |= SV_TYPE_SERVER;
4110 default_server_announce |= SV_TYPE_SERVER_UNIX;
4112 /* note that the flag should be set only if we have a
4113 printer service but nmbd doesn't actually load the
4114 services so we can't tell --jerry */
4116 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
4118 default_server_announce |= SV_TYPE_SERVER_NT;
4119 default_server_announce |= SV_TYPE_NT;
4121 switch (lp_server_role()) {
4122 case ROLE_DOMAIN_MEMBER:
4123 default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
4125 case ROLE_DOMAIN_PDC:
4126 default_server_announce |= SV_TYPE_DOMAIN_CTRL;
4128 case ROLE_DOMAIN_BDC:
4129 default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
4131 case ROLE_STANDALONE:
4135 if (lp_time_server())
4136 default_server_announce |= SV_TYPE_TIME_SOURCE;
4138 if (lp_host_msdfs())
4139 default_server_announce |= SV_TYPE_DFS_SERVER;
4141 return default_server_announce;
4144 /***********************************************************
4145 If we are PDC then prefer us as DMB
4146 ************************************************************/
4148 bool lp_domain_master(void)
4150 if (Globals._domain_master == Auto)
4151 return (lp_server_role() == ROLE_DOMAIN_PDC);
4153 return (bool)Globals._domain_master;
4156 /***********************************************************
4157 If we are PDC then prefer us as DMB
4158 ************************************************************/
4160 static bool lp_domain_master_true_or_auto(void)
4162 if (Globals._domain_master) /* auto or yes */
4168 /***********************************************************
4169 If we are DMB then prefer us as LMB
4170 ************************************************************/
4172 bool lp_preferred_master(void)
4174 int preferred_master = lp__preferred_master();
4176 if (preferred_master == Auto)
4177 return (lp_local_master() && lp_domain_master());
4179 return (bool)preferred_master;
4182 /*******************************************************************
4184 ********************************************************************/
4186 void lp_remove_service(int snum)
4188 ServicePtrs[snum]->valid = false;
4191 const char *lp_printername(TALLOC_CTX *ctx, int snum)
4193 const char *ret = lp__printername(ctx, snum);
4194 if (ret == NULL || *ret == '\0') {
4195 ret = lp_const_servicename(snum);
4202 /***********************************************************
4203 Allow daemons such as winbindd to fix their logfile name.
4204 ************************************************************/
4206 void lp_set_logfile(const char *name)
4208 lpcfg_string_set(Globals.ctx, &Globals.logfile, name);
4209 debug_set_logfile(name);
4212 /*******************************************************************
4213 Return the max print jobs per queue.
4214 ********************************************************************/
4216 int lp_maxprintjobs(int snum)
4218 int maxjobs = lp_max_print_jobs(snum);
4220 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
4221 maxjobs = PRINT_MAX_JOBID - 1;
4226 const char *lp_printcapname(void)
4228 const char *printcap_name = lp_printcap_name();
4230 if ((printcap_name != NULL) &&
4231 (printcap_name[0] != '\0'))
4232 return printcap_name;
4234 if (sDefault.printing == PRINT_CUPS) {
4238 if (sDefault.printing == PRINT_BSD)
4239 return "/etc/printcap";
4241 return PRINTCAP_NAME;
4244 static uint32_t spoolss_state;
4246 bool lp_disable_spoolss( void )
4248 if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
4249 spoolss_state = lp__disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4251 return spoolss_state == SVCCTL_STOPPED ? true : false;
4254 void lp_set_spoolss_state( uint32_t state )
4256 SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
4258 spoolss_state = state;
4261 uint32_t lp_get_spoolss_state( void )
4263 return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4266 /*******************************************************************
4267 Ensure we don't use sendfile if server smb signing is active.
4268 ********************************************************************/
4270 bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state)
4272 bool sign_active = false;
4274 /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
4275 if (get_Protocol() < PROTOCOL_NT1) {
4278 if (signing_state) {
4279 sign_active = smb_signing_is_active(signing_state);
4281 return (lp__use_sendfile(snum) &&
4282 (get_remote_arch() != RA_WIN95) &&
4286 /*******************************************************************
4287 Turn off sendfile if we find the underlying OS doesn't support it.
4288 ********************************************************************/
4290 void set_use_sendfile(int snum, bool val)
4292 if (LP_SNUM_OK(snum))
4293 ServicePtrs[snum]->_use_sendfile = val;
4295 sDefault._use_sendfile = val;
4298 void lp_set_mangling_method(const char *new_method)
4300 lpcfg_string_set(Globals.ctx, &Globals.mangling_method, new_method);
4303 /*******************************************************************
4304 Global state for POSIX pathname processing.
4305 ********************************************************************/
4307 static bool posix_pathnames;
4309 bool lp_posix_pathnames(void)
4311 return posix_pathnames;
4314 /*******************************************************************
4315 Change everything needed to ensure POSIX pathname processing (currently
4317 ********************************************************************/
4319 void lp_set_posix_pathnames(void)
4321 posix_pathnames = true;
4324 /*******************************************************************
4325 Global state for POSIX lock processing - CIFS unix extensions.
4326 ********************************************************************/
4328 bool posix_default_lock_was_set;
4329 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
4331 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
4333 if (posix_default_lock_was_set) {
4334 return posix_cifsx_locktype;
4336 return (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
4337 POSIX_LOCK : WINDOWS_LOCK;
4341 /*******************************************************************
4342 ********************************************************************/
4344 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
4346 posix_default_lock_was_set = true;
4347 posix_cifsx_locktype = val;
4350 int lp_min_receive_file_size(void)
4352 int min_receivefile_size = lp_min_receivefile_size();
4354 if (min_receivefile_size < 0) {
4357 return min_receivefile_size;
4360 /*******************************************************************
4361 Safe wide links checks.
4362 This helper function always verify the validity of wide links,
4363 even after a configuration file reload.
4364 ********************************************************************/
4366 void widelinks_warning(int snum)
4368 if (lp_allow_insecure_wide_links()) {
4372 if (lp_unix_extensions() && lp_wide_links(snum)) {
4373 DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
4374 "These parameters are incompatible. "
4375 "Wide links will be disabled for this share.\n",
4376 lp_servicename(talloc_tos(), snum) ));
4380 bool lp_widelinks(int snum)
4382 /* wide links is always incompatible with unix extensions */
4383 if (lp_unix_extensions()) {
4385 * Unless we have "allow insecure widelinks"
4388 if (!lp_allow_insecure_wide_links()) {
4393 return lp_wide_links(snum);
4396 int lp_server_role(void)
4398 return lp_find_server_role(lp__server_role(),
4400 lp__domain_logons(),
4401 lp_domain_master_true_or_auto());
4404 int lp_security(void)
4406 return lp_find_security(lp__server_role(),
4410 int lp_client_max_protocol(void)
4412 int client_max_protocol = lp__client_max_protocol();
4413 if (client_max_protocol == PROTOCOL_DEFAULT) {
4414 return PROTOCOL_NT1;
4416 return client_max_protocol;
4419 int lp_winbindd_max_protocol(void)
4421 int client_max_protocol = lp__client_max_protocol();
4422 if (client_max_protocol == PROTOCOL_DEFAULT) {
4423 return PROTOCOL_LATEST;
4425 return client_max_protocol;
4428 struct loadparm_global * get_globals(void)
4433 unsigned int * get_flags(void)
4435 if (flags_list == NULL) {
4436 flags_list = talloc_zero_array(NULL, unsigned int, num_parameters());