2 Unix SMB/CIFS implementation.
3 Parameter loading functions
4 Copyright (C) Karl Auer 1993-1998
6 Largely re-written by Andrew Tridgell, September 1994
8 Copyright (C) Simo Sorce 2001
9 Copyright (C) Alexander Bokovoy 2002
10 Copyright (C) Stefan (metze) Metzmacher 2002
11 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
12 Copyright (C) Michael Adam 2008
13 Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
14 Copyright (C) Andrew Bartlett 2011
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program. If not, see <http://www.gnu.org/licenses/>.
33 * This module provides suitable callback functions for the params
34 * module. It builds the internal table of service details which is
35 * then used by the rest of the server.
39 * 1) add it to the global or service structure definition
40 * 2) add it to the parm_table
41 * 3) add it to the list of available functions (eg: using FN_GLOBAL_STRING())
42 * 4) If it's a global then initialise it in init_globals. If a local
43 * (ie. service) parameter then initialise it in the sDefault structure
47 * The configuration file is processed sequentially for speed. It is NOT
48 * accessed randomly as happens in 'real' Windows. For this reason, there
49 * is a fair bit of sequence-dependent code here - ie., code which assumes
50 * that certain things happen before others. In particular, the code which
51 * happens at the boundary between sections is delicately poised, so be
57 #include "system/filesys.h"
59 #include "lib/param/loadparm.h"
60 #include "lib/param/param.h"
62 #include "lib/smbconf/smbconf.h"
63 #include "lib/smbconf/smbconf_init.h"
66 #include "../librpc/gen_ndr/svcctl.h"
68 #include "../libcli/smb/smb_signing.h"
69 #include "dbwrap/dbwrap.h"
70 #include "dbwrap/dbwrap_rbt.h"
71 #include "../lib/util/bitmap.h"
72 #include "librpc/gen_ndr/nbt.h"
73 #include "source4/lib/tls/tls.h"
75 #ifdef HAVE_SYS_SYSCTL_H
76 #include <sys/sysctl.h>
81 extern userdom_struct current_user_info;
83 /* the special value for the include parameter
84 * to be interpreted not as a file name but to
85 * trigger loading of the global smb.conf options
87 #ifndef INCLUDE_REGISTRY_NAME
88 #define INCLUDE_REGISTRY_NAME "registry"
91 static bool in_client = false; /* Not in the client by default */
92 static struct smbconf_csn conf_last_csn;
94 static int config_backend = CONFIG_BACKEND_FILE;
96 /* some helpful bits */
97 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && \
98 (ServicePtrs != NULL) && \
99 (ServicePtrs[(i)] != NULL) && ServicePtrs[(i)]->valid)
100 #define VALID(i) ((ServicePtrs != NULL) && (ServicePtrs[i]!= NULL) && \
101 ServicePtrs[i]->valid)
103 #define USERSHARE_VALID 1
104 #define USERSHARE_PENDING_DELETE 2
106 static bool defaults_saved = false;
108 #include "lib/param/param_global.h"
110 static struct loadparm_global Globals;
112 /* This is a default service used to prime a services structure */
113 static struct loadparm_service sDefault =
118 .usershare_last_mod = {0, 0},
121 .invalid_users = NULL,
128 .root_preexec = NULL,
129 .root_postexec = NULL,
130 .cups_options = NULL,
131 .print_command = NULL,
133 .lprm_command = NULL,
134 .lppause_command = NULL,
135 .lpresume_command = NULL,
136 .queuepause_command = NULL,
137 .queueresume_command = NULL,
138 ._printername = NULL,
139 .printjob_username = NULL,
140 .dont_descend = NULL,
143 .magic_script = NULL,
144 .magic_output = NULL,
147 .veto_oplock_files = NULL,
157 .aio_write_behind = NULL,
158 .dfree_command = NULL,
159 .min_print_space = 0,
160 .max_print_jobs = 1000,
161 .max_reported_print_jobs = 0,
162 .write_cache_size = 0,
164 .force_create_mode = 0,
165 .directory_mask = 0755,
166 .force_directory_mode = 0,
167 .max_connections = 0,
168 .default_case = CASE_LOWER,
169 .printing = DEFAULT_PRINTING,
170 .oplock_contention_limit = 2,
173 .dfree_cache_time = 0,
174 .preexec_close = false,
175 .root_preexec_close = false,
176 .case_sensitive = Auto,
177 .preserve_case = true,
178 .short_preserve_case = true,
179 .hide_dot_files = true,
180 .hide_special_files = false,
181 .hide_unreadable = false,
182 .hide_unwriteable_files = false,
184 .access_based_share_enum = false,
189 .administrative_share = false,
192 .print_notify_backchannel = false,
196 .store_dos_attributes = false,
197 .dmapi_support = false,
199 .strict_locking = Auto,
200 .posix_locking = true,
202 .kernel_oplocks = false,
203 .level2_oplocks = true,
204 .mangled_names = true,
206 .follow_symlinks = true,
207 .sync_always = false,
208 .strict_allocate = false,
209 .strict_rename = false,
210 .strict_sync = false,
211 .mangling_char = '~',
213 .delete_readonly = false,
214 .fake_oplocks = false,
215 .delete_veto_files = false,
216 .dos_filemode = false,
217 .dos_filetimes = true,
218 .dos_filetime_resolution = false,
219 .fake_directory_create_times = false,
220 .blocking_locks = true,
221 .inherit_permissions = false,
222 .inherit_acls = false,
223 .inherit_owner = false,
225 .msdfs_shuffle_referrals = false,
226 .use_client_driver = false,
227 .default_devmode = true,
228 .force_printername = false,
229 .nt_acl_support = true,
230 .force_unknown_acl_user = false,
231 ._use_sendfile = false,
232 .profile_acls = false,
233 .map_acl_inherit = false,
236 .acl_check_permissions = true,
237 .acl_map_full_control = true,
238 .acl_group_control = false,
239 .acl_allow_execute_always = false,
240 .allocation_roundup_size = SMB_ROUNDUP_ALLOCATION_SIZE,
243 .map_readonly = MAP_READONLY_YES,
244 .directory_name_cache_size = 100,
245 .smb_encrypt = SMB_SIGNING_DEFAULT,
246 .kernel_share_modes = true,
247 .durable_handles = true,
252 /* local variables */
253 static struct loadparm_service **ServicePtrs = NULL;
254 static int iNumServices = 0;
255 static int iServiceIndex = 0;
256 static struct db_context *ServiceHash;
257 static bool bInGlobalSection = true;
258 static bool bGlobalOnly = false;
259 static struct file_lists *file_lists = NULL;
260 static unsigned int *flags_list = NULL;
262 static void set_allowed_client_auth(void);
264 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue);
265 static void free_param_opts(struct parmlist_entry **popts);
268 * Function to return the default value for the maximum number of open
269 * file descriptors permitted. This function tries to consult the
270 * kernel-level (sysctl) and ulimit (getrlimit()) values and goes
271 * the smaller of those.
273 static int max_open_files(void)
275 int sysctl_max = MAX_OPEN_FILES;
276 int rlimit_max = MAX_OPEN_FILES;
278 #ifdef HAVE_SYSCTLBYNAME
280 size_t size = sizeof(sysctl_max);
281 sysctlbyname("kern.maxfilesperproc", &sysctl_max, &size, NULL,
286 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
292 if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
293 rlimit_max = rl.rlim_cur;
295 #if defined(RLIM_INFINITY)
296 if(rl.rlim_cur == RLIM_INFINITY)
297 rlimit_max = MAX_OPEN_FILES;
302 if (sysctl_max < MIN_OPEN_FILES_WINDOWS) {
303 DEBUG(2,("max_open_files: increasing sysctl_max (%d) to "
304 "minimum Windows limit (%d)\n",
306 MIN_OPEN_FILES_WINDOWS));
307 sysctl_max = MIN_OPEN_FILES_WINDOWS;
310 if (rlimit_max < MIN_OPEN_FILES_WINDOWS) {
311 DEBUG(2,("rlimit_max: increasing rlimit_max (%d) to "
312 "minimum Windows limit (%d)\n",
314 MIN_OPEN_FILES_WINDOWS));
315 rlimit_max = MIN_OPEN_FILES_WINDOWS;
318 return MIN(sysctl_max, rlimit_max);
322 * Common part of freeing allocated data for one parameter.
324 static void free_one_parameter_common(void *parm_ptr,
325 struct parm_struct parm)
327 if ((parm.type == P_STRING) ||
328 (parm.type == P_USTRING))
330 lpcfg_string_free((char**)parm_ptr);
331 } else if (parm.type == P_LIST || parm.type == P_CMDLIST) {
332 TALLOC_FREE(*((char***)parm_ptr));
337 * Free the allocated data for one parameter for a share
338 * given as a service struct.
340 static void free_one_parameter(struct loadparm_service *service,
341 struct parm_struct parm)
345 if (parm.p_class != P_LOCAL) {
349 parm_ptr = lp_parm_ptr(service, &parm);
351 free_one_parameter_common(parm_ptr, parm);
355 * Free the allocated parameter data of a share given
356 * as a service struct.
358 static void free_parameters(struct loadparm_service *service)
362 for (i=0; parm_table[i].label; i++) {
363 free_one_parameter(service, parm_table[i]);
368 * Free the allocated data for one parameter for a given share
369 * specified by an snum.
371 static void free_one_parameter_by_snum(int snum, struct parm_struct parm)
376 parm_ptr = lp_parm_ptr(NULL, &parm);
377 } else if (parm.p_class != P_LOCAL) {
380 parm_ptr = lp_parm_ptr(ServicePtrs[snum], &parm);
383 free_one_parameter_common(parm_ptr, parm);
387 * Free the allocated parameter data for a share specified
390 static void free_parameters_by_snum(int snum)
394 for (i=0; parm_table[i].label; i++) {
395 free_one_parameter_by_snum(snum, parm_table[i]);
400 * Free the allocated global parameters.
402 static void free_global_parameters(void)
405 struct parm_struct *parm;
407 free_param_opts(&Globals.param_opt);
408 free_parameters_by_snum(GLOBAL_SECTION_SNUM);
410 /* Reset references in the defaults because the context is going to be freed */
411 for (i=0; parm_table[i].label; i++) {
412 parm = &parm_table[i];
413 if ((parm->type == P_STRING) ||
414 (parm->type == P_USTRING)) {
415 if ((parm->def.svalue != NULL) &&
416 (*(parm->def.svalue) != '\0')) {
417 if (talloc_parent(parm->def.svalue) == Globals.ctx) {
418 parm->def.svalue = NULL;
423 TALLOC_FREE(Globals.ctx);
426 struct lp_stored_option {
427 struct lp_stored_option *prev, *next;
432 static struct lp_stored_option *stored_options;
435 save options set by lp_set_cmdline() into a list. This list is
436 re-applied when we do a globals reset, so that cmdline set options
437 are sticky across reloads of smb.conf
439 bool store_lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
441 struct lp_stored_option *entry, *entry_next;
442 for (entry = stored_options; entry != NULL; entry = entry_next) {
443 entry_next = entry->next;
444 if (strcmp(pszParmName, entry->label) == 0) {
445 DLIST_REMOVE(stored_options, entry);
451 entry = talloc(NULL, struct lp_stored_option);
456 entry->label = talloc_strdup(entry, pszParmName);
462 entry->value = talloc_strdup(entry, pszParmValue);
468 DLIST_ADD_END(stored_options, entry);
473 static bool apply_lp_set_cmdline(void)
475 struct lp_stored_option *entry = NULL;
476 for (entry = stored_options; entry != NULL; entry = entry->next) {
477 if (!lp_set_cmdline_helper(entry->label, entry->value)) {
478 DEBUG(0, ("Failed to re-apply cmdline parameter %s = %s\n",
479 entry->label, entry->value));
486 /***************************************************************************
487 Initialise the global parameter structure.
488 ***************************************************************************/
490 static void init_globals(struct loadparm_context *lp_ctx, bool reinit_globals)
492 static bool done_init = false;
496 /* If requested to initialize only once and we've already done it... */
497 if (!reinit_globals && done_init) {
498 /* ... then we have nothing more to do */
503 /* The logfile can be set before this is invoked. Free it if so. */
504 lpcfg_string_free(&Globals.logfile);
507 free_global_parameters();
510 /* This memset and the free_global_parameters() above will
511 * wipe out smb.conf options set with lp_set_cmdline(). The
512 * apply_lp_set_cmdline() call puts these values back in the
513 * table once the defaults are set */
514 ZERO_STRUCT(Globals);
516 Globals.ctx = talloc_pooled_object(NULL, char, 272, 2048);
518 /* Initialize the flags list if necessary */
519 if (flags_list == NULL) {
523 for (i = 0; parm_table[i].label; i++) {
524 if ((parm_table[i].type == P_STRING ||
525 parm_table[i].type == P_USTRING))
529 (char **)lp_parm_ptr(NULL, &parm_table[i]),
535 lpcfg_string_set(Globals.ctx, &sDefault.fstype, FSTYPE_STRING);
536 lpcfg_string_set(Globals.ctx, &sDefault.printjob_username, "%U");
538 init_printer_values(lp_ctx, Globals.ctx, &sDefault);
540 sDefault.ntvfs_handler = str_list_make_v3_const(NULL, "unixuid default", NULL);
542 DEBUG(3, ("Initialising global parameters\n"));
544 /* Must manually force to upper case here, as this does not go via the handler */
545 lpcfg_string_set(Globals.ctx, &Globals.netbios_name,
548 lpcfg_string_set(Globals.ctx, &Globals.smb_passwd_file,
549 get_dyn_SMB_PASSWD_FILE());
550 lpcfg_string_set(Globals.ctx, &Globals.private_dir,
551 get_dyn_PRIVATE_DIR());
553 /* use the new 'hash2' method by default, with a prefix of 1 */
554 lpcfg_string_set(Globals.ctx, &Globals.mangling_method, "hash2");
555 Globals.mangle_prefix = 1;
557 lpcfg_string_set(Globals.ctx, &Globals.guest_account, GUEST_ACCOUNT);
559 /* using UTF8 by default allows us to support all chars */
560 lpcfg_string_set(Globals.ctx, &Globals.unix_charset,
561 DEFAULT_UNIX_CHARSET);
563 /* Use codepage 850 as a default for the dos character set */
564 lpcfg_string_set(Globals.ctx, &Globals.dos_charset,
565 DEFAULT_DOS_CHARSET);
568 * Allow the default PASSWD_CHAT to be overridden in local.h.
570 lpcfg_string_set(Globals.ctx, &Globals.passwd_chat,
571 DEFAULT_PASSWD_CHAT);
573 lpcfg_string_set(Globals.ctx, &Globals.workgroup, DEFAULT_WORKGROUP);
575 lpcfg_string_set(Globals.ctx, &Globals.passwd_program, "");
576 lpcfg_string_set(Globals.ctx, &Globals.lock_directory,
578 lpcfg_string_set(Globals.ctx, &Globals.state_directory,
580 lpcfg_string_set(Globals.ctx, &Globals.cache_directory,
582 lpcfg_string_set(Globals.ctx, &Globals.pid_directory,
584 lpcfg_string_set(Globals.ctx, &Globals.nbt_client_socket_address,
587 * By default support explicit binding to broadcast
590 Globals.nmbd_bind_explicit_broadcast = true;
592 s = talloc_asprintf(talloc_tos(), "Samba %s", samba_version_string());
594 smb_panic("init_globals: ENOMEM");
596 lpcfg_string_set(Globals.ctx, &Globals.server_string, s);
599 lpcfg_string_set(Globals.ctx, &Globals.panic_action,
600 "/bin/sleep 999999999");
603 lpcfg_string_set(Globals.ctx, &Globals.socket_options,
604 DEFAULT_SOCKET_OPTIONS);
606 lpcfg_string_set(Globals.ctx, &Globals.logon_drive, "");
607 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
608 lpcfg_string_set(Globals.ctx, &Globals.logon_home, "\\\\%N\\%U");
609 lpcfg_string_set(Globals.ctx, &Globals.logon_path,
610 "\\\\%N\\%U\\profile");
612 Globals.name_resolve_order = str_list_make_v3_const(NULL, "lmhosts wins host bcast", NULL);
613 lpcfg_string_set(Globals.ctx, &Globals.password_server, "*");
615 Globals.algorithmic_rid_base = BASE_RID;
617 Globals.load_printers = true;
618 Globals.printcap_cache_time = 750; /* 12.5 minutes */
620 Globals.config_backend = config_backend;
621 Globals._server_role = ROLE_AUTO;
623 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
624 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
625 Globals.max_xmit = 0x4104;
626 Globals.max_mux = 50; /* This is *needed* for profile support. */
627 Globals.lpq_cache_time = 30; /* changed to handle large print servers better -- jerry */
628 Globals._disable_spoolss = false;
629 Globals.max_smbd_processes = 0;/* no limit specified */
630 Globals.username_level = 0;
631 Globals.deadtime = 0;
632 Globals.getwd_cache = true;
633 Globals.large_readwrite = true;
634 Globals.max_log_size = 5000;
635 Globals.max_open_files = max_open_files();
636 Globals.server_max_protocol = PROTOCOL_SMB3_11;
637 Globals.server_min_protocol = PROTOCOL_LANMAN1;
638 Globals._client_max_protocol = PROTOCOL_DEFAULT;
639 Globals.client_min_protocol = PROTOCOL_CORE;
640 Globals._client_ipc_max_protocol = PROTOCOL_DEFAULT;
641 Globals._client_ipc_min_protocol = PROTOCOL_DEFAULT;
642 Globals._security = SEC_AUTO;
643 Globals.encrypt_passwords = true;
644 Globals.client_schannel = Auto;
645 Globals.winbind_sealed_pipes = true;
646 Globals.require_strong_key = true;
647 Globals.server_schannel = Auto;
648 Globals.read_raw = true;
649 Globals.write_raw = true;
650 Globals.null_passwords = false;
651 Globals.old_password_allowed_period = 60;
652 Globals.obey_pam_restrictions = false;
654 Globals.syslog_only = false;
655 Globals.timestamp_logs = true;
656 lpcfg_string_set(Globals.ctx, &Globals.log_level, "0");
657 Globals.debug_prefix_timestamp = false;
658 Globals.debug_hires_timestamp = true;
659 Globals.debug_pid = false;
660 Globals.debug_uid = false;
661 Globals.debug_class = false;
662 Globals.enable_core_files = true;
663 Globals.max_ttl = 60 * 60 * 24 * 3; /* 3 days default. */
664 Globals.max_wins_ttl = 60 * 60 * 24 * 6; /* 6 days default. */
665 Globals.min_wins_ttl = 60 * 60 * 6; /* 6 hours default. */
666 Globals.machine_password_timeout = 60 * 60 * 24 * 7; /* 7 days default. */
667 Globals.lm_announce = Auto; /* = Auto: send only if LM clients found */
668 Globals.lm_interval = 60;
669 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
670 Globals.nis_homedir = false;
671 #ifdef WITH_NISPLUS_HOME
672 lpcfg_string_set(Globals.ctx, &Globals.homedir_map,
673 "auto_home.org_dir");
675 lpcfg_string_set(Globals.ctx, &Globals.homedir_map, "auto.home");
678 Globals.time_server = false;
679 Globals.bind_interfaces_only = false;
680 Globals.unix_password_sync = false;
681 Globals.pam_password_change = false;
682 Globals.passwd_chat_debug = false;
683 Globals.passwd_chat_timeout = 2; /* 2 second default. */
684 Globals.nt_pipe_support = true; /* Do NT pipes by default. */
685 Globals.nt_status_support = true; /* Use NT status by default. */
686 Globals.smbd_profiling_level = 0;
687 Globals.stat_cache = true; /* use stat cache by default */
688 Globals.max_stat_cache_size = 256; /* 256k by default */
689 Globals.restrict_anonymous = 0;
690 Globals.client_lanman_auth = false; /* Do NOT use the LanMan hash if it is available */
691 Globals.client_plaintext_auth = false; /* Do NOT use a plaintext password even if is requested by the server */
692 Globals.lanman_auth = false; /* Do NOT use the LanMan hash, even if it is supplied */
693 Globals.ntlm_auth = false; /* Do NOT use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
694 Globals.raw_ntlmv2_auth = false; /* Reject NTLMv2 without NTLMSSP */
695 Globals.client_ntlmv2_auth = true; /* Client should always use use NTLMv2, as we can't tell that the server supports it, but most modern servers do */
696 /* Note, that we will also use NTLM2 session security (which is different), if it is available */
698 Globals.allow_dcerpc_auth_level_connect = false; /* we don't allow this by default */
700 Globals.map_to_guest = 0; /* By Default, "Never" */
701 Globals.oplock_break_wait_time = 0; /* By Default, 0 msecs. */
702 Globals.enhanced_browsing = true;
703 Globals.lock_spin_time = WINDOWS_MINIMUM_LOCK_TIMEOUT_MS; /* msec. */
704 #ifdef MMAP_BLACKLIST
705 Globals.use_mmap = false;
707 Globals.use_mmap = true;
709 Globals.unicode = true;
710 Globals.unix_extensions = true;
711 Globals.reset_on_zero_vc = false;
712 Globals.log_writeable_files_on_exit = false;
713 Globals.create_krb5_conf = true;
714 Globals.include_system_krb5_conf = true;
715 Globals._winbind_max_domain_connections = 1;
717 /* hostname lookups can be very expensive and are broken on
718 a large number of sites (tridge) */
719 Globals.hostname_lookups = false;
721 Globals.change_notify = true,
722 Globals.kernel_change_notify = true,
724 lpcfg_string_set(Globals.ctx, &Globals.passdb_backend, "tdbsam");
725 lpcfg_string_set(Globals.ctx, &Globals.ldap_suffix, "");
726 lpcfg_string_set(Globals.ctx, &Globals._ldap_machine_suffix, "");
727 lpcfg_string_set(Globals.ctx, &Globals._ldap_user_suffix, "");
728 lpcfg_string_set(Globals.ctx, &Globals._ldap_group_suffix, "");
729 lpcfg_string_set(Globals.ctx, &Globals._ldap_idmap_suffix, "");
731 lpcfg_string_set(Globals.ctx, &Globals.ldap_admin_dn, "");
732 Globals.ldap_ssl = LDAP_SSL_START_TLS;
733 Globals.ldap_ssl_ads = false;
734 Globals.ldap_deref = -1;
735 Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
736 Globals.ldap_delete_dn = false;
737 Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
738 Globals.ldap_follow_referral = Auto;
739 Globals.ldap_timeout = LDAP_DEFAULT_TIMEOUT;
740 Globals.ldap_connection_timeout = LDAP_CONNECTION_DEFAULT_TIMEOUT;
741 Globals.ldap_page_size = LDAP_PAGE_SIZE;
743 Globals.ldap_debug_level = 0;
744 Globals.ldap_debug_threshold = 10;
746 Globals.client_ldap_sasl_wrapping = ADS_AUTH_SASL_SIGN;
748 Globals.ldap_server_require_strong_auth =
749 LDAP_SERVER_REQUIRE_STRONG_AUTH_YES;
751 /* This is what we tell the afs client. in reality we set the token
752 * to never expire, though, when this runs out the afs client will
753 * forget the token. Set to 0 to get NEVERDATE.*/
754 Globals.afs_token_lifetime = 604800;
755 Globals.cups_connection_timeout = CUPS_DEFAULT_CONNECTION_TIMEOUT;
757 /* these parameters are set to defaults that are more appropriate
758 for the increasing samba install base:
760 as a member of the workgroup, that will possibly become a
761 _local_ master browser (lm = true). this is opposed to a forced
762 local master browser startup (pm = true).
764 doesn't provide WINS server service by default (wsupp = false),
765 and doesn't provide domain master browser services by default, either.
769 Globals.show_add_printer_wizard = true;
770 Globals.os_level = 20;
771 Globals.local_master = true;
772 Globals._domain_master = Auto; /* depending on _domain_logons */
773 Globals._domain_logons = false;
774 Globals.browse_list = true;
775 Globals.we_are_a_wins_server = false;
776 Globals.wins_proxy = false;
778 TALLOC_FREE(Globals.init_logon_delayed_hosts);
779 Globals.init_logon_delay = 100; /* 100 ms default delay */
781 Globals.wins_dns_proxy = true;
783 Globals.allow_trusted_domains = true;
784 lpcfg_string_set(Globals.ctx, &Globals.idmap_backend, "tdb");
786 lpcfg_string_set(Globals.ctx, &Globals.template_shell, "/bin/false");
787 lpcfg_string_set(Globals.ctx, &Globals.template_homedir,
789 lpcfg_string_set(Globals.ctx, &Globals.winbind_separator, "\\");
790 lpcfg_string_set(Globals.ctx, &Globals.winbindd_socket_directory,
791 dyn_WINBINDD_SOCKET_DIR);
793 lpcfg_string_set(Globals.ctx, &Globals.cups_server, "");
794 lpcfg_string_set(Globals.ctx, &Globals.iprint_server, "");
796 lpcfg_string_set(Globals.ctx, &Globals._ctdbd_socket, "");
798 Globals.cluster_addresses = NULL;
799 Globals.clustering = false;
800 Globals.ctdb_timeout = 0;
801 Globals.ctdb_locktime_warn_threshold = 0;
803 Globals.winbind_cache_time = 300; /* 5 minutes */
804 Globals.winbind_reconnect_delay = 30; /* 30 seconds */
805 Globals.winbind_request_timeout = 60; /* 60 seconds */
806 Globals.winbind_max_clients = 200;
807 Globals.winbind_enum_users = false;
808 Globals.winbind_enum_groups = false;
809 Globals.winbind_use_default_domain = false;
810 Globals.winbind_trusted_domains_only = false;
811 Globals.winbind_nested_groups = true;
812 Globals.winbind_expand_groups = 0;
813 Globals.winbind_nss_info = str_list_make_v3_const(NULL, "template", NULL);
814 Globals.winbind_refresh_tickets = false;
815 Globals.winbind_offline_logon = false;
817 Globals.idmap_cache_time = 86400 * 7; /* a week by default */
818 Globals.idmap_negative_cache_time = 120; /* 2 minutes by default */
820 Globals.passdb_expand_explicit = false;
822 Globals.name_cache_timeout = 660; /* In seconds */
824 Globals.use_spnego = true;
825 Globals.client_use_spnego = true;
827 Globals.client_signing = SMB_SIGNING_DEFAULT;
828 Globals._client_ipc_signing = SMB_SIGNING_DEFAULT;
829 Globals.server_signing = SMB_SIGNING_DEFAULT;
831 Globals.defer_sharing_violations = true;
832 Globals.smb_ports = str_list_make_v3_const(NULL, SMB_PORTS, NULL);
834 Globals.enable_privileges = true;
835 Globals.host_msdfs = true;
836 Globals.enable_asu_support = false;
838 /* User defined shares. */
839 s = talloc_asprintf(talloc_tos(), "%s/usershares", get_dyn_STATEDIR());
841 smb_panic("init_globals: ENOMEM");
843 lpcfg_string_set(Globals.ctx, &Globals.usershare_path, s);
845 lpcfg_string_set(Globals.ctx, &Globals.usershare_template_share, "");
846 Globals.usershare_max_shares = 0;
847 /* By default disallow sharing of directories not owned by the sharer. */
848 Globals.usershare_owner_only = true;
849 /* By default disallow guest access to usershares. */
850 Globals.usershare_allow_guests = false;
852 Globals.keepalive = DEFAULT_KEEPALIVE;
854 /* By default no shares out of the registry */
855 Globals.registry_shares = false;
857 Globals.min_receivefile_size = 0;
859 Globals.map_untrusted_to_domain = false;
860 Globals.multicast_dns_register = true;
862 Globals.smb2_max_read = DEFAULT_SMB2_MAX_READ;
863 Globals.smb2_max_write = DEFAULT_SMB2_MAX_WRITE;
864 Globals.smb2_max_trans = DEFAULT_SMB2_MAX_TRANSACT;
865 Globals.smb2_max_credits = DEFAULT_SMB2_MAX_CREDITS;
866 Globals.smb2_leases = true;
868 lpcfg_string_set(Globals.ctx, &Globals.ncalrpc_dir,
869 get_dyn_NCALRPCDIR());
871 Globals.server_services = str_list_make_v3_const(NULL, "s3fs rpc nbt wrepl ldap cldap kdc drepl winbindd ntp_signd kcc dnsupdate dns", NULL);
873 Globals.dcerpc_endpoint_servers = str_list_make_v3_const(NULL, "epmapper wkssvc rpcecho samr netlogon lsarpc drsuapi dssetup unixinfo browser eventlog6 backupkey dnsserver", NULL);
875 Globals.tls_enabled = true;
876 Globals.tls_verify_peer = TLS_VERIFY_PEER_AS_STRICT_AS_POSSIBLE;
878 lpcfg_string_set(Globals.ctx, &Globals._tls_keyfile, "tls/key.pem");
879 lpcfg_string_set(Globals.ctx, &Globals._tls_certfile, "tls/cert.pem");
880 lpcfg_string_set(Globals.ctx, &Globals._tls_cafile, "tls/ca.pem");
881 lpcfg_string_set(Globals.ctx, &Globals.tls_priority,
882 "NORMAL:-VERS-SSL3.0");
884 lpcfg_string_set(Globals.ctx, &Globals.share_backend, "classic");
886 Globals._preferred_master = Auto;
888 Globals.allow_dns_updates = DNS_UPDATE_SIGNED;
890 lpcfg_string_set(Globals.ctx, &Globals.ntp_signd_socket_directory,
891 get_dyn_NTP_SIGND_SOCKET_DIR());
893 lpcfg_string_set(Globals.ctx,
894 &Globals.winbindd_privileged_socket_directory,
895 get_dyn_WINBINDD_PRIVILEGED_SOCKET_DIR());
897 s = talloc_asprintf(talloc_tos(), "%s/samba_kcc", get_dyn_SCRIPTSBINDIR());
899 smb_panic("init_globals: ENOMEM");
901 Globals.samba_kcc_command = str_list_make_v3_const(NULL, s, NULL);
904 s = talloc_asprintf(talloc_tos(), "%s/samba_dnsupdate", get_dyn_SCRIPTSBINDIR());
906 smb_panic("init_globals: ENOMEM");
908 Globals.dns_update_command = str_list_make_v3_const(NULL, s, NULL);
911 s = talloc_asprintf(talloc_tos(), "%s/samba_spnupdate", get_dyn_SCRIPTSBINDIR());
913 smb_panic("init_globals: ENOMEM");
915 Globals.spn_update_command = str_list_make_v3_const(NULL, s, NULL);
918 Globals.nsupdate_command = str_list_make_v3_const(NULL, "/usr/bin/nsupdate -g", NULL);
920 Globals.rndc_command = str_list_make_v3_const(NULL, "/usr/sbin/rndc", NULL);
922 Globals.cldap_port = 389;
924 Globals.dgram_port = NBT_DGRAM_SERVICE_PORT;
926 Globals.nbt_port = NBT_NAME_SERVICE_PORT;
928 Globals.krb5_port = 88;
930 Globals.kpasswd_port = 464;
932 Globals.web_port = 901;
934 Globals.aio_max_threads = 100;
936 /* Now put back the settings that were set with lp_set_cmdline() */
937 apply_lp_set_cmdline();
940 /* Convenience routine to setup an lp_context with additional s3 variables */
941 static struct loadparm_context *setup_lp_context(TALLOC_CTX *mem_ctx)
943 struct loadparm_context *lp_ctx;
945 lp_ctx = loadparm_init_s3(mem_ctx,
946 loadparm_s3_helpers());
947 if (lp_ctx == NULL) {
948 DEBUG(0, ("loadparm_init_s3 failed\n"));
952 lp_ctx->sDefault = &sDefault;
953 lp_ctx->services = NULL; /* We do not want to access this directly */
954 lp_ctx->bInGlobalSection = bInGlobalSection;
955 lp_ctx->flags = flags_list;
960 /*******************************************************************
961 Convenience routine to grab string parameters into talloced memory
962 and run standard_sub_basic on them. The buffers can be written to by
963 callers without affecting the source string.
964 ********************************************************************/
966 char *lp_string(TALLOC_CTX *ctx, const char *s)
970 /* The follow debug is useful for tracking down memory problems
971 especially if you have an inner loop that is calling a lp_*()
972 function that returns a string. Perhaps this debug should be
973 present all the time? */
976 DEBUG(10, ("lp_string(%s)\n", s));
982 ret = talloc_sub_basic(ctx,
983 get_current_username(),
984 current_user_info.domain,
986 if (trim_char(ret, '\"', '\"')) {
987 if (strchr(ret,'\"') != NULL) {
989 ret = talloc_sub_basic(ctx,
990 get_current_username(),
991 current_user_info.domain,
999 In this section all the functions that are used to access the
1000 parameters from the rest of the program are defined
1003 #define FN_GLOBAL_STRING(fn_name,ptr) \
1004 char *lp_ ## fn_name(TALLOC_CTX *ctx) {return(lp_string((ctx), *(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : ""));}
1005 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1006 const char *lp_ ## fn_name(void) {return(*(const char * const *)(&Globals.ptr) ? *(const char * const *)(&Globals.ptr) : "");}
1007 #define FN_GLOBAL_LIST(fn_name,ptr) \
1008 const char **lp_ ## fn_name(void) {return(*(const char ***)(&Globals.ptr));}
1009 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1010 bool lp_ ## fn_name(void) {return(*(bool *)(&Globals.ptr));}
1011 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1012 char lp_ ## fn_name(void) {return(*(char *)(&Globals.ptr));}
1013 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1014 int lp_ ## fn_name(void) {return(*(int *)(&Globals.ptr));}
1016 #define FN_LOCAL_STRING(fn_name,val) \
1017 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));}
1018 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1019 const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1020 #define FN_LOCAL_LIST(fn_name,val) \
1021 const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1022 #define FN_LOCAL_BOOL(fn_name,val) \
1023 bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1024 #define FN_LOCAL_INTEGER(fn_name,val) \
1025 int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1027 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1028 bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1029 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1030 int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1031 #define FN_LOCAL_PARM_CHAR(fn_name,val) \
1032 char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1034 int lp_winbind_max_domain_connections(void)
1036 if (lp_winbind_offline_logon() &&
1037 lp__winbind_max_domain_connections() > 1) {
1038 DEBUG(1, ("offline logons active, restricting max domain "
1039 "connections to 1\n"));
1042 return MAX(1, lp__winbind_max_domain_connections());
1045 /* These functions remain in source3/param for now */
1047 #include "lib/param/param_functions.c"
1049 FN_LOCAL_STRING(servicename, szService)
1050 FN_LOCAL_CONST_STRING(const_servicename, szService)
1052 /* These functions cannot be auto-generated */
1053 FN_LOCAL_BOOL(autoloaded, autoloaded)
1054 FN_GLOBAL_CONST_STRING(dnsdomain, dnsdomain)
1056 /* local prototypes */
1058 static int map_parameter_canonical(const char *pszParmName, bool *inverse);
1059 static const char *get_boolean(bool bool_value);
1060 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
1062 static bool hash_a_service(const char *name, int number);
1063 static void free_service_byindex(int iService);
1064 static void show_parameter(int parmIndex);
1065 static bool is_synonym_of(int parm1, int parm2, bool *inverse);
1066 static bool lp_parameter_value_is_valid(const char *parm_name, const char *val);
1069 * This is a helper function for parametrical options support. It returns a
1070 * pointer to parametrical option value if it exists or NULL otherwise. Actual
1071 * parametrical functions are quite simple
1073 static struct parmlist_entry *get_parametrics(int snum, const char *type,
1076 if (snum >= iNumServices) return NULL;
1079 return get_parametric_helper(NULL, type, option, Globals.param_opt);
1081 return get_parametric_helper(ServicePtrs[snum],
1082 type, option, Globals.param_opt);
1086 static void discard_whitespace(char *str)
1088 size_t len = strlen(str);
1092 if (isspace(str[i])) {
1093 memmove(&str[i], &str[i+1], len-i);
1102 * @brief Go through all global parametric parameters
1104 * @param regex_str A regular expression to scan param for
1105 * @param max_matches Max number of submatches the regexp expects
1106 * @param cb Function to call on match. Should return true
1107 * when it wants wi_scan_global_parametrics to stop
1109 * @param private_data Anonymous pointer passed to cb
1111 * @return 0: success, regcomp/regexec return value on error.
1112 * See "man regexec" for possible errors
1115 int lp_wi_scan_global_parametrics(
1116 const char *regex_str, size_t max_matches,
1117 bool (*cb)(const char *string, regmatch_t matches[],
1118 void *private_data),
1121 struct parmlist_entry *data;
1125 ret = regcomp(®ex, regex_str, REG_ICASE);
1130 for (data = Globals.param_opt; data != NULL; data = data->next) {
1131 size_t keylen = strlen(data->key);
1133 regmatch_t matches[max_matches];
1136 memcpy(key, data->key, sizeof(key));
1137 discard_whitespace(key);
1139 ret = regexec(®ex, key, max_matches, matches, 0);
1140 if (ret == REG_NOMATCH) {
1147 stop = cb(key, matches, private_data);
1160 #define MISSING_PARAMETER(name) \
1161 DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
1163 /*******************************************************************
1164 convenience routine to return enum parameters.
1165 ********************************************************************/
1166 static int lp_enum(const char *s,const struct enum_list *_enum)
1170 if (!s || !*s || !_enum) {
1171 MISSING_PARAMETER(lp_enum);
1175 for (i=0; _enum[i].name; i++) {
1176 if (strequal(_enum[i].name,s))
1177 return _enum[i].value;
1180 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
1184 #undef MISSING_PARAMETER
1186 /* Return parametric option from a given service. Type is a part of option before ':' */
1187 /* Parametric option has following syntax: 'Type: option = value' */
1188 char *lp_parm_talloc_string(TALLOC_CTX *ctx, int snum, const char *type, const char *option, const char *def)
1190 struct parmlist_entry *data = get_parametrics(snum, type, option);
1192 if (data == NULL||data->value==NULL) {
1194 return lp_string(ctx, def);
1200 return lp_string(ctx, data->value);
1203 /* Return parametric option from a given service. Type is a part of option before ':' */
1204 /* Parametric option has following syntax: 'Type: option = value' */
1205 const char *lp_parm_const_string(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)
1216 /* Return parametric option from a given service. Type is a part of option before ':' */
1217 /* Parametric option has following syntax: 'Type: option = value' */
1219 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
1221 struct parmlist_entry *data = get_parametrics(snum, type, option);
1223 if (data == NULL||data->value==NULL)
1224 return (const char **)def;
1226 if (data->list==NULL) {
1227 data->list = str_list_make_v3(NULL, data->value, NULL);
1230 return discard_const_p(const char *, data->list);
1233 /* Return parametric option from a given service. Type is a part of option before ':' */
1234 /* Parametric option has following syntax: 'Type: option = value' */
1236 int lp_parm_int(int snum, const char *type, const char *option, int def)
1238 struct parmlist_entry *data = get_parametrics(snum, type, option);
1240 if (data && data->value && *data->value)
1241 return lp_int(data->value);
1246 /* Return parametric option from a given service. Type is a part of option before ':' */
1247 /* Parametric option has following syntax: 'Type: option = value' */
1249 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
1251 struct parmlist_entry *data = get_parametrics(snum, type, option);
1253 if (data && data->value && *data->value)
1254 return lp_ulong(data->value);
1259 /* Return parametric option from a given service. Type is a part of option before ':' */
1260 /* Parametric option has following syntax: 'Type: option = value' */
1262 unsigned long long lp_parm_ulonglong(int snum, const char *type,
1263 const char *option, unsigned long long def)
1265 struct parmlist_entry *data = get_parametrics(snum, type, option);
1267 if (data && data->value && *data->value) {
1268 return lp_ulonglong(data->value);
1274 /* Return parametric option from a given service. Type is a part of option
1276 /* Parametric option has following syntax: 'Type: option = value' */
1278 bool lp_parm_bool(int snum, const char *type, const char *option, bool def)
1280 struct parmlist_entry *data = get_parametrics(snum, type, option);
1282 if (data && data->value && *data->value)
1283 return lp_bool(data->value);
1288 /* Return parametric option from a given service. Type is a part of option before ':' */
1289 /* Parametric option has following syntax: 'Type: option = value' */
1291 int lp_parm_enum(int snum, const char *type, const char *option,
1292 const struct enum_list *_enum, int def)
1294 struct parmlist_entry *data = get_parametrics(snum, type, option);
1296 if (data && data->value && *data->value && _enum)
1297 return lp_enum(data->value, _enum);
1303 * free a param_opts structure.
1304 * param_opts handling should be moved to talloc;
1305 * then this whole functions reduces to a TALLOC_FREE().
1308 static void free_param_opts(struct parmlist_entry **popts)
1310 struct parmlist_entry *opt, *next_opt;
1312 if (*popts != NULL) {
1313 DEBUG(5, ("Freeing parametrics:\n"));
1316 while (opt != NULL) {
1317 lpcfg_string_free(&opt->key);
1318 lpcfg_string_free(&opt->value);
1319 TALLOC_FREE(opt->list);
1320 next_opt = opt->next;
1327 /***************************************************************************
1328 Free the dynamically allocated parts of a service struct.
1329 ***************************************************************************/
1331 static void free_service(struct loadparm_service *pservice)
1336 if (pservice->szService)
1337 DEBUG(5, ("free_service: Freeing service %s\n",
1338 pservice->szService));
1340 free_parameters(pservice);
1342 lpcfg_string_free(&pservice->szService);
1343 TALLOC_FREE(pservice->copymap);
1345 free_param_opts(&pservice->param_opt);
1347 ZERO_STRUCTP(pservice);
1351 /***************************************************************************
1352 remove a service indexed in the ServicePtrs array from the ServiceHash
1353 and free the dynamically allocated parts
1354 ***************************************************************************/
1356 static void free_service_byindex(int idx)
1358 if ( !LP_SNUM_OK(idx) )
1361 ServicePtrs[idx]->valid = false;
1363 /* we have to cleanup the hash record */
1365 if (ServicePtrs[idx]->szService) {
1366 char *canon_name = canonicalize_servicename(
1368 ServicePtrs[idx]->szService );
1370 dbwrap_delete_bystring(ServiceHash, canon_name );
1371 TALLOC_FREE(canon_name);
1374 free_service(ServicePtrs[idx]);
1375 TALLOC_FREE(ServicePtrs[idx]);
1378 /***************************************************************************
1379 Add a new service to the services array initialising it with the given
1381 ***************************************************************************/
1383 static int add_a_service(const struct loadparm_service *pservice, const char *name)
1386 struct loadparm_service **tsp = NULL;
1388 /* it might already exist */
1390 i = getservicebyname(name, NULL);
1396 /* Re use empty slots if any before allocating new one.*/
1397 for (i=0; i < iNumServices; i++) {
1398 if (ServicePtrs[i] == NULL) {
1402 if (i == iNumServices) {
1403 /* if not, then create one */
1404 tsp = talloc_realloc(NULL, ServicePtrs,
1405 struct loadparm_service *,
1408 DEBUG(0, ("add_a_service: failed to enlarge "
1415 ServicePtrs[i] = talloc_zero(ServicePtrs, struct loadparm_service);
1416 if (!ServicePtrs[i]) {
1417 DEBUG(0,("add_a_service: out of memory!\n"));
1421 ServicePtrs[i]->valid = true;
1423 copy_service(ServicePtrs[i], pservice, NULL);
1425 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->szService,
1428 DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
1429 i, ServicePtrs[i]->szService));
1431 if (!hash_a_service(ServicePtrs[i]->szService, i)) {
1438 /***************************************************************************
1439 Convert a string to uppercase and remove whitespaces.
1440 ***************************************************************************/
1442 char *canonicalize_servicename(TALLOC_CTX *ctx, const char *src)
1447 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
1451 result = talloc_strdup(ctx, src);
1452 SMB_ASSERT(result != NULL);
1454 if (!strlower_m(result)) {
1455 TALLOC_FREE(result);
1461 /***************************************************************************
1462 Add a name/index pair for the services array to the hash table.
1463 ***************************************************************************/
1465 static bool hash_a_service(const char *name, int idx)
1469 if ( !ServiceHash ) {
1470 DEBUG(10,("hash_a_service: creating servicehash\n"));
1471 ServiceHash = db_open_rbt(NULL);
1472 if ( !ServiceHash ) {
1473 DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
1478 DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
1481 canon_name = canonicalize_servicename(talloc_tos(), name );
1483 dbwrap_store_bystring(ServiceHash, canon_name,
1484 make_tdb_data((uint8_t *)&idx, sizeof(idx)),
1487 TALLOC_FREE(canon_name);
1492 /***************************************************************************
1493 Add a new home service, with the specified home directory, defaults coming
1495 ***************************************************************************/
1497 bool lp_add_home(const char *pszHomename, int iDefaultService,
1498 const char *user, const char *pszHomedir)
1502 if (pszHomename == NULL || user == NULL || pszHomedir == NULL ||
1503 pszHomedir[0] == '\0') {
1507 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
1512 if (!(*(ServicePtrs[iDefaultService]->path))
1513 || strequal(ServicePtrs[iDefaultService]->path,
1514 lp_path(talloc_tos(), GLOBAL_SECTION_SNUM))) {
1515 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path,
1519 if (!(*(ServicePtrs[i]->comment))) {
1520 char *comment = talloc_asprintf(talloc_tos(), "Home directory of %s", user);
1521 if (comment == NULL) {
1524 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment,
1526 TALLOC_FREE(comment);
1529 /* set the browseable flag from the global default */
1531 ServicePtrs[i]->browseable = sDefault.browseable;
1532 ServicePtrs[i]->access_based_share_enum = sDefault.access_based_share_enum;
1534 ServicePtrs[i]->autoloaded = true;
1536 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
1537 user, ServicePtrs[i]->path ));
1542 /***************************************************************************
1543 Add a new service, based on an old one.
1544 ***************************************************************************/
1546 int lp_add_service(const char *pszService, int iDefaultService)
1548 if (iDefaultService < 0) {
1549 return add_a_service(&sDefault, pszService);
1552 return (add_a_service(ServicePtrs[iDefaultService], pszService));
1555 /***************************************************************************
1556 Add the IPC service.
1557 ***************************************************************************/
1559 static bool lp_add_ipc(const char *ipc_name, bool guest_ok)
1561 char *comment = NULL;
1562 int i = add_a_service(&sDefault, ipc_name);
1567 comment = talloc_asprintf(talloc_tos(), "IPC Service (%s)",
1568 Globals.server_string);
1569 if (comment == NULL) {
1573 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->path, tmpdir());
1574 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1575 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->fstype, "IPC");
1576 ServicePtrs[i]->max_connections = 0;
1577 ServicePtrs[i]->available = true;
1578 ServicePtrs[i]->read_only = true;
1579 ServicePtrs[i]->guest_only = false;
1580 ServicePtrs[i]->administrative_share = true;
1581 ServicePtrs[i]->guest_ok = guest_ok;
1582 ServicePtrs[i]->printable = false;
1583 ServicePtrs[i]->browseable = sDefault.browseable;
1584 ServicePtrs[i]->autoloaded = true;
1586 DEBUG(3, ("adding IPC service\n"));
1588 TALLOC_FREE(comment);
1592 /***************************************************************************
1593 Add a new printer service, with defaults coming from service iFrom.
1594 ***************************************************************************/
1596 bool lp_add_printer(const char *pszPrintername, int iDefaultService)
1598 const char *comment = "From Printcap";
1599 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
1604 /* note that we do NOT default the availability flag to true - */
1605 /* we take it from the default service passed. This allows all */
1606 /* dynamic printers to be disabled by disabling the [printers] */
1607 /* entry (if/when the 'available' keyword is implemented!). */
1609 /* the printer name is set to the service name. */
1610 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->_printername,
1612 lpcfg_string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1614 /* set the browseable flag from the gloabl default */
1615 ServicePtrs[i]->browseable = sDefault.browseable;
1617 /* Printers cannot be read_only. */
1618 ServicePtrs[i]->read_only = false;
1619 /* No oplocks on printer services. */
1620 ServicePtrs[i]->oplocks = false;
1621 /* Printer services must be printable. */
1622 ServicePtrs[i]->printable = true;
1624 DEBUG(3, ("adding printer service %s\n", pszPrintername));
1630 /***************************************************************************
1631 Check whether the given parameter name is valid.
1632 Parametric options (names containing a colon) are considered valid.
1633 ***************************************************************************/
1635 bool lp_parameter_is_valid(const char *pszParmName)
1637 return ((lpcfg_map_parameter(pszParmName) != -1) ||
1638 (strchr(pszParmName, ':') != NULL));
1641 /***************************************************************************
1642 Check whether the given name is the name of a global parameter.
1643 Returns true for strings belonging to parameters of class
1644 P_GLOBAL, false for all other strings, also for parametric options
1645 and strings not belonging to any option.
1646 ***************************************************************************/
1648 bool lp_parameter_is_global(const char *pszParmName)
1650 int num = lpcfg_map_parameter(pszParmName);
1653 return (parm_table[num].p_class == P_GLOBAL);
1659 /**************************************************************************
1660 Determine the canonical name for a parameter.
1661 Indicate when it is an inverse (boolean) synonym instead of a
1663 **************************************************************************/
1665 bool lp_canonicalize_parameter(const char *parm_name, const char **canon_parm,
1670 if (!lp_parameter_is_valid(parm_name)) {
1675 num = map_parameter_canonical(parm_name, inverse);
1677 /* parametric option */
1678 *canon_parm = parm_name;
1680 *canon_parm = parm_table[num].label;
1687 /**************************************************************************
1688 Determine the canonical name for a parameter.
1689 Turn the value given into the inverse boolean expression when
1690 the synonym is an invers boolean synonym.
1693 - parm_name is a valid parameter name and
1694 - val is a valid value for this parameter and
1695 - in case the parameter is an inverse boolean synonym, if the val
1696 string could successfully be converted to the reverse bool.
1697 Return false in all other cases.
1698 **************************************************************************/
1700 bool lp_canonicalize_parameter_with_value(const char *parm_name,
1702 const char **canon_parm,
1703 const char **canon_val)
1709 if (!lp_parameter_is_valid(parm_name)) {
1715 num = map_parameter_canonical(parm_name, &inverse);
1717 /* parametric option */
1718 *canon_parm = parm_name;
1723 *canon_parm = parm_table[num].label;
1725 if (!lp_invert_boolean(val, canon_val)) {
1733 ret = lp_parameter_value_is_valid(*canon_parm, *canon_val);
1738 /***************************************************************************
1739 Map a parameter's string representation to the index of the canonical
1740 form of the parameter (it might be a synonym).
1741 Returns -1 if the parameter string is not recognised.
1742 ***************************************************************************/
1744 static int map_parameter_canonical(const char *pszParmName, bool *inverse)
1746 int parm_num, canon_num;
1747 bool loc_inverse = false;
1749 parm_num = lpcfg_map_parameter(pszParmName);
1750 if ((parm_num < 0) || !(parm_table[parm_num].flags & FLAG_SYNONYM)) {
1751 /* invalid, parametric or no canidate for synonyms ... */
1755 for (canon_num = 0; parm_table[canon_num].label; canon_num++) {
1756 if (is_synonym_of(parm_num, canon_num, &loc_inverse)) {
1757 parm_num = canon_num;
1763 if (inverse != NULL) {
1764 *inverse = loc_inverse;
1769 /***************************************************************************
1770 return true if parameter number parm1 is a synonym of parameter
1771 number parm2 (parm2 being the principal name).
1772 set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
1774 ***************************************************************************/
1776 static bool is_synonym_of(int parm1, int parm2, bool *inverse)
1778 if ((parm_table[parm1].offset == parm_table[parm2].offset) &&
1779 (parm_table[parm1].p_class == parm_table[parm2].p_class) &&
1780 (parm_table[parm1].flags & FLAG_SYNONYM) &&
1781 !(parm_table[parm2].flags & FLAG_SYNONYM))
1783 if (inverse != NULL) {
1784 if ((parm_table[parm1].type == P_BOOLREV) &&
1785 (parm_table[parm2].type == P_BOOL))
1797 /***************************************************************************
1798 Show one parameter's name, type, [values,] and flags.
1799 (helper functions for show_parameter_list)
1800 ***************************************************************************/
1802 static void show_parameter(int parmIndex)
1804 int enumIndex, flagIndex;
1809 const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
1810 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
1811 "P_ENUM", "P_BYTES", "P_CMDLIST" };
1812 unsigned flags[] = { FLAG_DEPRECATED, FLAG_SYNONYM };
1813 const char *flag_names[] = { "FLAG_DEPRECATED", "FLAG_SYNONYM", NULL};
1815 printf("%s=%s", parm_table[parmIndex].label,
1816 type[parm_table[parmIndex].type]);
1817 if (parm_table[parmIndex].type == P_ENUM) {
1820 parm_table[parmIndex].enum_list[enumIndex].name;
1824 enumIndex ? "|" : "",
1825 parm_table[parmIndex].enum_list[enumIndex].name);
1830 for (flagIndex=0; flag_names[flagIndex]; flagIndex++) {
1831 if (parm_table[parmIndex].flags & flags[flagIndex]) {
1834 flag_names[flagIndex]);
1839 /* output synonyms */
1841 for (parmIndex2=0; parm_table[parmIndex2].label; parmIndex2++) {
1842 if (is_synonym_of(parmIndex, parmIndex2, &inverse)) {
1843 printf(" (%ssynonym of %s)", inverse ? "inverse " : "",
1844 parm_table[parmIndex2].label);
1845 } else if (is_synonym_of(parmIndex2, parmIndex, &inverse)) {
1847 printf(" (synonyms: ");
1852 printf("%s%s", parm_table[parmIndex2].label,
1853 inverse ? "[i]" : "");
1864 * Check the value for a P_ENUM
1866 static bool check_enum_parameter(struct parm_struct *parm, const char *value)
1870 for (i = 0; parm->enum_list[i].name; i++) {
1871 if (strwicmp(value, parm->enum_list[i].name) == 0) {
1878 /**************************************************************************
1879 Check whether the given value is valid for the given parameter name.
1880 **************************************************************************/
1882 static bool lp_parameter_value_is_valid(const char *parm_name, const char *val)
1884 bool ret = false, tmp_bool;
1885 int num = lpcfg_map_parameter(parm_name), tmp_int;
1886 uint64_t tmp_int64 = 0;
1887 struct parm_struct *parm;
1889 /* parametric options (parameter names containing a colon) cannot
1890 be checked and are therefore considered valid. */
1891 if (strchr(parm_name, ':') != NULL) {
1896 parm = &parm_table[num];
1897 switch (parm->type) {
1900 ret = set_boolean(val, &tmp_bool);
1904 ret = (sscanf(val, "%d", &tmp_int) == 1);
1908 ret = (sscanf(val, "%o", &tmp_int) == 1);
1912 ret = check_enum_parameter(parm, val);
1916 if (conv_str_size_error(val, &tmp_int64) &&
1917 tmp_int64 <= INT_MAX) {
1934 /***************************************************************************
1935 Show all parameter's name, type, [values,] and flags.
1936 ***************************************************************************/
1938 void show_parameter_list(void)
1940 int classIndex, parmIndex;
1941 const char *section_names[] = { "local", "global", NULL};
1943 for (classIndex=0; section_names[classIndex]; classIndex++) {
1944 printf("[%s]\n", section_names[classIndex]);
1945 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
1946 if (parm_table[parmIndex].p_class == classIndex) {
1947 show_parameter(parmIndex);
1953 /***************************************************************************
1954 Get the standard string representation of a boolean value ("yes" or "no")
1955 ***************************************************************************/
1957 static const char *get_boolean(bool bool_value)
1959 static const char *yes_str = "yes";
1960 static const char *no_str = "no";
1962 return (bool_value ? yes_str : no_str);
1965 /***************************************************************************
1966 Provide the string of the negated boolean value associated to the boolean
1967 given as a string. Returns false if the passed string does not correctly
1968 represent a boolean.
1969 ***************************************************************************/
1971 bool lp_invert_boolean(const char *str, const char **inverse_str)
1975 if (!set_boolean(str, &val)) {
1979 *inverse_str = get_boolean(!val);
1983 /***************************************************************************
1984 Provide the canonical string representation of a boolean value given
1985 as a string. Return true on success, false if the string given does
1986 not correctly represent a boolean.
1987 ***************************************************************************/
1989 bool lp_canonicalize_boolean(const char *str, const char**canon_str)
1993 if (!set_boolean(str, &val)) {
1997 *canon_str = get_boolean(val);
2001 /***************************************************************************
2002 Find a service by name. Otherwise works like get_service.
2003 ***************************************************************************/
2005 int getservicebyname(const char *pszServiceName, struct loadparm_service *pserviceDest)
2012 if (ServiceHash == NULL) {
2016 canon_name = canonicalize_servicename(talloc_tos(), pszServiceName);
2018 status = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name,
2021 if (NT_STATUS_IS_OK(status) &&
2022 (data.dptr != NULL) &&
2023 (data.dsize == sizeof(iService)))
2025 memcpy(&iService, data.dptr, sizeof(iService));
2028 TALLOC_FREE(canon_name);
2030 if ((iService != -1) && (LP_SNUM_OK(iService))
2031 && (pserviceDest != NULL)) {
2032 copy_service(pserviceDest, ServicePtrs[iService], NULL);
2038 /* Return a pointer to a service by name. Unlike getservicebyname, it does not copy the service */
2039 struct loadparm_service *lp_service(const char *pszServiceName)
2041 int iService = getservicebyname(pszServiceName, NULL);
2042 if (iService == -1 || !LP_SNUM_OK(iService)) {
2045 return ServicePtrs[iService];
2048 struct loadparm_service *lp_servicebynum(int snum)
2050 if ((snum == -1) || !LP_SNUM_OK(snum)) {
2053 return ServicePtrs[snum];
2056 struct loadparm_service *lp_default_loadparm_service()
2061 static struct smbconf_ctx *lp_smbconf_ctx(void)
2064 static struct smbconf_ctx *conf_ctx = NULL;
2066 if (conf_ctx == NULL) {
2067 err = smbconf_init(NULL, &conf_ctx, "registry:");
2068 if (!SBC_ERROR_IS_OK(err)) {
2069 DEBUG(1, ("error initializing registry configuration: "
2070 "%s\n", sbcErrorString(err)));
2078 static bool process_smbconf_service(struct smbconf_service *service)
2083 if (service == NULL) {
2087 ret = lp_do_section(service->name, NULL);
2091 for (count = 0; count < service->num_params; count++) {
2093 if (!bInGlobalSection && bGlobalOnly) {
2096 const char *pszParmName = service->param_names[count];
2097 const char *pszParmValue = service->param_values[count];
2099 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2101 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2102 pszParmName, pszParmValue);
2109 if (iServiceIndex >= 0) {
2110 return lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2116 * load a service from registry and activate it
2118 bool process_registry_service(const char *service_name)
2121 struct smbconf_service *service = NULL;
2122 TALLOC_CTX *mem_ctx = talloc_stackframe();
2123 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2126 if (conf_ctx == NULL) {
2130 DEBUG(5, ("process_registry_service: service name %s\n", service_name));
2132 if (!smbconf_share_exists(conf_ctx, service_name)) {
2134 * Registry does not contain data for this service (yet),
2135 * but make sure lp_load doesn't return false.
2141 err = smbconf_get_share(conf_ctx, mem_ctx, service_name, &service);
2142 if (!SBC_ERROR_IS_OK(err)) {
2146 ret = process_smbconf_service(service);
2152 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2155 TALLOC_FREE(mem_ctx);
2160 * process_registry_globals
2162 static bool process_registry_globals(void)
2166 add_to_file_list(NULL, &file_lists, INCLUDE_REGISTRY_NAME, INCLUDE_REGISTRY_NAME);
2168 if (!bInGlobalSection && bGlobalOnly) {
2171 const char *pszParmName = "registry shares";
2172 const char *pszParmValue = "yes";
2174 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2176 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2177 pszParmName, pszParmValue);
2184 return process_registry_service(GLOBAL_NAME);
2187 bool process_registry_shares(void)
2191 struct smbconf_service **service = NULL;
2192 uint32_t num_shares = 0;
2193 TALLOC_CTX *mem_ctx = talloc_stackframe();
2194 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2197 if (conf_ctx == NULL) {
2201 err = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &service);
2202 if (!SBC_ERROR_IS_OK(err)) {
2208 for (count = 0; count < num_shares; count++) {
2209 if (strequal(service[count]->name, GLOBAL_NAME)) {
2212 ret = process_smbconf_service(service[count]);
2219 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2222 TALLOC_FREE(mem_ctx);
2227 * reload those shares from registry that are already
2228 * activated in the services array.
2230 static bool reload_registry_shares(void)
2235 for (i = 0; i < iNumServices; i++) {
2240 if (ServicePtrs[i]->usershare == USERSHARE_VALID) {
2244 ret = process_registry_service(ServicePtrs[i]->szService);
2255 #define MAX_INCLUDE_DEPTH 100
2257 static uint8_t include_depth;
2260 * Free the file lists
2262 static void free_file_list(void)
2264 struct file_lists *f;
2265 struct file_lists *next;
2278 * Utility function for outsiders to check if we're running on registry.
2280 bool lp_config_backend_is_registry(void)
2282 return (lp_config_backend() == CONFIG_BACKEND_REGISTRY);
2286 * Utility function to check if the config backend is FILE.
2288 bool lp_config_backend_is_file(void)
2290 return (lp_config_backend() == CONFIG_BACKEND_FILE);
2293 /*******************************************************************
2294 Check if a config file has changed date.
2295 ********************************************************************/
2297 bool lp_file_list_changed(void)
2299 struct file_lists *f = file_lists;
2301 DEBUG(6, ("lp_file_list_changed()\n"));
2304 if (strequal(f->name, INCLUDE_REGISTRY_NAME)) {
2305 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2307 if (conf_ctx == NULL) {
2310 if (smbconf_changed(conf_ctx, &conf_last_csn, NULL,
2313 DEBUGADD(6, ("registry config changed\n"));
2320 n2 = talloc_sub_basic(talloc_tos(),
2321 get_current_username(),
2322 current_user_info.domain,
2327 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
2328 f->name, n2, ctime(&f->modtime)));
2330 mod_time = file_modtime(n2);
2333 ((f->modtime != mod_time) ||
2334 (f->subfname == NULL) ||
2335 (strcmp(n2, f->subfname) != 0)))
2338 ("file %s modified: %s\n", n2,
2340 f->modtime = mod_time;
2341 TALLOC_FREE(f->subfname);
2342 f->subfname = talloc_strdup(f, n2);
2343 if (f->subfname == NULL) {
2344 smb_panic("talloc_strdup failed");
2358 * Initialize iconv conversion descriptors.
2360 * This is called the first time it is needed, and also called again
2361 * every time the configuration is reloaded, because the charset or
2362 * codepage might have changed.
2364 static void init_iconv(void)
2366 global_iconv_handle = smb_iconv_handle_reinit(NULL, lp_dos_charset(),
2368 true, global_iconv_handle);
2371 /***************************************************************************
2372 Handle the include operation.
2373 ***************************************************************************/
2374 static bool bAllowIncludeRegistry = true;
2376 bool lp_include(struct loadparm_context *lp_ctx, struct loadparm_service *service,
2377 const char *pszParmValue, char **ptr)
2381 if (include_depth >= MAX_INCLUDE_DEPTH) {
2382 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
2387 if (strequal(pszParmValue, INCLUDE_REGISTRY_NAME)) {
2388 if (!bAllowIncludeRegistry) {
2391 if (lp_ctx->bInGlobalSection) {
2394 ret = process_registry_globals();
2398 DEBUG(1, ("\"include = registry\" only effective "
2399 "in %s section\n", GLOBAL_NAME));
2404 fname = talloc_sub_basic(talloc_tos(), get_current_username(),
2405 current_user_info.domain,
2408 add_to_file_list(NULL, &file_lists, pszParmValue, fname);
2410 if (service == NULL) {
2411 lpcfg_string_set(Globals.ctx, ptr, fname);
2413 lpcfg_string_set(service, ptr, fname);
2416 if (file_exist(fname)) {
2419 ret = pm_process(fname, lp_do_section, do_parameter, lp_ctx);
2425 DEBUG(2, ("Can't find include file %s\n", fname));
2430 bool lp_idmap_range(const char *domain_name, uint32_t *low, uint32_t *high)
2432 char *config_option = NULL;
2433 const char *range = NULL;
2436 SMB_ASSERT(low != NULL);
2437 SMB_ASSERT(high != NULL);
2439 if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2443 config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2445 if (config_option == NULL) {
2446 DEBUG(0, ("out of memory\n"));
2450 range = lp_parm_const_string(-1, config_option, "range", NULL);
2451 if (range == NULL) {
2452 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name));
2456 if (sscanf(range, "%u - %u", low, high) != 2) {
2457 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2458 range, domain_name));
2465 talloc_free(config_option);
2470 bool lp_idmap_default_range(uint32_t *low, uint32_t *high)
2472 return lp_idmap_range("*", low, high);
2475 const char *lp_idmap_backend(const char *domain_name)
2477 char *config_option = NULL;
2478 const char *backend = NULL;
2480 if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2484 config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2486 if (config_option == NULL) {
2487 DEBUG(0, ("out of memory\n"));
2491 backend = lp_parm_const_string(-1, config_option, "backend", NULL);
2492 if (backend == NULL) {
2493 DEBUG(1, ("idmap backend not specified for domain '%s'\n", domain_name));
2498 talloc_free(config_option);
2502 const char *lp_idmap_default_backend(void)
2504 return lp_idmap_backend("*");
2507 /***************************************************************************
2508 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2509 ***************************************************************************/
2511 static const char *append_ldap_suffix(TALLOC_CTX *ctx, const char *str )
2513 const char *suffix_string;
2515 suffix_string = talloc_asprintf(ctx, "%s,%s", str,
2516 Globals.ldap_suffix );
2517 if ( !suffix_string ) {
2518 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2522 return suffix_string;
2525 const char *lp_ldap_machine_suffix(TALLOC_CTX *ctx)
2527 if (Globals._ldap_machine_suffix[0])
2528 return append_ldap_suffix(ctx, Globals._ldap_machine_suffix);
2530 return lp_string(ctx, Globals.ldap_suffix);
2533 const char *lp_ldap_user_suffix(TALLOC_CTX *ctx)
2535 if (Globals._ldap_user_suffix[0])
2536 return append_ldap_suffix(ctx, Globals._ldap_user_suffix);
2538 return lp_string(ctx, Globals.ldap_suffix);
2541 const char *lp_ldap_group_suffix(TALLOC_CTX *ctx)
2543 if (Globals._ldap_group_suffix[0])
2544 return append_ldap_suffix(ctx, Globals._ldap_group_suffix);
2546 return lp_string(ctx, Globals.ldap_suffix);
2549 const char *lp_ldap_idmap_suffix(TALLOC_CTX *ctx)
2551 if (Globals._ldap_idmap_suffix[0])
2552 return append_ldap_suffix(ctx, Globals._ldap_idmap_suffix);
2554 return lp_string(ctx, Globals.ldap_suffix);
2558 return the parameter pointer for a parameter
2560 void *lp_parm_ptr(struct loadparm_service *service, struct parm_struct *parm)
2562 if (service == NULL) {
2563 if (parm->p_class == P_LOCAL)
2564 return (void *)(((char *)&sDefault)+parm->offset);
2565 else if (parm->p_class == P_GLOBAL)
2566 return (void *)(((char *)&Globals)+parm->offset);
2569 return (void *)(((char *)service) + parm->offset);
2573 /***************************************************************************
2574 Process a parameter for a particular service number. If snum < 0
2575 then assume we are in the globals.
2576 ***************************************************************************/
2578 bool lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
2580 TALLOC_CTX *frame = talloc_stackframe();
2581 struct loadparm_context *lp_ctx;
2584 lp_ctx = setup_lp_context(frame);
2585 if (lp_ctx == NULL) {
2591 ok = lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue);
2593 ok = lpcfg_do_service_parameter(lp_ctx, ServicePtrs[snum],
2594 pszParmName, pszParmValue);
2602 /***************************************************************************
2603 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
2604 FLAG_CMDLINE won't be overridden by loads from smb.conf.
2605 ***************************************************************************/
2607 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue)
2610 parmnum = lpcfg_map_parameter(pszParmName);
2612 flags_list[parmnum] &= ~FLAG_CMDLINE;
2613 if (!lp_do_parameter(-1, pszParmName, pszParmValue)) {
2616 flags_list[parmnum] |= FLAG_CMDLINE;
2618 /* we have to also set FLAG_CMDLINE on aliases. Aliases must
2619 * be grouped in the table, so we don't have to search the
2622 i>=0 && parm_table[i].offset == parm_table[parmnum].offset
2623 && parm_table[i].p_class == parm_table[parmnum].p_class;
2625 flags_list[i] |= FLAG_CMDLINE;
2627 for (i=parmnum+1;i<num_parameters() && parm_table[i].offset == parm_table[parmnum].offset
2628 && parm_table[i].p_class == parm_table[parmnum].p_class;i++) {
2629 flags_list[i] |= FLAG_CMDLINE;
2635 /* it might be parametric */
2636 if (strchr(pszParmName, ':') != NULL) {
2637 set_param_opt(NULL, &Globals.param_opt, pszParmName, pszParmValue, FLAG_CMDLINE);
2641 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
2645 bool lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
2648 TALLOC_CTX *frame = talloc_stackframe();
2649 struct loadparm_context *lp_ctx;
2651 lp_ctx = setup_lp_context(frame);
2652 if (lp_ctx == NULL) {
2657 ret = lpcfg_set_cmdline(lp_ctx, pszParmName, pszParmValue);
2663 /***************************************************************************
2664 Process a parameter.
2665 ***************************************************************************/
2667 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
2670 if (!bInGlobalSection && bGlobalOnly)
2673 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2675 if (bInGlobalSection) {
2676 return lpcfg_do_global_parameter(userdata, pszParmName, pszParmValue);
2678 return lpcfg_do_service_parameter(userdata, ServicePtrs[iServiceIndex],
2679 pszParmName, pszParmValue);
2683 /***************************************************************************
2684 Initialize any local variables in the sDefault table, after parsing a
2686 ***************************************************************************/
2688 static void init_locals(void)
2691 * We run this check once the [globals] is parsed, to force
2692 * the VFS objects and other per-share settings we need for
2693 * the standard way a AD DC is operated. We may change these
2694 * as our code evolves, which is why we force these settings.
2696 * We can't do this at the end of lp_load_ex(), as by that
2697 * point the services have been loaded and they will already
2698 * have "" as their vfs objects.
2700 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
2701 const char **vfs_objects = lp_vfs_objects(-1);
2702 if (!vfs_objects || !vfs_objects[0]) {
2703 if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL)) {
2704 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
2705 } else if (lp_parm_const_string(-1, "posix", "eadb", NULL)) {
2706 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
2708 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
2712 lp_do_parameter(-1, "map hidden", "no");
2713 lp_do_parameter(-1, "map system", "no");
2714 lp_do_parameter(-1, "map readonly", "no");
2715 lp_do_parameter(-1, "map archive", "no");
2716 lp_do_parameter(-1, "store dos attributes", "yes");
2720 /***************************************************************************
2721 Process a new section (service). At this stage all sections are services.
2722 Later we'll have special sections that permit server parameters to be set.
2723 Returns true on success, false on failure.
2724 ***************************************************************************/
2726 bool lp_do_section(const char *pszSectionName, void *userdata)
2728 struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
2730 bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
2731 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
2734 /* if we were in a global section then do the local inits */
2735 if (bInGlobalSection && !isglobal)
2738 /* if we've just struck a global section, note the fact. */
2739 bInGlobalSection = isglobal;
2740 if (lp_ctx != NULL) {
2741 lp_ctx->bInGlobalSection = isglobal;
2744 /* check for multiple global sections */
2745 if (bInGlobalSection) {
2746 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
2750 if (!bInGlobalSection && bGlobalOnly)
2753 /* if we have a current service, tidy it up before moving on */
2756 if (iServiceIndex >= 0)
2757 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2759 /* if all is still well, move to the next record in the services array */
2761 /* We put this here to avoid an odd message order if messages are */
2762 /* issued by the post-processing of a previous section. */
2763 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
2765 iServiceIndex = add_a_service(&sDefault, pszSectionName);
2766 if (iServiceIndex < 0) {
2767 DEBUG(0, ("Failed to add a new service\n"));
2770 /* Clean all parametric options for service */
2771 /* They will be added during parsing again */
2772 free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
2778 /***************************************************************************
2779 Display the contents of a parameter of a single services record.
2780 ***************************************************************************/
2782 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
2784 bool result = false;
2785 struct loadparm_context *lp_ctx;
2787 lp_ctx = setup_lp_context(talloc_tos());
2788 if (lp_ctx == NULL) {
2793 result = lpcfg_dump_a_parameter(lp_ctx, NULL, parm_name, f);
2795 result = lpcfg_dump_a_parameter(lp_ctx, ServicePtrs[snum], parm_name, f);
2797 TALLOC_FREE(lp_ctx);
2802 /***************************************************************************
2803 Display the contents of a single copy structure.
2804 ***************************************************************************/
2805 static void dump_copy_map(bool *pcopymap)
2811 printf("\n\tNon-Copied parameters:\n");
2813 for (i = 0; parm_table[i].label; i++)
2814 if (parm_table[i].p_class == P_LOCAL &&
2815 parm_table[i].ptr && !pcopymap[i] &&
2816 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
2818 printf("\t\t%s\n", parm_table[i].label);
2823 /***************************************************************************
2824 Return TRUE if the passed service number is within range.
2825 ***************************************************************************/
2827 bool lp_snum_ok(int iService)
2829 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->available);
2832 /***************************************************************************
2833 Auto-load some home services.
2834 ***************************************************************************/
2836 static void lp_add_auto_services(char *str)
2846 s = talloc_strdup(talloc_tos(), str);
2848 smb_panic("talloc_strdup failed");
2852 homes = lp_servicenumber(HOMES_NAME);
2854 for (p = strtok_r(s, LIST_SEP, &saveptr); p;
2855 p = strtok_r(NULL, LIST_SEP, &saveptr)) {
2858 if (lp_servicenumber(p) >= 0)
2861 home = get_user_home_dir(talloc_tos(), p);
2863 if (home && home[0] && homes >= 0)
2864 lp_add_home(p, homes, p, home);
2871 /***************************************************************************
2872 Auto-load one printer.
2873 ***************************************************************************/
2875 void lp_add_one_printer(const char *name, const char *comment,
2876 const char *location, void *pdata)
2878 int printers = lp_servicenumber(PRINTERS_NAME);
2881 if (lp_servicenumber(name) < 0) {
2882 lp_add_printer(name, printers);
2883 if ((i = lp_servicenumber(name)) >= 0) {
2884 lpcfg_string_set(ServicePtrs[i],
2885 &ServicePtrs[i]->comment, comment);
2886 ServicePtrs[i]->autoloaded = true;
2891 /***************************************************************************
2892 Have we loaded a services file yet?
2893 ***************************************************************************/
2895 bool lp_loaded(void)
2900 /***************************************************************************
2901 Unload unused services.
2902 ***************************************************************************/
2904 void lp_killunused(struct smbd_server_connection *sconn,
2905 bool (*snumused) (struct smbd_server_connection *, int))
2908 for (i = 0; i < iNumServices; i++) {
2912 /* don't kill autoloaded or usershare services */
2913 if ( ServicePtrs[i]->autoloaded ||
2914 ServicePtrs[i]->usershare == USERSHARE_VALID) {
2918 if (!snumused || !snumused(sconn, i)) {
2919 free_service_byindex(i);
2925 * Kill all except autoloaded and usershare services - convenience wrapper
2927 void lp_kill_all_services(void)
2929 lp_killunused(NULL, NULL);
2932 /***************************************************************************
2934 ***************************************************************************/
2936 void lp_killservice(int iServiceIn)
2938 if (VALID(iServiceIn)) {
2939 free_service_byindex(iServiceIn);
2943 /***************************************************************************
2944 Save the curent values of all global and sDefault parameters into the
2945 defaults union. This allows testparm to show only the
2946 changed (ie. non-default) parameters.
2947 ***************************************************************************/
2949 static void lp_save_defaults(void)
2952 struct parmlist_entry * parm;
2953 for (i = 0; parm_table[i].label; i++) {
2954 if (!(flags_list[i] & FLAG_CMDLINE)) {
2955 flags_list[i] |= FLAG_DEFAULT;
2958 if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
2959 && parm_table[i].p_class == parm_table[i - 1].p_class)
2961 switch (parm_table[i].type) {
2964 parm_table[i].def.lvalue = str_list_copy(
2965 NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
2971 &parm_table[i].def.svalue,
2972 *(char **)lp_parm_ptr(
2973 NULL, &parm_table[i]));
2974 if (parm_table[i].def.svalue == NULL) {
2975 smb_panic("lpcfg_string_set() failed");
2980 parm_table[i].def.bvalue =
2981 *(bool *)lp_parm_ptr(NULL, &parm_table[i]);
2984 parm_table[i].def.cvalue =
2985 *(char *)lp_parm_ptr(NULL, &parm_table[i]);
2991 parm_table[i].def.ivalue =
2992 *(int *)lp_parm_ptr(NULL, &parm_table[i]);
2997 for (parm=Globals.param_opt; parm; parm=parm->next) {
2998 if (!(parm->priority & FLAG_CMDLINE)) {
2999 parm->priority |= FLAG_DEFAULT;
3003 for (parm=sDefault.param_opt; parm; parm=parm->next) {
3004 if (!(parm->priority & FLAG_CMDLINE)) {
3005 parm->priority |= FLAG_DEFAULT;
3009 defaults_saved = true;
3012 /***********************************************************
3013 If we should send plaintext/LANMAN passwords in the clinet
3014 ************************************************************/
3016 static void set_allowed_client_auth(void)
3018 if (Globals.client_ntlmv2_auth) {
3019 Globals.client_lanman_auth = false;
3021 if (!Globals.client_lanman_auth) {
3022 Globals.client_plaintext_auth = false;
3026 /***************************************************************************
3028 The following code allows smbd to read a user defined share file.
3029 Yes, this is my intent. Yes, I'm comfortable with that...
3031 THE FOLLOWING IS SECURITY CRITICAL CODE.
3033 It washes your clothes, it cleans your house, it guards you while you sleep...
3034 Do not f%^k with it....
3035 ***************************************************************************/
3037 #define MAX_USERSHARE_FILE_SIZE (10*1024)
3039 /***************************************************************************
3040 Check allowed stat state of a usershare file.
3041 Ensure we print out who is dicking with us so the admin can
3042 get their sorry ass fired.
3043 ***************************************************************************/
3045 static bool check_usershare_stat(const char *fname,
3046 const SMB_STRUCT_STAT *psbuf)
3048 if (!S_ISREG(psbuf->st_ex_mode)) {
3049 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3050 "not a regular file\n",
3051 fname, (unsigned int)psbuf->st_ex_uid ));
3055 /* Ensure this doesn't have the other write bit set. */
3056 if (psbuf->st_ex_mode & S_IWOTH) {
3057 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
3058 "public write. Refusing to allow as a usershare file.\n",
3059 fname, (unsigned int)psbuf->st_ex_uid ));
3063 /* Should be 10k or less. */
3064 if (psbuf->st_ex_size > MAX_USERSHARE_FILE_SIZE) {
3065 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
3066 "too large (%u) to be a user share file.\n",
3067 fname, (unsigned int)psbuf->st_ex_uid,
3068 (unsigned int)psbuf->st_ex_size ));
3075 /***************************************************************************
3076 Parse the contents of a usershare file.
3077 ***************************************************************************/
3079 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
3080 SMB_STRUCT_STAT *psbuf,
3081 const char *servicename,
3085 char **pp_sharepath,
3087 char **pp_cp_servicename,
3088 struct security_descriptor **ppsd,
3091 const char **prefixallowlist = lp_usershare_prefix_allow_list();
3092 const char **prefixdenylist = lp_usershare_prefix_deny_list();
3095 SMB_STRUCT_STAT sbuf;
3096 char *sharepath = NULL;
3097 char *comment = NULL;
3099 *pp_sharepath = NULL;
3102 *pallow_guest = false;
3105 return USERSHARE_MALFORMED_FILE;
3108 if (strcmp(lines[0], "#VERSION 1") == 0) {
3110 } else if (strcmp(lines[0], "#VERSION 2") == 0) {
3113 return USERSHARE_MALFORMED_FILE;
3116 return USERSHARE_BAD_VERSION;
3119 if (strncmp(lines[1], "path=", 5) != 0) {
3120 return USERSHARE_MALFORMED_PATH;
3123 sharepath = talloc_strdup(ctx, &lines[1][5]);
3125 return USERSHARE_POSIX_ERR;
3127 trim_string(sharepath, " ", " ");
3129 if (strncmp(lines[2], "comment=", 8) != 0) {
3130 return USERSHARE_MALFORMED_COMMENT_DEF;
3133 comment = talloc_strdup(ctx, &lines[2][8]);
3135 return USERSHARE_POSIX_ERR;
3137 trim_string(comment, " ", " ");
3138 trim_char(comment, '"', '"');
3140 if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
3141 return USERSHARE_MALFORMED_ACL_DEF;
3144 if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
3145 return USERSHARE_ACL_ERR;
3149 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
3150 return USERSHARE_MALFORMED_ACL_DEF;
3152 if (lines[4][9] == 'y') {
3153 *pallow_guest = true;
3156 /* Backwards compatible extension to file version #2. */
3158 if (strncmp(lines[5], "sharename=", 10) != 0) {
3159 return USERSHARE_MALFORMED_SHARENAME_DEF;
3161 if (!strequal(&lines[5][10], servicename)) {
3162 return USERSHARE_BAD_SHARENAME;
3164 *pp_cp_servicename = talloc_strdup(ctx, &lines[5][10]);
3165 if (!*pp_cp_servicename) {
3166 return USERSHARE_POSIX_ERR;
3171 if (*pp_cp_servicename == NULL) {
3172 *pp_cp_servicename = talloc_strdup(ctx, servicename);
3173 if (!*pp_cp_servicename) {
3174 return USERSHARE_POSIX_ERR;
3178 if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->path) == 0)) {
3179 /* Path didn't change, no checks needed. */
3180 *pp_sharepath = sharepath;
3181 *pp_comment = comment;
3182 return USERSHARE_OK;
3185 /* The path *must* be absolute. */
3186 if (sharepath[0] != '/') {
3187 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
3188 servicename, sharepath));
3189 return USERSHARE_PATH_NOT_ABSOLUTE;
3192 /* If there is a usershare prefix deny list ensure one of these paths
3193 doesn't match the start of the user given path. */
3194 if (prefixdenylist) {
3196 for ( i=0; prefixdenylist[i]; i++ ) {
3197 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
3198 servicename, i, prefixdenylist[i], sharepath ));
3199 if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
3200 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
3201 "usershare prefix deny list entries.\n",
3202 servicename, sharepath));
3203 return USERSHARE_PATH_IS_DENIED;
3208 /* If there is a usershare prefix allow list ensure one of these paths
3209 does match the start of the user given path. */
3211 if (prefixallowlist) {
3213 for ( i=0; prefixallowlist[i]; i++ ) {
3214 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
3215 servicename, i, prefixallowlist[i], sharepath ));
3216 if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
3220 if (prefixallowlist[i] == NULL) {
3221 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
3222 "usershare prefix allow list entries.\n",
3223 servicename, sharepath));
3224 return USERSHARE_PATH_NOT_ALLOWED;
3228 /* Ensure this is pointing to a directory. */
3229 dp = opendir(sharepath);
3232 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3233 servicename, sharepath));
3234 return USERSHARE_PATH_NOT_DIRECTORY;
3237 /* Ensure the owner of the usershare file has permission to share
3240 if (sys_stat(sharepath, &sbuf, false) == -1) {
3241 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
3242 servicename, sharepath, strerror(errno) ));
3244 return USERSHARE_POSIX_ERR;
3249 if (!S_ISDIR(sbuf.st_ex_mode)) {
3250 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3251 servicename, sharepath ));
3252 return USERSHARE_PATH_NOT_DIRECTORY;
3255 /* Check if sharing is restricted to owner-only. */
3256 /* psbuf is the stat of the usershare definition file,
3257 sbuf is the stat of the target directory to be shared. */
3259 if (lp_usershare_owner_only()) {
3260 /* root can share anything. */
3261 if ((psbuf->st_ex_uid != 0) && (sbuf.st_ex_uid != psbuf->st_ex_uid)) {
3262 return USERSHARE_PATH_NOT_ALLOWED;
3266 *pp_sharepath = sharepath;
3267 *pp_comment = comment;
3268 return USERSHARE_OK;
3271 /***************************************************************************
3272 Deal with a usershare file.
3275 -1 - Bad name, invalid contents.
3276 - service name already existed and not a usershare, problem
3277 with permissions to share directory etc.
3278 ***************************************************************************/
3280 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
3282 SMB_STRUCT_STAT sbuf;
3283 SMB_STRUCT_STAT lsbuf;
3285 char *sharepath = NULL;
3286 char *comment = NULL;
3287 char *cp_service_name = NULL;
3288 char **lines = NULL;
3292 TALLOC_CTX *ctx = talloc_stackframe();
3293 struct security_descriptor *psd = NULL;
3294 bool guest_ok = false;
3295 char *canon_name = NULL;
3296 bool added_service = false;
3299 /* Ensure share name doesn't contain invalid characters. */
3300 if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
3301 DEBUG(0,("process_usershare_file: share name %s contains "
3302 "invalid characters (any of %s)\n",
3303 file_name, INVALID_SHARENAME_CHARS ));
3307 canon_name = canonicalize_servicename(ctx, file_name);
3312 fname = talloc_asprintf(ctx, "%s/%s", dir_name, file_name);
3317 /* Minimize the race condition by doing an lstat before we
3318 open and fstat. Ensure this isn't a symlink link. */
3320 if (sys_lstat(fname, &lsbuf, false) != 0) {
3321 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
3322 fname, strerror(errno) ));
3326 /* This must be a regular file, not a symlink, directory or
3327 other strange filetype. */
3328 if (!check_usershare_stat(fname, &lsbuf)) {
3336 status = dbwrap_fetch_bystring(ServiceHash, canon_name,
3341 if (NT_STATUS_IS_OK(status) &&
3342 (data.dptr != NULL) &&
3343 (data.dsize == sizeof(iService))) {
3344 memcpy(&iService, data.dptr, sizeof(iService));
3348 if (iService != -1 &&
3349 timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
3350 &lsbuf.st_ex_mtime) == 0) {
3351 /* Nothing changed - Mark valid and return. */
3352 DEBUG(10,("process_usershare_file: service %s not changed.\n",
3354 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3359 /* Try and open the file read only - no symlinks allowed. */
3361 fd = open(fname, O_RDONLY|O_NOFOLLOW, 0);
3363 fd = open(fname, O_RDONLY, 0);
3367 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
3368 fname, strerror(errno) ));
3372 /* Now fstat to be *SURE* it's a regular file. */
3373 if (sys_fstat(fd, &sbuf, false) != 0) {
3375 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
3376 fname, strerror(errno) ));
3380 /* Is it the same dev/inode as was lstated ? */
3381 if (!check_same_stat(&lsbuf, &sbuf)) {
3383 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
3384 "Symlink spoofing going on ?\n", fname ));
3388 /* This must be a regular file, not a symlink, directory or
3389 other strange filetype. */
3390 if (!check_usershare_stat(fname, &sbuf)) {
3395 lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE, NULL);
3398 if (lines == NULL) {
3399 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
3400 fname, (unsigned int)sbuf.st_ex_uid ));
3404 if (parse_usershare_file(ctx, &sbuf, file_name,
3405 iService, lines, numlines, &sharepath,
3406 &comment, &cp_service_name,
3407 &psd, &guest_ok) != USERSHARE_OK) {
3411 /* Everything ok - add the service possibly using a template. */
3413 const struct loadparm_service *sp = &sDefault;
3414 if (snum_template != -1) {
3415 sp = ServicePtrs[snum_template];
3418 if ((iService = add_a_service(sp, cp_service_name)) < 0) {
3419 DEBUG(0, ("process_usershare_file: Failed to add "
3420 "new service %s\n", cp_service_name));
3424 added_service = true;
3426 /* Read only is controlled by usershare ACL below. */
3427 ServicePtrs[iService]->read_only = false;
3430 /* Write the ACL of the new/modified share. */
3431 if (!set_share_security(canon_name, psd)) {
3432 DEBUG(0, ("process_usershare_file: Failed to set share "
3433 "security for user share %s\n",
3438 /* If from a template it may be marked invalid. */
3439 ServicePtrs[iService]->valid = true;
3441 /* Set the service as a valid usershare. */
3442 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3444 /* Set guest access. */
3445 if (lp_usershare_allow_guests()) {
3446 ServicePtrs[iService]->guest_ok = guest_ok;
3449 /* And note when it was loaded. */
3450 ServicePtrs[iService]->usershare_last_mod = sbuf.st_ex_mtime;
3451 lpcfg_string_set(ServicePtrs[iService], &ServicePtrs[iService]->path,
3453 lpcfg_string_set(ServicePtrs[iService],
3454 &ServicePtrs[iService]->comment, comment);
3460 if (ret == -1 && iService != -1 && added_service) {
3461 lp_remove_service(iService);
3469 /***************************************************************************
3470 Checks if a usershare entry has been modified since last load.
3471 ***************************************************************************/
3473 static bool usershare_exists(int iService, struct timespec *last_mod)
3475 SMB_STRUCT_STAT lsbuf;
3476 const char *usersharepath = Globals.usershare_path;
3479 fname = talloc_asprintf(talloc_tos(),
3482 ServicePtrs[iService]->szService);
3483 if (fname == NULL) {
3487 if (sys_lstat(fname, &lsbuf, false) != 0) {
3492 if (!S_ISREG(lsbuf.st_ex_mode)) {
3498 *last_mod = lsbuf.st_ex_mtime;
3502 /***************************************************************************
3503 Load a usershare service by name. Returns a valid servicenumber or -1.
3504 ***************************************************************************/
3506 int load_usershare_service(const char *servicename)
3508 SMB_STRUCT_STAT sbuf;
3509 const char *usersharepath = Globals.usershare_path;
3510 int max_user_shares = Globals.usershare_max_shares;
3511 int snum_template = -1;
3513 if (*usersharepath == 0 || max_user_shares == 0) {
3517 if (sys_stat(usersharepath, &sbuf, false) != 0) {
3518 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
3519 usersharepath, strerror(errno) ));
3523 if (!S_ISDIR(sbuf.st_ex_mode)) {
3524 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
3530 * This directory must be owned by root, and have the 't' bit set.
3531 * It also must not be writable by "other".
3535 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3537 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3539 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
3540 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3545 /* Ensure the template share exists if it's set. */
3546 if (Globals.usershare_template_share[0]) {
3547 /* We can't use lp_servicenumber here as we are recommending that
3548 template shares have -valid=false set. */
3549 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3550 if (ServicePtrs[snum_template]->szService &&
3551 strequal(ServicePtrs[snum_template]->szService,
3552 Globals.usershare_template_share)) {
3557 if (snum_template == -1) {
3558 DEBUG(0,("load_usershare_service: usershare template share %s "
3559 "does not exist.\n",
3560 Globals.usershare_template_share ));
3565 return process_usershare_file(usersharepath, servicename, snum_template);
3568 /***************************************************************************
3569 Load all user defined shares from the user share directory.
3570 We only do this if we're enumerating the share list.
3571 This is the function that can delete usershares that have
3573 ***************************************************************************/
3575 int load_usershare_shares(struct smbd_server_connection *sconn,
3576 bool (*snumused) (struct smbd_server_connection *, int))
3579 SMB_STRUCT_STAT sbuf;
3581 int num_usershares = 0;
3582 int max_user_shares = Globals.usershare_max_shares;
3583 unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
3584 unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
3585 unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
3587 int snum_template = -1;
3588 const char *usersharepath = Globals.usershare_path;
3589 int ret = lp_numservices();
3590 TALLOC_CTX *tmp_ctx;
3592 if (max_user_shares == 0 || *usersharepath == '\0') {
3593 return lp_numservices();
3596 if (sys_stat(usersharepath, &sbuf, false) != 0) {
3597 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
3598 usersharepath, strerror(errno) ));
3603 * This directory must be owned by root, and have the 't' bit set.
3604 * It also must not be writable by "other".
3608 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3610 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3612 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
3613 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3618 /* Ensure the template share exists if it's set. */
3619 if (Globals.usershare_template_share[0]) {
3620 /* We can't use lp_servicenumber here as we are recommending that
3621 template shares have -valid=false set. */
3622 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3623 if (ServicePtrs[snum_template]->szService &&
3624 strequal(ServicePtrs[snum_template]->szService,
3625 Globals.usershare_template_share)) {
3630 if (snum_template == -1) {
3631 DEBUG(0,("load_usershare_shares: usershare template share %s "
3632 "does not exist.\n",
3633 Globals.usershare_template_share ));
3638 /* Mark all existing usershares as pending delete. */
3639 for (iService = iNumServices - 1; iService >= 0; iService--) {
3640 if (VALID(iService) && ServicePtrs[iService]->usershare) {
3641 ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
3645 dp = opendir(usersharepath);
3647 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
3648 usersharepath, strerror(errno) ));
3652 for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
3654 num_dir_entries++ ) {
3656 const char *n = de->d_name;
3658 /* Ignore . and .. */
3660 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
3666 /* Temporary file used when creating a share. */
3667 num_tmp_dir_entries++;
3670 /* Allow 20% tmp entries. */
3671 if (num_tmp_dir_entries > allowed_tmp_entries) {
3672 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
3673 "in directory %s\n",
3674 num_tmp_dir_entries, usersharepath));
3678 r = process_usershare_file(usersharepath, n, snum_template);
3680 /* Update the services count. */
3682 if (num_usershares >= max_user_shares) {
3683 DEBUG(0,("load_usershare_shares: max user shares reached "
3684 "on file %s in directory %s\n",
3685 n, usersharepath ));
3688 } else if (r == -1) {
3689 num_bad_dir_entries++;
3692 /* Allow 20% bad entries. */
3693 if (num_bad_dir_entries > allowed_bad_entries) {
3694 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
3695 "in directory %s\n",
3696 num_bad_dir_entries, usersharepath));
3700 /* Allow 20% bad entries. */
3701 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
3702 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
3703 "in directory %s\n",
3704 num_dir_entries, usersharepath));
3711 /* Sweep through and delete any non-refreshed usershares that are
3712 not currently in use. */
3713 tmp_ctx = talloc_stackframe();
3714 for (iService = iNumServices - 1; iService >= 0; iService--) {
3715 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
3718 if (snumused && snumused(sconn, iService)) {
3722 servname = lp_servicename(tmp_ctx, iService);
3724 /* Remove from the share ACL db. */
3725 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
3727 delete_share_security(servname);
3728 free_service_byindex(iService);
3731 talloc_free(tmp_ctx);
3733 return lp_numservices();
3736 /********************************************************
3737 Destroy global resources allocated in this file
3738 ********************************************************/
3740 void gfree_loadparm(void)
3746 /* Free resources allocated to services */
3748 for ( i = 0; i < iNumServices; i++ ) {
3750 free_service_byindex(i);
3754 TALLOC_FREE( ServicePtrs );
3757 /* Now release all resources allocated to global
3758 parameters and the default service */
3760 free_global_parameters();
3764 /***************************************************************************
3765 Allow client apps to specify that they are a client
3766 ***************************************************************************/
3767 static void lp_set_in_client(bool b)
3773 /***************************************************************************
3774 Determine if we're running in a client app
3775 ***************************************************************************/
3776 static bool lp_is_in_client(void)
3781 static void lp_enforce_ad_dc_settings(void)
3783 lp_do_parameter(GLOBAL_SECTION_SNUM, "passdb backend", "samba_dsdb");
3784 lp_do_parameter(GLOBAL_SECTION_SNUM,
3785 "winbindd:use external pipes", "true");
3786 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:default", "external");
3787 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:svcctl", "embedded");
3788 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:srvsvc", "embedded");
3789 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:eventlog", "embedded");
3790 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:ntsvcs", "embedded");
3791 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:winreg", "embedded");
3792 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:spoolss", "embedded");
3793 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_daemon:spoolssd", "embedded");
3794 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:tcpip", "no");
3797 /***************************************************************************
3798 Load the services array from the services file. Return true on success,
3800 ***************************************************************************/
3802 static bool lp_load_ex(const char *pszFname,
3806 bool reinit_globals,
3807 bool allow_include_registry,
3808 bool load_all_shares)
3812 TALLOC_CTX *frame = talloc_stackframe();
3813 struct loadparm_context *lp_ctx;
3817 DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
3819 bInGlobalSection = true;
3820 bGlobalOnly = global_only;
3821 bAllowIncludeRegistry = allow_include_registry;
3823 lp_ctx = setup_lp_context(talloc_tos());
3825 init_globals(lp_ctx, reinit_globals);
3829 if (save_defaults) {
3834 if (!reinit_globals) {
3835 free_param_opts(&Globals.param_opt);
3836 apply_lp_set_cmdline();
3839 lp_do_parameter(-1, "idmap config * : backend", Globals.idmap_backend);
3841 /* We get sections first, so have to start 'behind' to make up */
3844 if (lp_config_backend_is_file()) {
3845 n2 = talloc_sub_basic(talloc_tos(), get_current_username(),
3846 current_user_info.domain,
3849 smb_panic("lp_load_ex: out of memory");
3852 add_to_file_list(NULL, &file_lists, pszFname, n2);
3854 bRetval = pm_process(n2, lp_do_section, do_parameter, lp_ctx);
3857 /* finish up the last section */
3858 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
3860 if (iServiceIndex >= 0) {
3861 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
3865 if (lp_config_backend_is_registry()) {
3867 /* config backend changed to registry in config file */
3869 * We need to use this extra global variable here to
3870 * survive restart: init_globals uses this as a default
3871 * for config_backend. Otherwise, init_globals would
3872 * send us into an endless loop here.
3875 config_backend = CONFIG_BACKEND_REGISTRY;
3877 DEBUG(1, ("lp_load_ex: changing to config backend "
3879 init_globals(lp_ctx, true);
3881 TALLOC_FREE(lp_ctx);
3883 lp_kill_all_services();
3884 ok = lp_load_ex(pszFname, global_only, save_defaults,
3885 add_ipc, reinit_globals,
3886 allow_include_registry,
3891 } else if (lp_config_backend_is_registry()) {
3892 bRetval = process_registry_globals();
3894 DEBUG(0, ("Illegal config backend given: %d\n",
3895 lp_config_backend()));
3899 if (bRetval && lp_registry_shares()) {
3900 if (load_all_shares) {
3901 bRetval = process_registry_shares();
3903 bRetval = reload_registry_shares();
3908 char *serv = lp_auto_services(talloc_tos());
3909 lp_add_auto_services(serv);
3914 /* When 'restrict anonymous = 2' guest connections to ipc$
3916 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
3917 if ( lp_enable_asu_support() ) {
3918 lp_add_ipc("ADMIN$", false);
3922 set_allowed_client_auth();
3924 if (lp_security() == SEC_ADS && strchr(lp_password_server(), ':')) {
3925 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
3926 lp_password_server()));
3931 /* Now we check we_are_a_wins_server and set szWINSserver to 127.0.0.1 */
3932 /* if we_are_a_wins_server is true and we are in the client */
3933 if (lp_is_in_client() && Globals.we_are_a_wins_server) {
3934 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
3939 fault_configure(smb_panic_s3);
3942 * We run this check once the whole smb.conf is parsed, to
3943 * force some settings for the standard way a AD DC is
3944 * operated. We may change these as our code evolves, which
3945 * is why we force these settings.
3947 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
3948 lp_enforce_ad_dc_settings();
3951 bAllowIncludeRegistry = true;
3957 static bool lp_load(const char *pszFname,
3961 bool reinit_globals)
3963 return lp_load_ex(pszFname,
3968 true, /* allow_include_registry */
3969 false); /* load_all_shares*/
3972 bool lp_load_initial_only(const char *pszFname)
3974 return lp_load_ex(pszFname,
3975 true, /* global only */
3976 true, /* save_defaults */
3977 false, /* add_ipc */
3978 true, /* reinit_globals */
3979 false, /* allow_include_registry */
3980 false); /* load_all_shares*/
3984 * most common lp_load wrapper, loading only the globals
3986 * If this is used in a daemon or client utility it should be called
3987 * after processing popt.
3989 bool lp_load_global(const char *file_name)
3991 return lp_load(file_name,
3992 true, /* global_only */
3993 false, /* save_defaults */
3994 false, /* add_ipc */
3995 true); /* reinit_globals */
3999 * The typical lp_load wrapper with shares, loads global and
4000 * shares, including IPC, but does not force immediate
4001 * loading of all shares from registry.
4003 bool lp_load_with_shares(const char *file_name)
4005 return lp_load(file_name,
4006 false, /* global_only */
4007 false, /* save_defaults */
4009 true); /* reinit_globals */
4013 * lp_load wrapper, especially for clients
4015 bool lp_load_client(const char *file_name)
4017 lp_set_in_client(true);
4019 return lp_load_global(file_name);
4023 * lp_load wrapper, loading only globals, but intended
4024 * for subsequent calls, not reinitializing the globals
4027 bool lp_load_global_no_reinit(const char *file_name)
4029 return lp_load(file_name,
4030 true, /* global_only */
4031 false, /* save_defaults */
4032 false, /* add_ipc */
4033 false); /* reinit_globals */
4037 * lp_load wrapper, loading globals and shares,
4038 * intended for subsequent calls, i.e. not reinitializing
4039 * the globals to default values.
4041 bool lp_load_no_reinit(const char *file_name)
4043 return lp_load(file_name,
4044 false, /* global_only */
4045 false, /* save_defaults */
4046 false, /* add_ipc */
4047 false); /* reinit_globals */
4052 * lp_load wrapper, especially for clients, no reinitialization
4054 bool lp_load_client_no_reinit(const char *file_name)
4056 lp_set_in_client(true);
4058 return lp_load_global_no_reinit(file_name);
4061 bool lp_load_with_registry_shares(const char *pszFname)
4063 return lp_load_ex(pszFname,
4064 false, /* global_only */
4065 true, /* save_defaults */
4066 false, /* add_ipc */
4067 false, /* reinit_globals */
4068 true, /* allow_include_registry */
4069 true); /* load_all_shares*/
4072 /***************************************************************************
4073 Return the max number of services.
4074 ***************************************************************************/
4076 int lp_numservices(void)
4078 return (iNumServices);
4081 /***************************************************************************
4082 Display the contents of the services array in human-readable form.
4083 ***************************************************************************/
4085 void lp_dump(FILE *f, bool show_defaults, int maxtoprint)
4088 struct loadparm_context *lp_ctx;
4091 defaults_saved = false;
4093 lp_ctx = setup_lp_context(talloc_tos());
4094 if (lp_ctx == NULL) {
4098 lpcfg_dump_globals(lp_ctx, f, !defaults_saved);
4100 lpcfg_dump_a_service(&sDefault, &sDefault, f, flags_list, show_defaults);
4102 for (iService = 0; iService < maxtoprint; iService++) {
4104 lp_dump_one(f, show_defaults, iService);
4108 /***************************************************************************
4109 Display the contents of one service in human-readable form.
4110 ***************************************************************************/
4112 void lp_dump_one(FILE * f, bool show_defaults, int snum)
4115 if (ServicePtrs[snum]->szService[0] == '\0')
4117 lpcfg_dump_a_service(ServicePtrs[snum], &sDefault, f,
4118 flags_list, show_defaults);
4122 /***************************************************************************
4123 Return the number of the service with the given name, or -1 if it doesn't
4124 exist. Note that this is a DIFFERENT ANIMAL from the internal function
4125 getservicebyname()! This works ONLY if all services have been loaded, and
4126 does not copy the found service.
4127 ***************************************************************************/
4129 int lp_servicenumber(const char *pszServiceName)
4132 fstring serviceName;
4134 if (!pszServiceName) {
4135 return GLOBAL_SECTION_SNUM;
4138 for (iService = iNumServices - 1; iService >= 0; iService--) {
4139 if (VALID(iService) && ServicePtrs[iService]->szService) {
4141 * The substitution here is used to support %U in
4144 fstrcpy(serviceName, ServicePtrs[iService]->szService);
4145 standard_sub_basic(get_current_username(),
4146 current_user_info.domain,
4147 serviceName,sizeof(serviceName));
4148 if (strequal(serviceName, pszServiceName)) {
4154 if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
4155 struct timespec last_mod;
4157 if (!usershare_exists(iService, &last_mod)) {
4158 /* Remove the share security tdb entry for it. */
4159 delete_share_security(lp_servicename(talloc_tos(), iService));
4160 /* Remove it from the array. */
4161 free_service_byindex(iService);
4162 /* Doesn't exist anymore. */
4163 return GLOBAL_SECTION_SNUM;
4166 /* Has it been modified ? If so delete and reload. */
4167 if (timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
4169 /* Remove it from the array. */
4170 free_service_byindex(iService);
4171 /* and now reload it. */
4172 iService = load_usershare_service(pszServiceName);
4177 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
4178 return GLOBAL_SECTION_SNUM;
4184 /*******************************************************************
4185 A useful volume label function.
4186 ********************************************************************/
4188 const char *volume_label(TALLOC_CTX *ctx, int snum)
4191 const char *label = lp_volume(ctx, snum);
4193 label = lp_servicename(ctx, snum);
4196 /* This returns a 33 byte guarenteed null terminated string. */
4197 ret = talloc_strndup(ctx, label, 32);
4204 /*******************************************************************
4205 Get the default server type we will announce as via nmbd.
4206 ********************************************************************/
4208 int lp_default_server_announce(void)
4210 int default_server_announce = 0;
4211 default_server_announce |= SV_TYPE_WORKSTATION;
4212 default_server_announce |= SV_TYPE_SERVER;
4213 default_server_announce |= SV_TYPE_SERVER_UNIX;
4215 /* note that the flag should be set only if we have a
4216 printer service but nmbd doesn't actually load the
4217 services so we can't tell --jerry */
4219 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
4221 default_server_announce |= SV_TYPE_SERVER_NT;
4222 default_server_announce |= SV_TYPE_NT;
4224 switch (lp_server_role()) {
4225 case ROLE_DOMAIN_MEMBER:
4226 default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
4228 case ROLE_DOMAIN_PDC:
4229 default_server_announce |= SV_TYPE_DOMAIN_CTRL;
4231 case ROLE_DOMAIN_BDC:
4232 default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
4234 case ROLE_STANDALONE:
4238 if (lp_time_server())
4239 default_server_announce |= SV_TYPE_TIME_SOURCE;
4241 if (lp_host_msdfs())
4242 default_server_announce |= SV_TYPE_DFS_SERVER;
4244 return default_server_announce;
4247 /***********************************************************
4248 If we are PDC then prefer us as DMB
4249 ************************************************************/
4251 bool lp_domain_master(void)
4253 if (Globals._domain_master == Auto)
4254 return (lp_server_role() == ROLE_DOMAIN_PDC);
4256 return (bool)Globals._domain_master;
4259 /***********************************************************
4260 If we are PDC then prefer us as DMB
4261 ************************************************************/
4263 static bool lp_domain_master_true_or_auto(void)
4265 if (Globals._domain_master) /* auto or yes */
4271 /***********************************************************
4272 If we are DMB then prefer us as LMB
4273 ************************************************************/
4275 bool lp_preferred_master(void)
4277 int preferred_master = lp__preferred_master();
4279 if (preferred_master == Auto)
4280 return (lp_local_master() && lp_domain_master());
4282 return (bool)preferred_master;
4285 /*******************************************************************
4287 ********************************************************************/
4289 void lp_remove_service(int snum)
4291 ServicePtrs[snum]->valid = false;
4294 const char *lp_printername(TALLOC_CTX *ctx, int snum)
4296 const char *ret = lp__printername(ctx, snum);
4297 if (ret == NULL || *ret == '\0') {
4298 ret = lp_const_servicename(snum);
4305 /***********************************************************
4306 Allow daemons such as winbindd to fix their logfile name.
4307 ************************************************************/
4309 void lp_set_logfile(const char *name)
4311 lpcfg_string_set(Globals.ctx, &Globals.logfile, name);
4312 debug_set_logfile(name);
4315 /*******************************************************************
4316 Return the max print jobs per queue.
4317 ********************************************************************/
4319 int lp_maxprintjobs(int snum)
4321 int maxjobs = lp_max_print_jobs(snum);
4323 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
4324 maxjobs = PRINT_MAX_JOBID - 1;
4329 const char *lp_printcapname(void)
4331 const char *printcap_name = lp_printcap_name();
4333 if ((printcap_name != NULL) &&
4334 (printcap_name[0] != '\0'))
4335 return printcap_name;
4337 if (sDefault.printing == PRINT_CUPS) {
4341 if (sDefault.printing == PRINT_BSD)
4342 return "/etc/printcap";
4344 return PRINTCAP_NAME;
4347 static uint32_t spoolss_state;
4349 bool lp_disable_spoolss( void )
4351 if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
4352 spoolss_state = lp__disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4354 return spoolss_state == SVCCTL_STOPPED ? true : false;
4357 void lp_set_spoolss_state( uint32_t state )
4359 SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
4361 spoolss_state = state;
4364 uint32_t lp_get_spoolss_state( void )
4366 return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4369 /*******************************************************************
4370 Ensure we don't use sendfile if server smb signing is active.
4371 ********************************************************************/
4373 bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state)
4375 bool sign_active = false;
4377 /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
4378 if (get_Protocol() < PROTOCOL_NT1) {
4381 if (signing_state) {
4382 sign_active = smb_signing_is_active(signing_state);
4384 return (lp__use_sendfile(snum) &&
4385 (get_remote_arch() != RA_WIN95) &&
4389 /*******************************************************************
4390 Turn off sendfile if we find the underlying OS doesn't support it.
4391 ********************************************************************/
4393 void set_use_sendfile(int snum, bool val)
4395 if (LP_SNUM_OK(snum))
4396 ServicePtrs[snum]->_use_sendfile = val;
4398 sDefault._use_sendfile = val;
4401 void lp_set_mangling_method(const char *new_method)
4403 lpcfg_string_set(Globals.ctx, &Globals.mangling_method, new_method);
4406 /*******************************************************************
4407 Global state for POSIX pathname processing.
4408 ********************************************************************/
4410 static bool posix_pathnames;
4412 bool lp_posix_pathnames(void)
4414 return posix_pathnames;
4417 /*******************************************************************
4418 Change everything needed to ensure POSIX pathname processing (currently
4420 ********************************************************************/
4422 void lp_set_posix_pathnames(void)
4424 posix_pathnames = true;
4427 /*******************************************************************
4428 Global state for POSIX lock processing - CIFS unix extensions.
4429 ********************************************************************/
4431 bool posix_default_lock_was_set;
4432 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
4434 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
4436 if (posix_default_lock_was_set) {
4437 return posix_cifsx_locktype;
4439 return (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
4440 POSIX_LOCK : WINDOWS_LOCK;
4444 /*******************************************************************
4445 ********************************************************************/
4447 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
4449 posix_default_lock_was_set = true;
4450 posix_cifsx_locktype = val;
4453 int lp_min_receive_file_size(void)
4455 int min_receivefile_size = lp_min_receivefile_size();
4457 if (min_receivefile_size < 0) {
4460 return min_receivefile_size;
4463 /*******************************************************************
4464 Safe wide links checks.
4465 This helper function always verify the validity of wide links,
4466 even after a configuration file reload.
4467 ********************************************************************/
4469 void widelinks_warning(int snum)
4471 if (lp_allow_insecure_wide_links()) {
4475 if (lp_unix_extensions() && lp_wide_links(snum)) {
4476 DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
4477 "These parameters are incompatible. "
4478 "Wide links will be disabled for this share.\n",
4479 lp_servicename(talloc_tos(), snum) ));
4483 bool lp_widelinks(int snum)
4485 /* wide links is always incompatible with unix extensions */
4486 if (lp_unix_extensions()) {
4488 * Unless we have "allow insecure widelinks"
4491 if (!lp_allow_insecure_wide_links()) {
4496 return lp_wide_links(snum);
4499 int lp_server_role(void)
4501 return lp_find_server_role(lp__server_role(),
4503 lp__domain_logons(),
4504 lp_domain_master_true_or_auto());
4507 int lp_security(void)
4509 return lp_find_security(lp__server_role(),
4513 int lp_client_max_protocol(void)
4515 int client_max_protocol = lp__client_max_protocol();
4516 if (client_max_protocol == PROTOCOL_DEFAULT) {
4517 return PROTOCOL_NT1;
4519 return client_max_protocol;
4522 int lp_client_ipc_min_protocol(void)
4524 int client_ipc_min_protocol = lp__client_ipc_min_protocol();
4525 if (client_ipc_min_protocol == PROTOCOL_DEFAULT) {
4526 client_ipc_min_protocol = lp_client_min_protocol();
4528 if (client_ipc_min_protocol < PROTOCOL_NT1) {
4529 return PROTOCOL_NT1;
4531 return client_ipc_min_protocol;
4534 int lp_client_ipc_max_protocol(void)
4536 int client_ipc_max_protocol = lp__client_ipc_max_protocol();
4537 if (client_ipc_max_protocol == PROTOCOL_DEFAULT) {
4538 return PROTOCOL_LATEST;
4540 if (client_ipc_max_protocol < PROTOCOL_NT1) {
4541 return PROTOCOL_NT1;
4543 return client_ipc_max_protocol;
4546 int lp_client_ipc_signing(void)
4548 int client_ipc_signing = lp__client_ipc_signing();
4549 if (client_ipc_signing == SMB_SIGNING_DEFAULT) {
4550 return SMB_SIGNING_REQUIRED;
4552 return client_ipc_signing;
4555 struct loadparm_global * get_globals(void)
4560 unsigned int * get_flags(void)
4562 if (flags_list == NULL) {
4563 flags_list = talloc_zero_array(NULL, unsigned int, num_parameters());