2 Unix SMB/CIFS implementation.
3 Parameter loading functions
4 Copyright (C) Karl Auer 1993-1998
6 Largely re-written by Andrew Tridgell, September 1994
8 Copyright (C) Simo Sorce 2001
9 Copyright (C) Alexander Bokovoy 2002
10 Copyright (C) Stefan (metze) Metzmacher 2002
11 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
12 Copyright (C) Michael Adam 2008
13 Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
14 Copyright (C) Andrew Bartlett 2011
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program. If not, see <http://www.gnu.org/licenses/>.
33 * This module provides suitable callback functions for the params
34 * module. It builds the internal table of service details which is
35 * then used by the rest of the server.
39 * 1) add it to the global or service structure definition
40 * 2) add it to the parm_table
41 * 3) add it to the list of available functions (eg: using FN_GLOBAL_STRING())
42 * 4) If it's a global then initialise it in init_globals. If a local
43 * (ie. service) parameter then initialise it in the sDefault structure
47 * The configuration file is processed sequentially for speed. It is NOT
48 * accessed randomly as happens in 'real' Windows. For this reason, there
49 * is a fair bit of sequence-dependent code here - ie., code which assumes
50 * that certain things happen before others. In particular, the code which
51 * happens at the boundary between sections is delicately poised, so be
57 #include "system/filesys.h"
59 #include "lib/param/loadparm.h"
60 #include "lib/param/param.h"
62 #include "lib/smbconf/smbconf.h"
63 #include "lib/smbconf/smbconf_init.h"
66 #include "../librpc/gen_ndr/svcctl.h"
68 #include "../libcli/smb/smb_signing.h"
69 #include "dbwrap/dbwrap.h"
70 #include "dbwrap/dbwrap_rbt.h"
71 #include "../lib/util/bitmap.h"
72 #include "librpc/gen_ndr/nbt.h"
74 #ifdef HAVE_SYS_SYSCTL_H
75 #include <sys/sysctl.h>
80 extern userdom_struct current_user_info;
82 /* the special value for the include parameter
83 * to be interpreted not as a file name but to
84 * trigger loading of the global smb.conf options
86 #ifndef INCLUDE_REGISTRY_NAME
87 #define INCLUDE_REGISTRY_NAME "registry"
90 static bool in_client = false; /* Not in the client by default */
91 static struct smbconf_csn conf_last_csn;
93 static int config_backend = CONFIG_BACKEND_FILE;
95 /* some helpful bits */
96 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && (ServicePtrs != NULL) && ServicePtrs[(i)]->valid)
97 #define VALID(i) (ServicePtrs != NULL && ServicePtrs[i]->valid)
99 #define USERSHARE_VALID 1
100 #define USERSHARE_PENDING_DELETE 2
102 static bool defaults_saved = false;
104 #include "lib/param/param_global.h"
106 static struct loadparm_global Globals;
108 /* This is a default service used to prime a services structure */
109 static struct loadparm_service sDefault =
114 .usershare_last_mod = {0, 0},
118 .invalid_users = NULL,
125 .root_preexec = NULL,
126 .root_postexec = NULL,
127 .cups_options = NULL,
128 .print_command = NULL,
130 .lprm_command = NULL,
131 .lppause_command = NULL,
132 .lpresume_command = NULL,
133 .queuepause_command = NULL,
134 .queueresume_command = NULL,
135 ._printername = NULL,
136 .printjob_username = NULL,
137 .dont_descend = NULL,
140 .magic_script = NULL,
141 .magic_output = NULL,
144 .veto_oplock_files = NULL,
154 .aio_write_behind = NULL,
155 .dfree_command = NULL,
156 .min_print_space = 0,
157 .max_print_jobs = 1000,
158 .max_reported_print_jobs = 0,
159 .write_cache_size = 0,
161 .force_create_mode = 0,
162 .directory_mask = 0755,
163 .force_directory_mode = 0,
164 .max_connections = 0,
165 .default_case = CASE_LOWER,
166 .printing = DEFAULT_PRINTING,
167 .oplock_contention_limit = 2,
170 .dfree_cache_time = 0,
171 .preexec_close = false,
172 .root_preexec_close = false,
173 .case_sensitive = Auto,
174 .preserve_case = true,
175 .short_preserve_case = true,
176 .hide_dot_files = true,
177 .hide_special_files = false,
178 .hide_unreadable = false,
179 .hide_unwriteable_files = false,
181 .access_based_share_enum = false,
186 .administrative_share = false,
189 .print_notify_backchannel = false,
193 .store_dos_attributes = false,
194 .dmapi_support = false,
196 .strict_locking = Auto,
197 .posix_locking = true,
199 .kernel_oplocks = false,
200 .level2_oplocks = true,
202 .mangled_names = true,
204 .follow_symlinks = true,
205 .sync_always = false,
206 .strict_allocate = false,
207 .strict_rename = false,
208 .strict_sync = false,
209 .mangling_char = '~',
211 .delete_readonly = false,
212 .fake_oplocks = false,
213 .delete_veto_files = false,
214 .dos_filemode = false,
215 .dos_filetimes = true,
216 .dos_filetime_resolution = false,
217 .fake_directory_create_times = false,
218 .blocking_locks = true,
219 .inherit_permissions = false,
220 .inherit_acls = false,
221 .inherit_owner = false,
223 .msdfs_shuffle_referrals = false,
224 .use_client_driver = false,
225 .default_devmode = true,
226 .force_printername = false,
227 .nt_acl_support = true,
228 .force_unknown_acl_user = false,
229 ._use_sendfile = false,
230 .profile_acls = false,
231 .map_acl_inherit = false,
234 .acl_check_permissions = true,
235 .acl_map_full_control = true,
236 .acl_group_control = false,
237 .acl_allow_execute_always = false,
238 .allocation_roundup_size = SMB_ROUNDUP_ALLOCATION_SIZE,
241 .map_readonly = MAP_READONLY_YES,
242 .directory_name_cache_size = 100,
243 .smb_encrypt = SMB_SIGNING_DEFAULT,
244 .kernel_share_modes = true,
245 .durable_handles = true,
250 /* local variables */
251 static struct loadparm_service **ServicePtrs = NULL;
252 static int iNumServices = 0;
253 static int iServiceIndex = 0;
254 static struct db_context *ServiceHash;
255 static bool bInGlobalSection = true;
256 static bool bGlobalOnly = false;
257 static struct file_lists *file_lists = NULL;
258 static unsigned int *flags_list = NULL;
260 static void set_allowed_client_auth(void);
262 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue);
263 static void free_param_opts(struct parmlist_entry **popts);
265 /* this is used to prevent lots of mallocs of size 1 */
266 static const char null_string[] = "";
272 static void string_free(char **s)
276 if (*s == null_string)
282 Set a string value, deallocating any existing space, and allocing the space
286 static bool string_set(TALLOC_CTX *mem_ctx, char **dest,const char *src)
294 (*dest) = talloc_strdup(mem_ctx, src);
295 if ((*dest) == NULL) {
296 DEBUG(0,("Out of memory in string_init\n"));
304 * Function to return the default value for the maximum number of open
305 * file descriptors permitted. This function tries to consult the
306 * kernel-level (sysctl) and ulimit (getrlimit()) values and goes
307 * the smaller of those.
309 static int max_open_files(void)
311 int sysctl_max = MAX_OPEN_FILES;
312 int rlimit_max = MAX_OPEN_FILES;
314 #ifdef HAVE_SYSCTLBYNAME
316 size_t size = sizeof(sysctl_max);
317 sysctlbyname("kern.maxfilesperproc", &sysctl_max, &size, NULL,
322 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
328 if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
329 rlimit_max = rl.rlim_cur;
331 #if defined(RLIM_INFINITY)
332 if(rl.rlim_cur == RLIM_INFINITY)
333 rlimit_max = MAX_OPEN_FILES;
338 if (sysctl_max < MIN_OPEN_FILES_WINDOWS) {
339 DEBUG(2,("max_open_files: increasing sysctl_max (%d) to "
340 "minimum Windows limit (%d)\n",
342 MIN_OPEN_FILES_WINDOWS));
343 sysctl_max = MIN_OPEN_FILES_WINDOWS;
346 if (rlimit_max < MIN_OPEN_FILES_WINDOWS) {
347 DEBUG(2,("rlimit_max: increasing rlimit_max (%d) to "
348 "minimum Windows limit (%d)\n",
350 MIN_OPEN_FILES_WINDOWS));
351 rlimit_max = MIN_OPEN_FILES_WINDOWS;
354 return MIN(sysctl_max, rlimit_max);
358 * Common part of freeing allocated data for one parameter.
360 static void free_one_parameter_common(void *parm_ptr,
361 struct parm_struct parm)
363 if ((parm.type == P_STRING) ||
364 (parm.type == P_USTRING))
366 string_free((char**)parm_ptr);
367 } else if (parm.type == P_LIST || parm.type == P_CMDLIST) {
368 TALLOC_FREE(*((char***)parm_ptr));
373 * Free the allocated data for one parameter for a share
374 * given as a service struct.
376 static void free_one_parameter(struct loadparm_service *service,
377 struct parm_struct parm)
381 if (parm.p_class != P_LOCAL) {
385 parm_ptr = lp_parm_ptr(service, &parm);
387 free_one_parameter_common(parm_ptr, parm);
391 * Free the allocated parameter data of a share given
392 * as a service struct.
394 static void free_parameters(struct loadparm_service *service)
398 for (i=0; parm_table[i].label; i++) {
399 free_one_parameter(service, parm_table[i]);
404 * Free the allocated data for one parameter for a given share
405 * specified by an snum.
407 static void free_one_parameter_by_snum(int snum, struct parm_struct parm)
412 parm_ptr = lp_parm_ptr(NULL, &parm);
413 } else if (parm.p_class != P_LOCAL) {
416 parm_ptr = lp_parm_ptr(ServicePtrs[snum], &parm);
419 free_one_parameter_common(parm_ptr, parm);
423 * Free the allocated parameter data for a share specified
426 static void free_parameters_by_snum(int snum)
430 for (i=0; parm_table[i].label; i++) {
431 free_one_parameter_by_snum(snum, parm_table[i]);
436 * Free the allocated global parameters.
438 static void free_global_parameters(void)
440 free_param_opts(&Globals.param_opt);
441 free_parameters_by_snum(GLOBAL_SECTION_SNUM);
442 TALLOC_FREE(Globals.ctx);
445 struct lp_stored_option {
446 struct lp_stored_option *prev, *next;
451 static struct lp_stored_option *stored_options;
454 save options set by lp_set_cmdline() into a list. This list is
455 re-applied when we do a globals reset, so that cmdline set options
456 are sticky across reloads of smb.conf
458 bool store_lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
460 struct lp_stored_option *entry, *entry_next;
461 for (entry = stored_options; entry != NULL; entry = entry_next) {
462 entry_next = entry->next;
463 if (strcmp(pszParmName, entry->label) == 0) {
464 DLIST_REMOVE(stored_options, entry);
470 entry = talloc(NULL, struct lp_stored_option);
475 entry->label = talloc_strdup(entry, pszParmName);
481 entry->value = talloc_strdup(entry, pszParmValue);
487 DLIST_ADD_END(stored_options, entry, struct lp_stored_option);
492 static bool apply_lp_set_cmdline(void)
494 struct lp_stored_option *entry = NULL;
495 for (entry = stored_options; entry != NULL; entry = entry->next) {
496 if (!lp_set_cmdline_helper(entry->label, entry->value)) {
497 DEBUG(0, ("Failed to re-apply cmdline parameter %s = %s\n",
498 entry->label, entry->value));
505 /***************************************************************************
506 Initialise the global parameter structure.
507 ***************************************************************************/
509 static void init_globals(struct loadparm_context *lp_ctx, bool reinit_globals)
511 static bool done_init = false;
515 /* If requested to initialize only once and we've already done it... */
516 if (!reinit_globals && done_init) {
517 /* ... then we have nothing more to do */
522 /* The logfile can be set before this is invoked. Free it if so. */
523 if (Globals.logfile != NULL) {
524 string_free(&Globals.logfile);
525 Globals.logfile = NULL;
529 free_global_parameters();
532 /* This memset and the free_global_parameters() above will
533 * wipe out smb.conf options set with lp_set_cmdline(). The
534 * apply_lp_set_cmdline() call puts these values back in the
535 * table once the defaults are set */
536 ZERO_STRUCT(Globals);
538 Globals.ctx = talloc_pooled_object(NULL, char, 272, 2048);
540 /* Initialize the flags list if necessary */
541 if (flags_list == NULL) {
545 for (i = 0; parm_table[i].label; i++) {
546 if ((parm_table[i].type == P_STRING ||
547 parm_table[i].type == P_USTRING))
549 string_set(Globals.ctx, (char **)lp_parm_ptr(NULL, &parm_table[i]), "");
554 string_set(Globals.ctx, &sDefault.fstype, FSTYPE_STRING);
555 string_set(Globals.ctx, &sDefault.printjob_username, "%U");
557 init_printer_values(lp_ctx, Globals.ctx, &sDefault);
559 sDefault.ntvfs_handler = str_list_make_v3_const(NULL, "unixuid default", NULL);
561 DEBUG(3, ("Initialising global parameters\n"));
563 /* Must manually force to upper case here, as this does not go via the handler */
564 string_set(Globals.ctx, &Globals.netbios_name, myhostname_upper());
566 string_set(Globals.ctx, &Globals.smb_passwd_file, get_dyn_SMB_PASSWD_FILE());
567 string_set(Globals.ctx, &Globals.private_dir, get_dyn_PRIVATE_DIR());
569 /* use the new 'hash2' method by default, with a prefix of 1 */
570 string_set(Globals.ctx, &Globals.mangling_method, "hash2");
571 Globals.mangle_prefix = 1;
573 string_set(Globals.ctx, &Globals.guest_account, GUEST_ACCOUNT);
575 /* using UTF8 by default allows us to support all chars */
576 string_set(Globals.ctx, &Globals.unix_charset, DEFAULT_UNIX_CHARSET);
578 /* Use codepage 850 as a default for the dos character set */
579 string_set(Globals.ctx, &Globals.dos_charset, DEFAULT_DOS_CHARSET);
582 * Allow the default PASSWD_CHAT to be overridden in local.h.
584 string_set(Globals.ctx, &Globals.passwd_chat, DEFAULT_PASSWD_CHAT);
586 string_set(Globals.ctx, &Globals.workgroup, DEFAULT_WORKGROUP);
588 string_set(Globals.ctx, &Globals.passwd_program, "");
589 string_set(Globals.ctx, &Globals.lock_directory, get_dyn_LOCKDIR());
590 string_set(Globals.ctx, &Globals.state_directory, get_dyn_STATEDIR());
591 string_set(Globals.ctx, &Globals.cache_directory, get_dyn_CACHEDIR());
592 string_set(Globals.ctx, &Globals.pid_directory, get_dyn_PIDDIR());
593 string_set(Globals.ctx, &Globals.nbt_client_socket_address, "0.0.0.0");
595 * By default support explicit binding to broadcast
598 Globals.nmbd_bind_explicit_broadcast = true;
600 s = talloc_asprintf(talloc_tos(), "Samba %s", samba_version_string());
602 smb_panic("init_globals: ENOMEM");
604 string_set(Globals.ctx, &Globals.server_string, s);
607 string_set(Globals.ctx, &Globals.panic_action, "/bin/sleep 999999999");
610 string_set(Globals.ctx, &Globals.socket_options, DEFAULT_SOCKET_OPTIONS);
612 string_set(Globals.ctx, &Globals.logon_drive, "");
613 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
614 string_set(Globals.ctx, &Globals.logon_home, "\\\\%N\\%U");
615 string_set(Globals.ctx, &Globals.logon_path, "\\\\%N\\%U\\profile");
617 Globals.name_resolve_order = str_list_make_v3_const(NULL, "lmhosts wins host bcast", NULL);
618 string_set(Globals.ctx, &Globals.password_server, "*");
620 Globals.algorithmic_rid_base = BASE_RID;
622 Globals.load_printers = true;
623 Globals.printcap_cache_time = 750; /* 12.5 minutes */
625 Globals.config_backend = config_backend;
626 Globals._server_role = ROLE_AUTO;
628 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
629 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
630 Globals.max_xmit = 0x4104;
631 Globals.max_mux = 50; /* This is *needed* for profile support. */
632 Globals.lpq_cache_time = 30; /* changed to handle large print servers better -- jerry */
633 Globals._disable_spoolss = false;
634 Globals.max_smbd_processes = 0;/* no limit specified */
635 Globals.username_level = 0;
636 Globals.deadtime = 0;
637 Globals.getwd_cache = true;
638 Globals.large_readwrite = true;
639 Globals.max_log_size = 5000;
640 Globals.max_open_files = max_open_files();
641 Globals.server_max_protocol = PROTOCOL_SMB3_11;
642 Globals.server_min_protocol = PROTOCOL_LANMAN1;
643 Globals._client_max_protocol = PROTOCOL_DEFAULT;
644 Globals.client_min_protocol = PROTOCOL_CORE;
645 Globals._security = SEC_AUTO;
646 Globals.encrypt_passwords = true;
647 Globals.client_schannel = Auto;
648 Globals.winbind_sealed_pipes = true;
649 Globals.require_strong_key = true;
650 Globals.server_schannel = Auto;
651 Globals.read_raw = true;
652 Globals.write_raw = true;
653 Globals.null_passwords = false;
654 Globals.old_password_allowed_period = 60;
655 Globals.obey_pam_restrictions = false;
657 Globals.syslog_only = false;
658 Globals.timestamp_logs = true;
659 string_set(Globals.ctx, &Globals.log_level, "0");
660 Globals.debug_prefix_timestamp = false;
661 Globals.debug_hires_timestamp = true;
662 Globals.debug_pid = false;
663 Globals.debug_uid = false;
664 Globals.debug_class = false;
665 Globals.enable_core_files = true;
666 Globals.max_ttl = 60 * 60 * 24 * 3; /* 3 days default. */
667 Globals.max_wins_ttl = 60 * 60 * 24 * 6; /* 6 days default. */
668 Globals.min_wins_ttl = 60 * 60 * 6; /* 6 hours default. */
669 Globals.machine_password_timeout = 60 * 60 * 24 * 7; /* 7 days default. */
670 Globals.lm_announce = Auto; /* = Auto: send only if LM clients found */
671 Globals.lm_interval = 60;
672 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
673 Globals.nis_homedir = false;
674 #ifdef WITH_NISPLUS_HOME
675 string_set(Globals.ctx, &Globals.homedir_map, "auto_home.org_dir");
677 string_set(Globals.ctx, &Globals.homedir_map, "auto.home");
680 Globals.time_server = false;
681 Globals.bind_interfaces_only = false;
682 Globals.unix_password_sync = false;
683 Globals.pam_password_change = false;
684 Globals.passwd_chat_debug = false;
685 Globals.passwd_chat_timeout = 2; /* 2 second default. */
686 Globals.nt_pipe_support = true; /* Do NT pipes by default. */
687 Globals.nt_status_support = true; /* Use NT status by default. */
688 Globals.smbd_profiling_level = 0;
689 Globals.stat_cache = true; /* use stat cache by default */
690 Globals.max_stat_cache_size = 256; /* 256k by default */
691 Globals.restrict_anonymous = 0;
692 Globals.client_lanman_auth = false; /* Do NOT use the LanMan hash if it is available */
693 Globals.client_plaintext_auth = false; /* Do NOT use a plaintext password even if is requested by the server */
694 Globals.lanman_auth = false; /* Do NOT use the LanMan hash, even if it is supplied */
695 Globals.ntlm_auth = true; /* Do use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
696 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 */
697 /* Note, that we will also use NTLM2 session security (which is different), if it is available */
699 Globals.map_to_guest = 0; /* By Default, "Never" */
700 Globals.oplock_break_wait_time = 0; /* By Default, 0 msecs. */
701 Globals.enhanced_browsing = true;
702 Globals.lock_spin_time = WINDOWS_MINIMUM_LOCK_TIMEOUT_MS; /* msec. */
703 #ifdef MMAP_BLACKLIST
704 Globals.use_mmap = false;
706 Globals.use_mmap = true;
708 Globals.unicode = true;
709 Globals.unix_extensions = true;
710 Globals.reset_on_zero_vc = false;
711 Globals.log_writeable_files_on_exit = false;
712 Globals.create_krb5_conf = true;
713 Globals._winbind_max_domain_connections = 1;
715 /* hostname lookups can be very expensive and are broken on
716 a large number of sites (tridge) */
717 Globals.hostname_lookups = false;
719 Globals.change_notify = true,
720 Globals.kernel_change_notify = true,
722 string_set(Globals.ctx, &Globals.passdb_backend, "tdbsam");
723 string_set(Globals.ctx, &Globals.ldap_suffix, "");
724 string_set(Globals.ctx, &Globals._ldap_machine_suffix, "");
725 string_set(Globals.ctx, &Globals._ldap_user_suffix, "");
726 string_set(Globals.ctx, &Globals._ldap_group_suffix, "");
727 string_set(Globals.ctx, &Globals._ldap_idmap_suffix, "");
729 string_set(Globals.ctx, &Globals.ldap_admin_dn, "");
730 Globals.ldap_ssl = LDAP_SSL_START_TLS;
731 Globals.ldap_ssl_ads = false;
732 Globals.ldap_deref = -1;
733 Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
734 Globals.ldap_delete_dn = false;
735 Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
736 Globals.ldap_follow_referral = Auto;
737 Globals.ldap_timeout = LDAP_DEFAULT_TIMEOUT;
738 Globals.ldap_connection_timeout = LDAP_CONNECTION_DEFAULT_TIMEOUT;
739 Globals.ldap_page_size = LDAP_PAGE_SIZE;
741 Globals.ldap_debug_level = 0;
742 Globals.ldap_debug_threshold = 10;
744 Globals.client_ldap_sasl_wrapping = ADS_AUTH_SASL_SIGN;
746 /* This is what we tell the afs client. in reality we set the token
747 * to never expire, though, when this runs out the afs client will
748 * forget the token. Set to 0 to get NEVERDATE.*/
749 Globals.afs_token_lifetime = 604800;
750 Globals.cups_connection_timeout = CUPS_DEFAULT_CONNECTION_TIMEOUT;
752 /* these parameters are set to defaults that are more appropriate
753 for the increasing samba install base:
755 as a member of the workgroup, that will possibly become a
756 _local_ master browser (lm = true). this is opposed to a forced
757 local master browser startup (pm = true).
759 doesn't provide WINS server service by default (wsupp = false),
760 and doesn't provide domain master browser services by default, either.
764 Globals.show_add_printer_wizard = true;
765 Globals.os_level = 20;
766 Globals.local_master = true;
767 Globals._domain_master = Auto; /* depending on _domain_logons */
768 Globals._domain_logons = false;
769 Globals.browse_list = true;
770 Globals.we_are_a_wins_server = false;
771 Globals.wins_proxy = false;
773 TALLOC_FREE(Globals.init_logon_delayed_hosts);
774 Globals.init_logon_delay = 100; /* 100 ms default delay */
776 Globals.wins_dns_proxy = true;
778 Globals.allow_trusted_domains = true;
779 string_set(Globals.ctx, &Globals.szIdmapBackend, "tdb");
781 string_set(Globals.ctx, &Globals.template_shell, "/bin/false");
782 string_set(Globals.ctx, &Globals.template_homedir, "/home/%D/%U");
783 string_set(Globals.ctx, &Globals.winbind_separator, "\\");
784 string_set(Globals.ctx, &Globals.winbindd_socket_directory, dyn_WINBINDD_SOCKET_DIR);
786 string_set(Globals.ctx, &Globals.cups_server, "");
787 string_set(Globals.ctx, &Globals.iprint_server, "");
789 string_set(Globals.ctx, &Globals._ctdbd_socket, "");
791 Globals.cluster_addresses = NULL;
792 Globals.clustering = false;
793 Globals.ctdb_timeout = 0;
794 Globals.ctdb_locktime_warn_threshold = 0;
796 Globals.winbind_cache_time = 300; /* 5 minutes */
797 Globals.winbind_reconnect_delay = 30; /* 30 seconds */
798 Globals.winbind_request_timeout = 60; /* 60 seconds */
799 Globals.winbind_max_clients = 200;
800 Globals.winbind_enum_users = false;
801 Globals.winbind_enum_groups = false;
802 Globals.winbind_use_default_domain = false;
803 Globals.winbind_trusted_domains_only = false;
804 Globals.winbind_nested_groups = true;
805 Globals.winbind_expand_groups = 0;
806 Globals.winbind_nss_info = str_list_make_v3_const(NULL, "template", NULL);
807 Globals.winbind_refresh_tickets = false;
808 Globals.winbind_offline_logon = false;
810 Globals.idmap_cache_time = 86400 * 7; /* a week by default */
811 Globals.idmap_negative_cache_time = 120; /* 2 minutes by default */
813 Globals.passdb_expand_explicit = false;
815 Globals.name_cache_timeout = 660; /* In seconds */
817 Globals.use_spnego = true;
818 Globals.client_use_spnego = true;
820 Globals.client_signing = SMB_SIGNING_DEFAULT;
821 Globals.server_signing = SMB_SIGNING_DEFAULT;
823 Globals.defer_sharing_violations = true;
824 Globals.smb_ports = str_list_make_v3_const(NULL, SMB_PORTS, NULL);
826 Globals.enable_privileges = true;
827 Globals.host_msdfs = true;
828 Globals.enable_asu_support = false;
830 /* User defined shares. */
831 s = talloc_asprintf(talloc_tos(), "%s/usershares", get_dyn_STATEDIR());
833 smb_panic("init_globals: ENOMEM");
835 string_set(Globals.ctx, &Globals.usershare_path, s);
837 string_set(Globals.ctx, &Globals.usershare_template_share, "");
838 Globals.usershare_max_shares = 0;
839 /* By default disallow sharing of directories not owned by the sharer. */
840 Globals.usershare_owner_only = true;
841 /* By default disallow guest access to usershares. */
842 Globals.usershare_allow_guests = false;
844 Globals.keepalive = DEFAULT_KEEPALIVE;
846 /* By default no shares out of the registry */
847 Globals.registry_shares = false;
849 Globals.min_receivefile_size = 0;
851 Globals.map_untrusted_to_domain = false;
852 Globals.multicast_dns_register = true;
854 Globals.smb2_max_read = DEFAULT_SMB2_MAX_READ;
855 Globals.smb2_max_write = DEFAULT_SMB2_MAX_WRITE;
856 Globals.smb2_max_trans = DEFAULT_SMB2_MAX_TRANSACT;
857 Globals.smb2_max_credits = DEFAULT_SMB2_MAX_CREDITS;
858 Globals.smb2_leases = false;
860 string_set(Globals.ctx, &Globals.ncalrpc_dir, get_dyn_NCALRPCDIR());
862 Globals.server_services = str_list_make_v3_const(NULL, "s3fs rpc nbt wrepl ldap cldap kdc drepl winbindd ntp_signd kcc dnsupdate dns", NULL);
864 Globals.dcerpc_endpoint_servers = str_list_make_v3_const(NULL, "epmapper wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi dssetup unixinfo browser eventlog6 backupkey dnsserver", NULL);
866 Globals.tls_enabled = true;
868 string_set(Globals.ctx, &Globals._tls_keyfile, "tls/key.pem");
869 string_set(Globals.ctx, &Globals._tls_certfile, "tls/cert.pem");
870 string_set(Globals.ctx, &Globals._tls_cafile, "tls/ca.pem");
871 string_set(Globals.ctx, &Globals.tls_priority, "NORMAL:-VERS-SSL3.0");
873 string_set(Globals.ctx, &Globals.share_backend, "classic");
875 Globals._preferred_master = Auto;
877 Globals.allow_dns_updates = DNS_UPDATE_SIGNED;
879 string_set(Globals.ctx, &Globals.ntp_signd_socket_directory, get_dyn_NTP_SIGND_SOCKET_DIR());
881 string_set(Globals.ctx, &Globals.winbindd_privileged_socket_directory, get_dyn_WINBINDD_PRIVILEGED_SOCKET_DIR());
883 s = talloc_asprintf(talloc_tos(), "%s/samba_kcc", get_dyn_SCRIPTSBINDIR());
885 smb_panic("init_globals: ENOMEM");
887 Globals.samba_kcc_command = str_list_make_v3_const(NULL, s, NULL);
890 s = talloc_asprintf(talloc_tos(), "%s/samba_dnsupdate", get_dyn_SCRIPTSBINDIR());
892 smb_panic("init_globals: ENOMEM");
894 Globals.dns_update_command = str_list_make_v3_const(NULL, s, NULL);
897 s = talloc_asprintf(talloc_tos(), "%s/samba_spnupdate", get_dyn_SCRIPTSBINDIR());
899 smb_panic("init_globals: ENOMEM");
901 Globals.spn_update_command = str_list_make_v3_const(NULL, s, NULL);
904 Globals.nsupdate_command = str_list_make_v3_const(NULL, "/usr/bin/nsupdate -g", NULL);
906 Globals.rndc_command = str_list_make_v3_const(NULL, "/usr/sbin/rndc", NULL);
908 Globals.cldap_port = 389;
910 Globals.dgram_port = NBT_DGRAM_SERVICE_PORT;
912 Globals.nbt_port = NBT_NAME_SERVICE_PORT;
914 Globals.krb5_port = 88;
916 Globals.kpasswd_port = 464;
918 Globals.web_port = 901;
920 /* Now put back the settings that were set with lp_set_cmdline() */
921 apply_lp_set_cmdline();
924 /* Convenience routine to setup an lp_context with additional s3 variables */
925 static struct loadparm_context *setup_lp_context(TALLOC_CTX *mem_ctx)
927 struct loadparm_context *lp_ctx;
929 lp_ctx = loadparm_init_s3(mem_ctx,
930 loadparm_s3_helpers());
931 if (lp_ctx == NULL) {
932 DEBUG(0, ("loadparm_init_s3 failed\n"));
936 lp_ctx->sDefault = &sDefault;
937 lp_ctx->services = NULL; /* We do not want to access this directly */
938 lp_ctx->bInGlobalSection = bInGlobalSection;
939 lp_ctx->flags = flags_list;
944 /*******************************************************************
945 Convenience routine to grab string parameters into talloced memory
946 and run standard_sub_basic on them. The buffers can be written to by
947 callers without affecting the source string.
948 ********************************************************************/
950 char *lp_string(TALLOC_CTX *ctx, const char *s)
954 /* The follow debug is useful for tracking down memory problems
955 especially if you have an inner loop that is calling a lp_*()
956 function that returns a string. Perhaps this debug should be
957 present all the time? */
960 DEBUG(10, ("lp_string(%s)\n", s));
966 ret = talloc_sub_basic(ctx,
967 get_current_username(),
968 current_user_info.domain,
970 if (trim_char(ret, '\"', '\"')) {
971 if (strchr(ret,'\"') != NULL) {
973 ret = talloc_sub_basic(ctx,
974 get_current_username(),
975 current_user_info.domain,
983 In this section all the functions that are used to access the
984 parameters from the rest of the program are defined
987 #define FN_GLOBAL_STRING(fn_name,ptr) \
988 char *lp_ ## fn_name(TALLOC_CTX *ctx) {return(lp_string((ctx), *(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : ""));}
989 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
990 const char *lp_ ## fn_name(void) {return(*(const char * const *)(&Globals.ptr) ? *(const char * const *)(&Globals.ptr) : "");}
991 #define FN_GLOBAL_LIST(fn_name,ptr) \
992 const char **lp_ ## fn_name(void) {return(*(const char ***)(&Globals.ptr));}
993 #define FN_GLOBAL_BOOL(fn_name,ptr) \
994 bool lp_ ## fn_name(void) {return(*(bool *)(&Globals.ptr));}
995 #define FN_GLOBAL_CHAR(fn_name,ptr) \
996 char lp_ ## fn_name(void) {return(*(char *)(&Globals.ptr));}
997 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
998 int lp_ ## fn_name(void) {return(*(int *)(&Globals.ptr));}
1000 #define FN_LOCAL_STRING(fn_name,val) \
1001 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));}
1002 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1003 const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1004 #define FN_LOCAL_LIST(fn_name,val) \
1005 const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1006 #define FN_LOCAL_BOOL(fn_name,val) \
1007 bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1008 #define FN_LOCAL_INTEGER(fn_name,val) \
1009 int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1011 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1012 bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1013 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1014 int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1015 #define FN_LOCAL_PARM_CHAR(fn_name,val) \
1016 char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1018 int lp_winbind_max_domain_connections(void)
1020 if (lp_winbind_offline_logon() &&
1021 lp__winbind_max_domain_connections() > 1) {
1022 DEBUG(1, ("offline logons active, restricting max domain "
1023 "connections to 1\n"));
1026 return MAX(1, lp__winbind_max_domain_connections());
1029 /* These functions remain in source3/param for now */
1031 #include "lib/param/param_functions.c"
1033 FN_LOCAL_STRING(servicename, szService)
1034 FN_LOCAL_CONST_STRING(const_servicename, szService)
1036 /* These functions cannot be auto-generated */
1037 FN_LOCAL_BOOL(autoloaded, autoloaded)
1038 FN_GLOBAL_CONST_STRING(dnsdomain, dnsdomain)
1040 /* local prototypes */
1042 static int map_parameter_canonical(const char *pszParmName, bool *inverse);
1043 static const char *get_boolean(bool bool_value);
1044 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
1046 static bool hash_a_service(const char *name, int number);
1047 static void free_service_byindex(int iService);
1048 static void show_parameter(int parmIndex);
1049 static bool is_synonym_of(int parm1, int parm2, bool *inverse);
1052 * This is a helper function for parametrical options support. It returns a
1053 * pointer to parametrical option value if it exists or NULL otherwise. Actual
1054 * parametrical functions are quite simple
1056 static struct parmlist_entry *get_parametrics(int snum, const char *type,
1059 if (snum >= iNumServices) return NULL;
1062 return get_parametric_helper(NULL, type, option, Globals.param_opt);
1064 return get_parametric_helper(ServicePtrs[snum],
1065 type, option, Globals.param_opt);
1070 #define MISSING_PARAMETER(name) \
1071 DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
1073 /*******************************************************************
1074 convenience routine to return enum parameters.
1075 ********************************************************************/
1076 static int lp_enum(const char *s,const struct enum_list *_enum)
1080 if (!s || !*s || !_enum) {
1081 MISSING_PARAMETER(lp_enum);
1085 for (i=0; _enum[i].name; i++) {
1086 if (strequal(_enum[i].name,s))
1087 return _enum[i].value;
1090 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
1094 #undef MISSING_PARAMETER
1096 /* Return parametric option from a given service. Type is a part of option before ':' */
1097 /* Parametric option has following syntax: 'Type: option = value' */
1098 char *lp_parm_talloc_string(TALLOC_CTX *ctx, int snum, const char *type, const char *option, const char *def)
1100 struct parmlist_entry *data = get_parametrics(snum, type, option);
1102 if (data == NULL||data->value==NULL) {
1104 return lp_string(ctx, def);
1110 return lp_string(ctx, data->value);
1113 /* Return parametric option from a given service. Type is a part of option before ':' */
1114 /* Parametric option has following syntax: 'Type: option = value' */
1115 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
1117 struct parmlist_entry *data = get_parametrics(snum, type, option);
1119 if (data == NULL||data->value==NULL)
1126 /* Return parametric option from a given service. Type is a part of option before ':' */
1127 /* Parametric option has following syntax: 'Type: option = value' */
1129 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
1131 struct parmlist_entry *data = get_parametrics(snum, type, option);
1133 if (data == NULL||data->value==NULL)
1134 return (const char **)def;
1136 if (data->list==NULL) {
1137 data->list = str_list_make_v3(NULL, data->value, NULL);
1140 return discard_const_p(const char *, data->list);
1143 /* Return parametric option from a given service. Type is a part of option before ':' */
1144 /* Parametric option has following syntax: 'Type: option = value' */
1146 int lp_parm_int(int snum, const char *type, const char *option, int def)
1148 struct parmlist_entry *data = get_parametrics(snum, type, option);
1150 if (data && data->value && *data->value)
1151 return lp_int(data->value);
1156 /* Return parametric option from a given service. Type is a part of option before ':' */
1157 /* Parametric option has following syntax: 'Type: option = value' */
1159 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
1161 struct parmlist_entry *data = get_parametrics(snum, type, option);
1163 if (data && data->value && *data->value)
1164 return lp_ulong(data->value);
1169 /* Return parametric option from a given service. Type is a part of option before ':' */
1170 /* Parametric option has following syntax: 'Type: option = value' */
1172 bool lp_parm_bool(int snum, const char *type, const char *option, bool def)
1174 struct parmlist_entry *data = get_parametrics(snum, type, option);
1176 if (data && data->value && *data->value)
1177 return lp_bool(data->value);
1182 /* Return parametric option from a given service. Type is a part of option before ':' */
1183 /* Parametric option has following syntax: 'Type: option = value' */
1185 int lp_parm_enum(int snum, const char *type, const char *option,
1186 const struct enum_list *_enum, int def)
1188 struct parmlist_entry *data = get_parametrics(snum, type, option);
1190 if (data && data->value && *data->value && _enum)
1191 return lp_enum(data->value, _enum);
1197 * free a param_opts structure.
1198 * param_opts handling should be moved to talloc;
1199 * then this whole functions reduces to a TALLOC_FREE().
1202 static void free_param_opts(struct parmlist_entry **popts)
1204 struct parmlist_entry *opt, *next_opt;
1206 if (*popts != NULL) {
1207 DEBUG(5, ("Freeing parametrics:\n"));
1210 while (opt != NULL) {
1211 string_free(&opt->key);
1212 string_free(&opt->value);
1213 TALLOC_FREE(opt->list);
1214 next_opt = opt->next;
1221 /***************************************************************************
1222 Free the dynamically allocated parts of a service struct.
1223 ***************************************************************************/
1225 static void free_service(struct loadparm_service *pservice)
1230 if (pservice->szService)
1231 DEBUG(5, ("free_service: Freeing service %s\n",
1232 pservice->szService));
1234 free_parameters(pservice);
1236 string_free(&pservice->szService);
1237 TALLOC_FREE(pservice->copymap);
1239 free_param_opts(&pservice->param_opt);
1241 ZERO_STRUCTP(pservice);
1245 /***************************************************************************
1246 remove a service indexed in the ServicePtrs array from the ServiceHash
1247 and free the dynamically allocated parts
1248 ***************************************************************************/
1250 static void free_service_byindex(int idx)
1252 if ( !LP_SNUM_OK(idx) )
1255 ServicePtrs[idx]->valid = false;
1257 /* we have to cleanup the hash record */
1259 if (ServicePtrs[idx]->szService) {
1260 char *canon_name = canonicalize_servicename(
1262 ServicePtrs[idx]->szService );
1264 dbwrap_delete_bystring(ServiceHash, canon_name );
1265 TALLOC_FREE(canon_name);
1268 free_service(ServicePtrs[idx]);
1269 talloc_free_children(ServicePtrs[idx]);
1272 /***************************************************************************
1273 Add a new service to the services array initialising it with the given
1275 ***************************************************************************/
1277 static int add_a_service(const struct loadparm_service *pservice, const char *name)
1280 int num_to_alloc = iNumServices + 1;
1281 struct loadparm_service **tsp = NULL;
1283 /* it might already exist */
1285 i = getservicebyname(name, NULL);
1291 /* if not, then create one */
1293 tsp = talloc_realloc(NULL, ServicePtrs, struct loadparm_service *, num_to_alloc);
1295 DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
1299 ServicePtrs[iNumServices] = talloc_zero(NULL, struct loadparm_service);
1300 if (!ServicePtrs[iNumServices]) {
1301 DEBUG(0,("add_a_service: out of memory!\n"));
1306 ServicePtrs[i]->valid = true;
1308 copy_service(ServicePtrs[i], pservice, NULL);
1310 string_set(ServicePtrs[i], &ServicePtrs[i]->szService, name);
1312 DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
1313 i, ServicePtrs[i]->szService));
1315 if (!hash_a_service(ServicePtrs[i]->szService, i)) {
1322 /***************************************************************************
1323 Convert a string to uppercase and remove whitespaces.
1324 ***************************************************************************/
1326 char *canonicalize_servicename(TALLOC_CTX *ctx, const char *src)
1331 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
1335 result = talloc_strdup(ctx, src);
1336 SMB_ASSERT(result != NULL);
1338 if (!strlower_m(result)) {
1339 TALLOC_FREE(result);
1345 /***************************************************************************
1346 Add a name/index pair for the services array to the hash table.
1347 ***************************************************************************/
1349 static bool hash_a_service(const char *name, int idx)
1353 if ( !ServiceHash ) {
1354 DEBUG(10,("hash_a_service: creating servicehash\n"));
1355 ServiceHash = db_open_rbt(NULL);
1356 if ( !ServiceHash ) {
1357 DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
1362 DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
1365 canon_name = canonicalize_servicename(talloc_tos(), name );
1367 dbwrap_store_bystring(ServiceHash, canon_name,
1368 make_tdb_data((uint8_t *)&idx, sizeof(idx)),
1371 TALLOC_FREE(canon_name);
1376 /***************************************************************************
1377 Add a new home service, with the specified home directory, defaults coming
1379 ***************************************************************************/
1381 bool lp_add_home(const char *pszHomename, int iDefaultService,
1382 const char *user, const char *pszHomedir)
1386 if (pszHomename == NULL || user == NULL || pszHomedir == NULL ||
1387 pszHomedir[0] == '\0') {
1391 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
1396 if (!(*(ServicePtrs[iDefaultService]->path))
1397 || strequal(ServicePtrs[iDefaultService]->path,
1398 lp_path(talloc_tos(), GLOBAL_SECTION_SNUM))) {
1399 string_set(ServicePtrs[i], &ServicePtrs[i]->path, pszHomedir);
1402 if (!(*(ServicePtrs[i]->comment))) {
1403 char *comment = talloc_asprintf(talloc_tos(), "Home directory of %s", user);
1404 if (comment == NULL) {
1407 string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1408 TALLOC_FREE(comment);
1411 /* set the browseable flag from the global default */
1413 ServicePtrs[i]->browseable = sDefault.browseable;
1414 ServicePtrs[i]->access_based_share_enum = sDefault.access_based_share_enum;
1416 ServicePtrs[i]->autoloaded = true;
1418 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
1419 user, ServicePtrs[i]->path ));
1424 /***************************************************************************
1425 Add a new service, based on an old one.
1426 ***************************************************************************/
1428 int lp_add_service(const char *pszService, int iDefaultService)
1430 if (iDefaultService < 0) {
1431 return add_a_service(&sDefault, pszService);
1434 return (add_a_service(ServicePtrs[iDefaultService], pszService));
1437 /***************************************************************************
1438 Add the IPC service.
1439 ***************************************************************************/
1441 static bool lp_add_ipc(const char *ipc_name, bool guest_ok)
1443 char *comment = NULL;
1444 int i = add_a_service(&sDefault, ipc_name);
1449 comment = talloc_asprintf(talloc_tos(), "IPC Service (%s)",
1450 Globals.server_string);
1451 if (comment == NULL) {
1455 string_set(ServicePtrs[i], &ServicePtrs[i]->path, tmpdir());
1456 string_set(ServicePtrs[i], &ServicePtrs[i]->username, "");
1457 string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1458 string_set(ServicePtrs[i], &ServicePtrs[i]->fstype, "IPC");
1459 ServicePtrs[i]->max_connections = 0;
1460 ServicePtrs[i]->available = true;
1461 ServicePtrs[i]->read_only = true;
1462 ServicePtrs[i]->guest_only = false;
1463 ServicePtrs[i]->administrative_share = true;
1464 ServicePtrs[i]->guest_ok = guest_ok;
1465 ServicePtrs[i]->printable = false;
1466 ServicePtrs[i]->browseable = sDefault.browseable;
1468 DEBUG(3, ("adding IPC service\n"));
1470 TALLOC_FREE(comment);
1474 /***************************************************************************
1475 Add a new printer service, with defaults coming from service iFrom.
1476 ***************************************************************************/
1478 bool lp_add_printer(const char *pszPrintername, int iDefaultService)
1480 const char *comment = "From Printcap";
1481 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
1486 /* note that we do NOT default the availability flag to true - */
1487 /* we take it from the default service passed. This allows all */
1488 /* dynamic printers to be disabled by disabling the [printers] */
1489 /* entry (if/when the 'available' keyword is implemented!). */
1491 /* the printer name is set to the service name. */
1492 string_set(ServicePtrs[i], &ServicePtrs[i]->_printername, pszPrintername);
1493 string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
1495 /* set the browseable flag from the gloabl default */
1496 ServicePtrs[i]->browseable = sDefault.browseable;
1498 /* Printers cannot be read_only. */
1499 ServicePtrs[i]->read_only = false;
1500 /* No oplocks on printer services. */
1501 ServicePtrs[i]->oplocks = false;
1502 /* Printer services must be printable. */
1503 ServicePtrs[i]->printable = true;
1505 DEBUG(3, ("adding printer service %s\n", pszPrintername));
1511 /***************************************************************************
1512 Check whether the given parameter name is valid.
1513 Parametric options (names containing a colon) are considered valid.
1514 ***************************************************************************/
1516 bool lp_parameter_is_valid(const char *pszParmName)
1518 return ((lpcfg_map_parameter(pszParmName) != -1) ||
1519 (strchr(pszParmName, ':') != NULL));
1522 /***************************************************************************
1523 Check whether the given name is the name of a global parameter.
1524 Returns true for strings belonging to parameters of class
1525 P_GLOBAL, false for all other strings, also for parametric options
1526 and strings not belonging to any option.
1527 ***************************************************************************/
1529 bool lp_parameter_is_global(const char *pszParmName)
1531 int num = lpcfg_map_parameter(pszParmName);
1534 return (parm_table[num].p_class == P_GLOBAL);
1540 /**************************************************************************
1541 Determine the canonical name for a parameter.
1542 Indicate when it is an inverse (boolean) synonym instead of a
1544 **************************************************************************/
1546 bool lp_canonicalize_parameter(const char *parm_name, const char **canon_parm,
1551 if (!lp_parameter_is_valid(parm_name)) {
1556 num = map_parameter_canonical(parm_name, inverse);
1558 /* parametric option */
1559 *canon_parm = parm_name;
1561 *canon_parm = parm_table[num].label;
1568 /**************************************************************************
1569 Determine the canonical name for a parameter.
1570 Turn the value given into the inverse boolean expression when
1571 the synonym is an invers boolean synonym.
1573 Return true if parm_name is a valid parameter name and
1574 in case it is an invers boolean synonym, if the val string could
1575 successfully be converted to the reverse bool.
1576 Return false in all other cases.
1577 **************************************************************************/
1579 bool lp_canonicalize_parameter_with_value(const char *parm_name,
1581 const char **canon_parm,
1582 const char **canon_val)
1587 if (!lp_parameter_is_valid(parm_name)) {
1593 num = map_parameter_canonical(parm_name, &inverse);
1595 /* parametric option */
1596 *canon_parm = parm_name;
1599 *canon_parm = parm_table[num].label;
1601 if (!lp_invert_boolean(val, canon_val)) {
1613 /***************************************************************************
1614 Map a parameter's string representation to the index of the canonical
1615 form of the parameter (it might be a synonym).
1616 Returns -1 if the parameter string is not recognised.
1617 ***************************************************************************/
1619 static int map_parameter_canonical(const char *pszParmName, bool *inverse)
1621 int parm_num, canon_num;
1622 bool loc_inverse = false;
1624 parm_num = lpcfg_map_parameter(pszParmName);
1625 if ((parm_num < 0) || !(parm_table[parm_num].flags & FLAG_SYNONYM)) {
1626 /* invalid, parametric or no canidate for synonyms ... */
1630 for (canon_num = 0; parm_table[canon_num].label; canon_num++) {
1631 if (is_synonym_of(parm_num, canon_num, &loc_inverse)) {
1632 parm_num = canon_num;
1638 if (inverse != NULL) {
1639 *inverse = loc_inverse;
1644 /***************************************************************************
1645 return true if parameter number parm1 is a synonym of parameter
1646 number parm2 (parm2 being the principal name).
1647 set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
1649 ***************************************************************************/
1651 static bool is_synonym_of(int parm1, int parm2, bool *inverse)
1653 if ((parm_table[parm1].offset == parm_table[parm2].offset) &&
1654 (parm_table[parm1].p_class == parm_table[parm2].p_class) &&
1655 (parm_table[parm1].flags & FLAG_SYNONYM) &&
1656 !(parm_table[parm2].flags & FLAG_SYNONYM))
1658 if (inverse != NULL) {
1659 if ((parm_table[parm1].type == P_BOOLREV) &&
1660 (parm_table[parm2].type == P_BOOL))
1672 /***************************************************************************
1673 Show one parameter's name, type, [values,] and flags.
1674 (helper functions for show_parameter_list)
1675 ***************************************************************************/
1677 static void show_parameter(int parmIndex)
1679 int enumIndex, flagIndex;
1684 const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
1685 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
1686 "P_ENUM", "P_BYTES", "P_CMDLIST" };
1687 unsigned flags[] = { FLAG_DEPRECATED, FLAG_SYNONYM };
1688 const char *flag_names[] = { "FLAG_DEPRECATED", "FLAG_SYNONYM", NULL};
1690 printf("%s=%s", parm_table[parmIndex].label,
1691 type[parm_table[parmIndex].type]);
1692 if (parm_table[parmIndex].type == P_ENUM) {
1695 parm_table[parmIndex].enum_list[enumIndex].name;
1699 enumIndex ? "|" : "",
1700 parm_table[parmIndex].enum_list[enumIndex].name);
1705 for (flagIndex=0; flag_names[flagIndex]; flagIndex++) {
1706 if (parm_table[parmIndex].flags & flags[flagIndex]) {
1709 flag_names[flagIndex]);
1714 /* output synonyms */
1716 for (parmIndex2=0; parm_table[parmIndex2].label; parmIndex2++) {
1717 if (is_synonym_of(parmIndex, parmIndex2, &inverse)) {
1718 printf(" (%ssynonym of %s)", inverse ? "inverse " : "",
1719 parm_table[parmIndex2].label);
1720 } else if (is_synonym_of(parmIndex2, parmIndex, &inverse)) {
1722 printf(" (synonyms: ");
1727 printf("%s%s", parm_table[parmIndex2].label,
1728 inverse ? "[i]" : "");
1738 /***************************************************************************
1739 Show all parameter's name, type, [values,] and flags.
1740 ***************************************************************************/
1742 void show_parameter_list(void)
1744 int classIndex, parmIndex;
1745 const char *section_names[] = { "local", "global", NULL};
1747 for (classIndex=0; section_names[classIndex]; classIndex++) {
1748 printf("[%s]\n", section_names[classIndex]);
1749 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
1750 if (parm_table[parmIndex].p_class == classIndex) {
1751 show_parameter(parmIndex);
1757 /***************************************************************************
1758 Get the standard string representation of a boolean value ("yes" or "no")
1759 ***************************************************************************/
1761 static const char *get_boolean(bool bool_value)
1763 static const char *yes_str = "yes";
1764 static const char *no_str = "no";
1766 return (bool_value ? yes_str : no_str);
1769 /***************************************************************************
1770 Provide the string of the negated boolean value associated to the boolean
1771 given as a string. Returns false if the passed string does not correctly
1772 represent a boolean.
1773 ***************************************************************************/
1775 bool lp_invert_boolean(const char *str, const char **inverse_str)
1779 if (!set_boolean(str, &val)) {
1783 *inverse_str = get_boolean(!val);
1787 /***************************************************************************
1788 Provide the canonical string representation of a boolean value given
1789 as a string. Return true on success, false if the string given does
1790 not correctly represent a boolean.
1791 ***************************************************************************/
1793 bool lp_canonicalize_boolean(const char *str, const char**canon_str)
1797 if (!set_boolean(str, &val)) {
1801 *canon_str = get_boolean(val);
1805 /***************************************************************************
1806 Find a service by name. Otherwise works like get_service.
1807 ***************************************************************************/
1809 int getservicebyname(const char *pszServiceName, struct loadparm_service *pserviceDest)
1816 if (ServiceHash == NULL) {
1820 canon_name = canonicalize_servicename(talloc_tos(), pszServiceName);
1822 status = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name,
1825 if (NT_STATUS_IS_OK(status) &&
1826 (data.dptr != NULL) &&
1827 (data.dsize == sizeof(iService)))
1829 iService = *(int *)data.dptr;
1832 TALLOC_FREE(canon_name);
1834 if ((iService != -1) && (LP_SNUM_OK(iService))
1835 && (pserviceDest != NULL)) {
1836 copy_service(pserviceDest, ServicePtrs[iService], NULL);
1842 /* Return a pointer to a service by name. Unlike getservicebyname, it does not copy the service */
1843 struct loadparm_service *lp_service(const char *pszServiceName)
1845 int iService = getservicebyname(pszServiceName, NULL);
1846 if (iService == -1 || !LP_SNUM_OK(iService)) {
1849 return ServicePtrs[iService];
1852 struct loadparm_service *lp_servicebynum(int snum)
1854 if ((snum == -1) || !LP_SNUM_OK(snum)) {
1857 return ServicePtrs[snum];
1860 struct loadparm_service *lp_default_loadparm_service()
1865 static struct smbconf_ctx *lp_smbconf_ctx(void)
1868 static struct smbconf_ctx *conf_ctx = NULL;
1870 if (conf_ctx == NULL) {
1871 err = smbconf_init(NULL, &conf_ctx, "registry:");
1872 if (!SBC_ERROR_IS_OK(err)) {
1873 DEBUG(1, ("error initializing registry configuration: "
1874 "%s\n", sbcErrorString(err)));
1882 static bool process_smbconf_service(struct smbconf_service *service)
1887 if (service == NULL) {
1891 ret = lp_do_section(service->name, NULL);
1895 for (count = 0; count < service->num_params; count++) {
1897 if (!bInGlobalSection && bGlobalOnly) {
1900 const char *pszParmName = service->param_names[count];
1901 const char *pszParmValue = service->param_values[count];
1903 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
1905 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
1906 pszParmName, pszParmValue);
1913 if (iServiceIndex >= 0) {
1914 return lpcfg_service_ok(ServicePtrs[iServiceIndex]);
1920 * load a service from registry and activate it
1922 bool process_registry_service(const char *service_name)
1925 struct smbconf_service *service = NULL;
1926 TALLOC_CTX *mem_ctx = talloc_stackframe();
1927 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
1930 if (conf_ctx == NULL) {
1934 DEBUG(5, ("process_registry_service: service name %s\n", service_name));
1936 if (!smbconf_share_exists(conf_ctx, service_name)) {
1938 * Registry does not contain data for this service (yet),
1939 * but make sure lp_load doesn't return false.
1945 err = smbconf_get_share(conf_ctx, mem_ctx, service_name, &service);
1946 if (!SBC_ERROR_IS_OK(err)) {
1950 ret = process_smbconf_service(service);
1956 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
1959 TALLOC_FREE(mem_ctx);
1964 * process_registry_globals
1966 static bool process_registry_globals(void)
1970 add_to_file_list(NULL, &file_lists, INCLUDE_REGISTRY_NAME, INCLUDE_REGISTRY_NAME);
1972 if (!bInGlobalSection && bGlobalOnly) {
1975 const char *pszParmName = "registry shares";
1976 const char *pszParmValue = "yes";
1978 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
1980 ret = lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
1981 pszParmName, pszParmValue);
1988 return process_registry_service(GLOBAL_NAME);
1991 bool process_registry_shares(void)
1995 struct smbconf_service **service = NULL;
1996 uint32_t num_shares = 0;
1997 TALLOC_CTX *mem_ctx = talloc_stackframe();
1998 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2001 if (conf_ctx == NULL) {
2005 err = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &service);
2006 if (!SBC_ERROR_IS_OK(err)) {
2012 for (count = 0; count < num_shares; count++) {
2013 if (strequal(service[count]->name, GLOBAL_NAME)) {
2016 ret = process_smbconf_service(service[count]);
2023 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
2026 TALLOC_FREE(mem_ctx);
2031 * reload those shares from registry that are already
2032 * activated in the services array.
2034 static bool reload_registry_shares(void)
2039 for (i = 0; i < iNumServices; i++) {
2044 if (ServicePtrs[i]->usershare == USERSHARE_VALID) {
2048 ret = process_registry_service(ServicePtrs[i]->szService);
2059 #define MAX_INCLUDE_DEPTH 100
2061 static uint8_t include_depth;
2064 * Free the file lists
2066 static void free_file_list(void)
2068 struct file_lists *f;
2069 struct file_lists *next;
2082 * Utility function for outsiders to check if we're running on registry.
2084 bool lp_config_backend_is_registry(void)
2086 return (lp_config_backend() == CONFIG_BACKEND_REGISTRY);
2090 * Utility function to check if the config backend is FILE.
2092 bool lp_config_backend_is_file(void)
2094 return (lp_config_backend() == CONFIG_BACKEND_FILE);
2097 /*******************************************************************
2098 Check if a config file has changed date.
2099 ********************************************************************/
2101 bool lp_file_list_changed(void)
2103 struct file_lists *f = file_lists;
2105 DEBUG(6, ("lp_file_list_changed()\n"));
2108 if (strequal(f->name, INCLUDE_REGISTRY_NAME)) {
2109 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
2111 if (conf_ctx == NULL) {
2114 if (smbconf_changed(conf_ctx, &conf_last_csn, NULL,
2117 DEBUGADD(6, ("registry config changed\n"));
2124 n2 = talloc_sub_basic(talloc_tos(),
2125 get_current_username(),
2126 current_user_info.domain,
2131 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
2132 f->name, n2, ctime(&f->modtime)));
2134 mod_time = file_modtime(n2);
2137 ((f->modtime != mod_time) ||
2138 (f->subfname == NULL) ||
2139 (strcmp(n2, f->subfname) != 0)))
2142 ("file %s modified: %s\n", n2,
2144 f->modtime = mod_time;
2145 TALLOC_FREE(f->subfname);
2146 f->subfname = talloc_strdup(f, n2);
2147 if (f->subfname == NULL) {
2148 smb_panic("talloc_strdup failed");
2162 * Initialize iconv conversion descriptors.
2164 * This is called the first time it is needed, and also called again
2165 * every time the configuration is reloaded, because the charset or
2166 * codepage might have changed.
2168 static void init_iconv(void)
2170 global_iconv_handle = smb_iconv_handle_reinit(NULL, lp_dos_charset(),
2172 true, global_iconv_handle);
2175 /***************************************************************************
2176 Handle the include operation.
2177 ***************************************************************************/
2178 static bool bAllowIncludeRegistry = true;
2180 bool lp_include(struct loadparm_context *lp_ctx, struct loadparm_service *service,
2181 const char *pszParmValue, char **ptr)
2185 if (include_depth >= MAX_INCLUDE_DEPTH) {
2186 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
2191 if (strequal(pszParmValue, INCLUDE_REGISTRY_NAME)) {
2192 if (!bAllowIncludeRegistry) {
2195 if (lp_ctx->bInGlobalSection) {
2198 ret = process_registry_globals();
2202 DEBUG(1, ("\"include = registry\" only effective "
2203 "in %s section\n", GLOBAL_NAME));
2208 fname = talloc_sub_basic(talloc_tos(), get_current_username(),
2209 current_user_info.domain,
2212 add_to_file_list(NULL, &file_lists, pszParmValue, fname);
2214 if (service == NULL) {
2215 string_set(Globals.ctx, ptr, fname);
2217 string_set(service, ptr, fname);
2220 if (file_exist(fname)) {
2223 ret = pm_process(fname, lp_do_section, do_parameter, lp_ctx);
2229 DEBUG(2, ("Can't find include file %s\n", fname));
2234 bool lp_idmap_range(const char *domain_name, uint32_t *low, uint32_t *high)
2236 char *config_option = NULL;
2237 const char *range = NULL;
2240 SMB_ASSERT(low != NULL);
2241 SMB_ASSERT(high != NULL);
2243 if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2247 config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2249 if (config_option == NULL) {
2250 DEBUG(0, ("out of memory\n"));
2254 range = lp_parm_const_string(-1, config_option, "range", NULL);
2255 if (range == NULL) {
2256 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name));
2260 if (sscanf(range, "%u - %u", low, high) != 2) {
2261 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2262 range, domain_name));
2269 talloc_free(config_option);
2274 bool lp_idmap_default_range(uint32_t *low, uint32_t *high)
2276 return lp_idmap_range("*", low, high);
2279 const char *lp_idmap_backend(const char *domain_name)
2281 char *config_option = NULL;
2282 const char *backend = NULL;
2284 if ((domain_name == NULL) || (domain_name[0] == '\0')) {
2288 config_option = talloc_asprintf(talloc_tos(), "idmap config %s",
2290 if (config_option == NULL) {
2291 DEBUG(0, ("out of memory\n"));
2295 backend = lp_parm_const_string(-1, config_option, "backend", NULL);
2296 if (backend == NULL) {
2297 DEBUG(1, ("idmap backend not specified for domain '%s'\n", domain_name));
2302 talloc_free(config_option);
2306 const char *lp_idmap_default_backend(void)
2308 return lp_idmap_backend("*");
2311 /***************************************************************************
2312 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
2313 ***************************************************************************/
2315 static const char *append_ldap_suffix(TALLOC_CTX *ctx, const char *str )
2317 const char *suffix_string;
2319 suffix_string = talloc_asprintf(ctx, "%s,%s", str,
2320 Globals.ldap_suffix );
2321 if ( !suffix_string ) {
2322 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
2326 return suffix_string;
2329 const char *lp_ldap_machine_suffix(TALLOC_CTX *ctx)
2331 if (Globals._ldap_machine_suffix[0])
2332 return append_ldap_suffix(ctx, Globals._ldap_machine_suffix);
2334 return lp_string(ctx, Globals.ldap_suffix);
2337 const char *lp_ldap_user_suffix(TALLOC_CTX *ctx)
2339 if (Globals._ldap_user_suffix[0])
2340 return append_ldap_suffix(ctx, Globals._ldap_user_suffix);
2342 return lp_string(ctx, Globals.ldap_suffix);
2345 const char *lp_ldap_group_suffix(TALLOC_CTX *ctx)
2347 if (Globals._ldap_group_suffix[0])
2348 return append_ldap_suffix(ctx, Globals._ldap_group_suffix);
2350 return lp_string(ctx, Globals.ldap_suffix);
2353 const char *lp_ldap_idmap_suffix(TALLOC_CTX *ctx)
2355 if (Globals._ldap_idmap_suffix[0])
2356 return append_ldap_suffix(ctx, Globals._ldap_idmap_suffix);
2358 return lp_string(ctx, Globals.ldap_suffix);
2362 return the parameter pointer for a parameter
2364 void *lp_parm_ptr(struct loadparm_service *service, struct parm_struct *parm)
2366 if (service == NULL) {
2367 if (parm->p_class == P_LOCAL)
2368 return (void *)(((char *)&sDefault)+parm->offset);
2369 else if (parm->p_class == P_GLOBAL)
2370 return (void *)(((char *)&Globals)+parm->offset);
2373 return (void *)(((char *)service) + parm->offset);
2377 /***************************************************************************
2378 Process a parameter for a particular service number. If snum < 0
2379 then assume we are in the globals.
2380 ***************************************************************************/
2382 bool lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
2384 TALLOC_CTX *frame = talloc_stackframe();
2385 struct loadparm_context *lp_ctx;
2388 lp_ctx = setup_lp_context(frame);
2389 if (lp_ctx == NULL) {
2395 ok = lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue);
2397 ok = lpcfg_do_service_parameter(lp_ctx, ServicePtrs[snum],
2398 pszParmName, pszParmValue);
2406 /***************************************************************************
2407 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
2408 FLAG_CMDLINE won't be overridden by loads from smb.conf.
2409 ***************************************************************************/
2411 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue)
2414 parmnum = lpcfg_map_parameter(pszParmName);
2416 flags_list[parmnum] &= ~FLAG_CMDLINE;
2417 if (!lp_do_parameter(-1, pszParmName, pszParmValue)) {
2420 flags_list[parmnum] |= FLAG_CMDLINE;
2422 /* we have to also set FLAG_CMDLINE on aliases. Aliases must
2423 * be grouped in the table, so we don't have to search the
2426 i>=0 && parm_table[i].offset == parm_table[parmnum].offset
2427 && parm_table[i].p_class == parm_table[parmnum].p_class;
2429 flags_list[i] |= FLAG_CMDLINE;
2431 for (i=parmnum+1;i<num_parameters() && parm_table[i].offset == parm_table[parmnum].offset
2432 && parm_table[i].p_class == parm_table[parmnum].p_class;i++) {
2433 flags_list[i] |= FLAG_CMDLINE;
2439 /* it might be parametric */
2440 if (strchr(pszParmName, ':') != NULL) {
2441 set_param_opt(NULL, &Globals.param_opt, pszParmName, pszParmValue, FLAG_CMDLINE);
2445 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
2449 bool lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
2452 TALLOC_CTX *frame = talloc_stackframe();
2453 struct loadparm_context *lp_ctx;
2455 lp_ctx = setup_lp_context(frame);
2456 if (lp_ctx == NULL) {
2461 ret = lpcfg_set_cmdline(lp_ctx, pszParmName, pszParmValue);
2467 /***************************************************************************
2468 Process a parameter.
2469 ***************************************************************************/
2471 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
2474 if (!bInGlobalSection && bGlobalOnly)
2477 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
2479 if (bInGlobalSection) {
2480 return lpcfg_do_global_parameter(userdata, pszParmName, pszParmValue);
2482 return lpcfg_do_service_parameter(userdata, ServicePtrs[iServiceIndex],
2483 pszParmName, pszParmValue);
2487 /***************************************************************************
2488 Initialize any local variables in the sDefault table, after parsing a
2490 ***************************************************************************/
2492 static void init_locals(void)
2495 * We run this check once the [globals] is parsed, to force
2496 * the VFS objects and other per-share settings we need for
2497 * the standard way a AD DC is operated. We may change these
2498 * as our code evolves, which is why we force these settings.
2500 * We can't do this at the end of lp_load_ex(), as by that
2501 * point the services have been loaded and they will already
2502 * have "" as their vfs objects.
2504 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
2505 const char **vfs_objects = lp_vfs_objects(-1);
2506 if (!vfs_objects || !vfs_objects[0]) {
2507 if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL)) {
2508 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
2509 } else if (lp_parm_const_string(-1, "posix", "eadb", NULL)) {
2510 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
2512 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
2516 lp_do_parameter(-1, "map hidden", "no");
2517 lp_do_parameter(-1, "map system", "no");
2518 lp_do_parameter(-1, "map readonly", "no");
2519 lp_do_parameter(-1, "map archive", "no");
2520 lp_do_parameter(-1, "store dos attributes", "yes");
2524 /***************************************************************************
2525 Process a new section (service). At this stage all sections are services.
2526 Later we'll have special sections that permit server parameters to be set.
2527 Returns true on success, false on failure.
2528 ***************************************************************************/
2530 bool lp_do_section(const char *pszSectionName, void *userdata)
2532 struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
2534 bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
2535 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
2538 /* if we were in a global section then do the local inits */
2539 if (bInGlobalSection && !isglobal)
2542 /* if we've just struck a global section, note the fact. */
2543 bInGlobalSection = isglobal;
2544 if (lp_ctx != NULL) {
2545 lp_ctx->bInGlobalSection = isglobal;
2548 /* check for multiple global sections */
2549 if (bInGlobalSection) {
2550 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
2554 if (!bInGlobalSection && bGlobalOnly)
2557 /* if we have a current service, tidy it up before moving on */
2560 if (iServiceIndex >= 0)
2561 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
2563 /* if all is still well, move to the next record in the services array */
2565 /* We put this here to avoid an odd message order if messages are */
2566 /* issued by the post-processing of a previous section. */
2567 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
2569 iServiceIndex = add_a_service(&sDefault, pszSectionName);
2570 if (iServiceIndex < 0) {
2571 DEBUG(0, ("Failed to add a new service\n"));
2574 /* Clean all parametric options for service */
2575 /* They will be added during parsing again */
2576 free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
2582 /***************************************************************************
2583 Display the contents of a parameter of a single services record.
2584 ***************************************************************************/
2586 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
2588 bool result = false;
2589 struct loadparm_context *lp_ctx;
2591 lp_ctx = setup_lp_context(talloc_tos());
2592 if (lp_ctx == NULL) {
2597 result = lpcfg_dump_a_parameter(lp_ctx, NULL, parm_name, f);
2599 result = lpcfg_dump_a_parameter(lp_ctx, ServicePtrs[snum], parm_name, f);
2601 TALLOC_FREE(lp_ctx);
2606 /***************************************************************************
2607 Display the contents of a single copy structure.
2608 ***************************************************************************/
2609 static void dump_copy_map(bool *pcopymap)
2615 printf("\n\tNon-Copied parameters:\n");
2617 for (i = 0; parm_table[i].label; i++)
2618 if (parm_table[i].p_class == P_LOCAL &&
2619 parm_table[i].ptr && !pcopymap[i] &&
2620 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
2622 printf("\t\t%s\n", parm_table[i].label);
2627 /***************************************************************************
2628 Return TRUE if the passed service number is within range.
2629 ***************************************************************************/
2631 bool lp_snum_ok(int iService)
2633 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->available);
2636 /***************************************************************************
2637 Auto-load some home services.
2638 ***************************************************************************/
2640 static void lp_add_auto_services(char *str)
2650 s = talloc_strdup(talloc_tos(), str);
2652 smb_panic("talloc_strdup failed");
2656 homes = lp_servicenumber(HOMES_NAME);
2658 for (p = strtok_r(s, LIST_SEP, &saveptr); p;
2659 p = strtok_r(NULL, LIST_SEP, &saveptr)) {
2662 if (lp_servicenumber(p) >= 0)
2665 home = get_user_home_dir(talloc_tos(), p);
2667 if (home && home[0] && homes >= 0)
2668 lp_add_home(p, homes, p, home);
2675 /***************************************************************************
2676 Auto-load one printer.
2677 ***************************************************************************/
2679 void lp_add_one_printer(const char *name, const char *comment,
2680 const char *location, void *pdata)
2682 int printers = lp_servicenumber(PRINTERS_NAME);
2685 if (lp_servicenumber(name) < 0) {
2686 lp_add_printer(name, printers);
2687 if ((i = lp_servicenumber(name)) >= 0) {
2688 string_set(ServicePtrs[i], &ServicePtrs[i]->comment, comment);
2689 ServicePtrs[i]->autoloaded = true;
2694 /***************************************************************************
2695 Have we loaded a services file yet?
2696 ***************************************************************************/
2698 bool lp_loaded(void)
2703 /***************************************************************************
2704 Unload unused services.
2705 ***************************************************************************/
2707 void lp_killunused(struct smbd_server_connection *sconn,
2708 bool (*snumused) (struct smbd_server_connection *, int))
2711 for (i = 0; i < iNumServices; i++) {
2715 /* don't kill autoloaded or usershare services */
2716 if ( ServicePtrs[i]->autoloaded ||
2717 ServicePtrs[i]->usershare == USERSHARE_VALID) {
2721 if (!snumused || !snumused(sconn, i)) {
2722 free_service_byindex(i);
2728 * Kill all except autoloaded and usershare services - convenience wrapper
2730 void lp_kill_all_services(void)
2732 lp_killunused(NULL, NULL);
2735 /***************************************************************************
2737 ***************************************************************************/
2739 void lp_killservice(int iServiceIn)
2741 if (VALID(iServiceIn)) {
2742 free_service_byindex(iServiceIn);
2746 /***************************************************************************
2747 Save the curent values of all global and sDefault parameters into the
2748 defaults union. This allows testparm to show only the
2749 changed (ie. non-default) parameters.
2750 ***************************************************************************/
2752 static void lp_save_defaults(void)
2755 struct parmlist_entry * parm;
2756 for (i = 0; parm_table[i].label; i++) {
2757 if (!(flags_list[i] & FLAG_CMDLINE)) {
2758 flags_list[i] |= FLAG_DEFAULT;
2761 if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
2762 && parm_table[i].p_class == parm_table[i - 1].p_class)
2764 switch (parm_table[i].type) {
2767 parm_table[i].def.lvalue = str_list_copy(
2768 NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
2772 parm_table[i].def.svalue = talloc_strdup(Globals.ctx, *(char **)lp_parm_ptr(NULL, &parm_table[i]));
2773 if (parm_table[i].def.svalue == NULL) {
2774 smb_panic("talloc_strdup failed");
2779 parm_table[i].def.bvalue =
2780 *(bool *)lp_parm_ptr(NULL, &parm_table[i]);
2783 parm_table[i].def.cvalue =
2784 *(char *)lp_parm_ptr(NULL, &parm_table[i]);
2790 parm_table[i].def.ivalue =
2791 *(int *)lp_parm_ptr(NULL, &parm_table[i]);
2796 for (parm=Globals.param_opt; parm; parm=parm->next) {
2797 if (!(parm->priority & FLAG_CMDLINE)) {
2798 parm->priority |= FLAG_DEFAULT;
2802 for (parm=sDefault.param_opt; parm; parm=parm->next) {
2803 if (!(parm->priority & FLAG_CMDLINE)) {
2804 parm->priority |= FLAG_DEFAULT;
2808 defaults_saved = true;
2811 /***********************************************************
2812 If we should send plaintext/LANMAN passwords in the clinet
2813 ************************************************************/
2815 static void set_allowed_client_auth(void)
2817 if (Globals.client_ntlmv2_auth) {
2818 Globals.client_lanman_auth = false;
2820 if (!Globals.client_lanman_auth) {
2821 Globals.client_plaintext_auth = false;
2825 /***************************************************************************
2827 The following code allows smbd to read a user defined share file.
2828 Yes, this is my intent. Yes, I'm comfortable with that...
2830 THE FOLLOWING IS SECURITY CRITICAL CODE.
2832 It washes your clothes, it cleans your house, it guards you while you sleep...
2833 Do not f%^k with it....
2834 ***************************************************************************/
2836 #define MAX_USERSHARE_FILE_SIZE (10*1024)
2838 /***************************************************************************
2839 Check allowed stat state of a usershare file.
2840 Ensure we print out who is dicking with us so the admin can
2841 get their sorry ass fired.
2842 ***************************************************************************/
2844 static bool check_usershare_stat(const char *fname,
2845 const SMB_STRUCT_STAT *psbuf)
2847 if (!S_ISREG(psbuf->st_ex_mode)) {
2848 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
2849 "not a regular file\n",
2850 fname, (unsigned int)psbuf->st_ex_uid ));
2854 /* Ensure this doesn't have the other write bit set. */
2855 if (psbuf->st_ex_mode & S_IWOTH) {
2856 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
2857 "public write. Refusing to allow as a usershare file.\n",
2858 fname, (unsigned int)psbuf->st_ex_uid ));
2862 /* Should be 10k or less. */
2863 if (psbuf->st_ex_size > MAX_USERSHARE_FILE_SIZE) {
2864 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
2865 "too large (%u) to be a user share file.\n",
2866 fname, (unsigned int)psbuf->st_ex_uid,
2867 (unsigned int)psbuf->st_ex_size ));
2874 /***************************************************************************
2875 Parse the contents of a usershare file.
2876 ***************************************************************************/
2878 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
2879 SMB_STRUCT_STAT *psbuf,
2880 const char *servicename,
2884 char **pp_sharepath,
2886 char **pp_cp_servicename,
2887 struct security_descriptor **ppsd,
2890 const char **prefixallowlist = lp_usershare_prefix_allow_list();
2891 const char **prefixdenylist = lp_usershare_prefix_deny_list();
2894 SMB_STRUCT_STAT sbuf;
2895 char *sharepath = NULL;
2896 char *comment = NULL;
2898 *pp_sharepath = NULL;
2901 *pallow_guest = false;
2904 return USERSHARE_MALFORMED_FILE;
2907 if (strcmp(lines[0], "#VERSION 1") == 0) {
2909 } else if (strcmp(lines[0], "#VERSION 2") == 0) {
2912 return USERSHARE_MALFORMED_FILE;
2915 return USERSHARE_BAD_VERSION;
2918 if (strncmp(lines[1], "path=", 5) != 0) {
2919 return USERSHARE_MALFORMED_PATH;
2922 sharepath = talloc_strdup(ctx, &lines[1][5]);
2924 return USERSHARE_POSIX_ERR;
2926 trim_string(sharepath, " ", " ");
2928 if (strncmp(lines[2], "comment=", 8) != 0) {
2929 return USERSHARE_MALFORMED_COMMENT_DEF;
2932 comment = talloc_strdup(ctx, &lines[2][8]);
2934 return USERSHARE_POSIX_ERR;
2936 trim_string(comment, " ", " ");
2937 trim_char(comment, '"', '"');
2939 if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
2940 return USERSHARE_MALFORMED_ACL_DEF;
2943 if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
2944 return USERSHARE_ACL_ERR;
2948 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
2949 return USERSHARE_MALFORMED_ACL_DEF;
2951 if (lines[4][9] == 'y') {
2952 *pallow_guest = true;
2955 /* Backwards compatible extension to file version #2. */
2957 if (strncmp(lines[5], "sharename=", 10) != 0) {
2958 return USERSHARE_MALFORMED_SHARENAME_DEF;
2960 if (!strequal(&lines[5][10], servicename)) {
2961 return USERSHARE_BAD_SHARENAME;
2963 *pp_cp_servicename = talloc_strdup(ctx, &lines[5][10]);
2964 if (!*pp_cp_servicename) {
2965 return USERSHARE_POSIX_ERR;
2970 if (*pp_cp_servicename == NULL) {
2971 *pp_cp_servicename = talloc_strdup(ctx, servicename);
2972 if (!*pp_cp_servicename) {
2973 return USERSHARE_POSIX_ERR;
2977 if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->path) == 0)) {
2978 /* Path didn't change, no checks needed. */
2979 *pp_sharepath = sharepath;
2980 *pp_comment = comment;
2981 return USERSHARE_OK;
2984 /* The path *must* be absolute. */
2985 if (sharepath[0] != '/') {
2986 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
2987 servicename, sharepath));
2988 return USERSHARE_PATH_NOT_ABSOLUTE;
2991 /* If there is a usershare prefix deny list ensure one of these paths
2992 doesn't match the start of the user given path. */
2993 if (prefixdenylist) {
2995 for ( i=0; prefixdenylist[i]; i++ ) {
2996 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
2997 servicename, i, prefixdenylist[i], sharepath ));
2998 if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
2999 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
3000 "usershare prefix deny list entries.\n",
3001 servicename, sharepath));
3002 return USERSHARE_PATH_IS_DENIED;
3007 /* If there is a usershare prefix allow list ensure one of these paths
3008 does match the start of the user given path. */
3010 if (prefixallowlist) {
3012 for ( i=0; prefixallowlist[i]; i++ ) {
3013 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
3014 servicename, i, prefixallowlist[i], sharepath ));
3015 if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
3019 if (prefixallowlist[i] == NULL) {
3020 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
3021 "usershare prefix allow list entries.\n",
3022 servicename, sharepath));
3023 return USERSHARE_PATH_NOT_ALLOWED;
3027 /* Ensure this is pointing to a directory. */
3028 dp = opendir(sharepath);
3031 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3032 servicename, sharepath));
3033 return USERSHARE_PATH_NOT_DIRECTORY;
3036 /* Ensure the owner of the usershare file has permission to share
3039 if (sys_stat(sharepath, &sbuf, false) == -1) {
3040 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
3041 servicename, sharepath, strerror(errno) ));
3043 return USERSHARE_POSIX_ERR;
3048 if (!S_ISDIR(sbuf.st_ex_mode)) {
3049 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
3050 servicename, sharepath ));
3051 return USERSHARE_PATH_NOT_DIRECTORY;
3054 /* Check if sharing is restricted to owner-only. */
3055 /* psbuf is the stat of the usershare definition file,
3056 sbuf is the stat of the target directory to be shared. */
3058 if (lp_usershare_owner_only()) {
3059 /* root can share anything. */
3060 if ((psbuf->st_ex_uid != 0) && (sbuf.st_ex_uid != psbuf->st_ex_uid)) {
3061 return USERSHARE_PATH_NOT_ALLOWED;
3065 *pp_sharepath = sharepath;
3066 *pp_comment = comment;
3067 return USERSHARE_OK;
3070 /***************************************************************************
3071 Deal with a usershare file.
3074 -1 - Bad name, invalid contents.
3075 - service name already existed and not a usershare, problem
3076 with permissions to share directory etc.
3077 ***************************************************************************/
3079 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
3081 SMB_STRUCT_STAT sbuf;
3082 SMB_STRUCT_STAT lsbuf;
3084 char *sharepath = NULL;
3085 char *comment = NULL;
3086 char *cp_service_name = NULL;
3087 char **lines = NULL;
3091 TALLOC_CTX *ctx = talloc_stackframe();
3092 struct security_descriptor *psd = NULL;
3093 bool guest_ok = false;
3094 char *canon_name = NULL;
3095 bool added_service = false;
3098 /* Ensure share name doesn't contain invalid characters. */
3099 if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
3100 DEBUG(0,("process_usershare_file: share name %s contains "
3101 "invalid characters (any of %s)\n",
3102 file_name, INVALID_SHARENAME_CHARS ));
3106 canon_name = canonicalize_servicename(ctx, file_name);
3111 fname = talloc_asprintf(ctx, "%s/%s", dir_name, file_name);
3116 /* Minimize the race condition by doing an lstat before we
3117 open and fstat. Ensure this isn't a symlink link. */
3119 if (sys_lstat(fname, &lsbuf, false) != 0) {
3120 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
3121 fname, strerror(errno) ));
3125 /* This must be a regular file, not a symlink, directory or
3126 other strange filetype. */
3127 if (!check_usershare_stat(fname, &lsbuf)) {
3135 status = dbwrap_fetch_bystring(ServiceHash, canon_name,
3140 if (NT_STATUS_IS_OK(status) &&
3141 (data.dptr != NULL) &&
3142 (data.dsize == sizeof(iService))) {
3143 memcpy(&iService, data.dptr, sizeof(iService));
3147 if (iService != -1 &&
3148 timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
3149 &lsbuf.st_ex_mtime) == 0) {
3150 /* Nothing changed - Mark valid and return. */
3151 DEBUG(10,("process_usershare_file: service %s not changed.\n",
3153 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3158 /* Try and open the file read only - no symlinks allowed. */
3160 fd = open(fname, O_RDONLY|O_NOFOLLOW, 0);
3162 fd = open(fname, O_RDONLY, 0);
3166 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
3167 fname, strerror(errno) ));
3171 /* Now fstat to be *SURE* it's a regular file. */
3172 if (sys_fstat(fd, &sbuf, false) != 0) {
3174 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
3175 fname, strerror(errno) ));
3179 /* Is it the same dev/inode as was lstated ? */
3180 if (!check_same_stat(&lsbuf, &sbuf)) {
3182 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
3183 "Symlink spoofing going on ?\n", fname ));
3187 /* This must be a regular file, not a symlink, directory or
3188 other strange filetype. */
3189 if (!check_usershare_stat(fname, &sbuf)) {
3194 lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE, NULL);
3197 if (lines == NULL) {
3198 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
3199 fname, (unsigned int)sbuf.st_ex_uid ));
3203 if (parse_usershare_file(ctx, &sbuf, file_name,
3204 iService, lines, numlines, &sharepath,
3205 &comment, &cp_service_name,
3206 &psd, &guest_ok) != USERSHARE_OK) {
3210 /* Everything ok - add the service possibly using a template. */
3212 const struct loadparm_service *sp = &sDefault;
3213 if (snum_template != -1) {
3214 sp = ServicePtrs[snum_template];
3217 if ((iService = add_a_service(sp, cp_service_name)) < 0) {
3218 DEBUG(0, ("process_usershare_file: Failed to add "
3219 "new service %s\n", cp_service_name));
3223 added_service = true;
3225 /* Read only is controlled by usershare ACL below. */
3226 ServicePtrs[iService]->read_only = false;
3229 /* Write the ACL of the new/modified share. */
3230 if (!set_share_security(canon_name, psd)) {
3231 DEBUG(0, ("process_usershare_file: Failed to set share "
3232 "security for user share %s\n",
3237 /* If from a template it may be marked invalid. */
3238 ServicePtrs[iService]->valid = true;
3240 /* Set the service as a valid usershare. */
3241 ServicePtrs[iService]->usershare = USERSHARE_VALID;
3243 /* Set guest access. */
3244 if (lp_usershare_allow_guests()) {
3245 ServicePtrs[iService]->guest_ok = guest_ok;
3248 /* And note when it was loaded. */
3249 ServicePtrs[iService]->usershare_last_mod = sbuf.st_ex_mtime;
3250 string_set(ServicePtrs[iService], &ServicePtrs[iService]->path, sharepath);
3251 string_set(ServicePtrs[iService], &ServicePtrs[iService]->comment, comment);
3257 if (ret == -1 && iService != -1 && added_service) {
3258 lp_remove_service(iService);
3266 /***************************************************************************
3267 Checks if a usershare entry has been modified since last load.
3268 ***************************************************************************/
3270 static bool usershare_exists(int iService, struct timespec *last_mod)
3272 SMB_STRUCT_STAT lsbuf;
3273 const char *usersharepath = Globals.usershare_path;
3276 fname = talloc_asprintf(talloc_tos(),
3279 ServicePtrs[iService]->szService);
3280 if (fname == NULL) {
3284 if (sys_lstat(fname, &lsbuf, false) != 0) {
3289 if (!S_ISREG(lsbuf.st_ex_mode)) {
3295 *last_mod = lsbuf.st_ex_mtime;
3299 /***************************************************************************
3300 Load a usershare service by name. Returns a valid servicenumber or -1.
3301 ***************************************************************************/
3303 int load_usershare_service(const char *servicename)
3305 SMB_STRUCT_STAT sbuf;
3306 const char *usersharepath = Globals.usershare_path;
3307 int max_user_shares = Globals.usershare_max_shares;
3308 int snum_template = -1;
3310 if (*usersharepath == 0 || max_user_shares == 0) {
3314 if (sys_stat(usersharepath, &sbuf, false) != 0) {
3315 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
3316 usersharepath, strerror(errno) ));
3320 if (!S_ISDIR(sbuf.st_ex_mode)) {
3321 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
3327 * This directory must be owned by root, and have the 't' bit set.
3328 * It also must not be writable by "other".
3332 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3334 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3336 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
3337 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3342 /* Ensure the template share exists if it's set. */
3343 if (Globals.usershare_template_share[0]) {
3344 /* We can't use lp_servicenumber here as we are recommending that
3345 template shares have -valid=false set. */
3346 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3347 if (ServicePtrs[snum_template]->szService &&
3348 strequal(ServicePtrs[snum_template]->szService,
3349 Globals.usershare_template_share)) {
3354 if (snum_template == -1) {
3355 DEBUG(0,("load_usershare_service: usershare template share %s "
3356 "does not exist.\n",
3357 Globals.usershare_template_share ));
3362 return process_usershare_file(usersharepath, servicename, snum_template);
3365 /***************************************************************************
3366 Load all user defined shares from the user share directory.
3367 We only do this if we're enumerating the share list.
3368 This is the function that can delete usershares that have
3370 ***************************************************************************/
3372 int load_usershare_shares(struct smbd_server_connection *sconn,
3373 bool (*snumused) (struct smbd_server_connection *, int))
3376 SMB_STRUCT_STAT sbuf;
3378 int num_usershares = 0;
3379 int max_user_shares = Globals.usershare_max_shares;
3380 unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
3381 unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
3382 unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
3384 int snum_template = -1;
3385 const char *usersharepath = Globals.usershare_path;
3386 int ret = lp_numservices();
3387 TALLOC_CTX *tmp_ctx;
3389 if (max_user_shares == 0 || *usersharepath == '\0') {
3390 return lp_numservices();
3393 if (sys_stat(usersharepath, &sbuf, false) != 0) {
3394 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
3395 usersharepath, strerror(errno) ));
3400 * This directory must be owned by root, and have the 't' bit set.
3401 * It also must not be writable by "other".
3405 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
3407 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
3409 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
3410 "or does not have the sticky bit 't' set or is writable by anyone.\n",
3415 /* Ensure the template share exists if it's set. */
3416 if (Globals.usershare_template_share[0]) {
3417 /* We can't use lp_servicenumber here as we are recommending that
3418 template shares have -valid=false set. */
3419 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
3420 if (ServicePtrs[snum_template]->szService &&
3421 strequal(ServicePtrs[snum_template]->szService,
3422 Globals.usershare_template_share)) {
3427 if (snum_template == -1) {
3428 DEBUG(0,("load_usershare_shares: usershare template share %s "
3429 "does not exist.\n",
3430 Globals.usershare_template_share ));
3435 /* Mark all existing usershares as pending delete. */
3436 for (iService = iNumServices - 1; iService >= 0; iService--) {
3437 if (VALID(iService) && ServicePtrs[iService]->usershare) {
3438 ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
3442 dp = opendir(usersharepath);
3444 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
3445 usersharepath, strerror(errno) ));
3449 for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
3451 num_dir_entries++ ) {
3453 const char *n = de->d_name;
3455 /* Ignore . and .. */
3457 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
3463 /* Temporary file used when creating a share. */
3464 num_tmp_dir_entries++;
3467 /* Allow 20% tmp entries. */
3468 if (num_tmp_dir_entries > allowed_tmp_entries) {
3469 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
3470 "in directory %s\n",
3471 num_tmp_dir_entries, usersharepath));
3475 r = process_usershare_file(usersharepath, n, snum_template);
3477 /* Update the services count. */
3479 if (num_usershares >= max_user_shares) {
3480 DEBUG(0,("load_usershare_shares: max user shares reached "
3481 "on file %s in directory %s\n",
3482 n, usersharepath ));
3485 } else if (r == -1) {
3486 num_bad_dir_entries++;
3489 /* Allow 20% bad entries. */
3490 if (num_bad_dir_entries > allowed_bad_entries) {
3491 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
3492 "in directory %s\n",
3493 num_bad_dir_entries, usersharepath));
3497 /* Allow 20% bad entries. */
3498 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
3499 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
3500 "in directory %s\n",
3501 num_dir_entries, usersharepath));
3508 /* Sweep through and delete any non-refreshed usershares that are
3509 not currently in use. */
3510 tmp_ctx = talloc_stackframe();
3511 for (iService = iNumServices - 1; iService >= 0; iService--) {
3512 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
3515 if (snumused && snumused(sconn, iService)) {
3519 servname = lp_servicename(tmp_ctx, iService);
3521 /* Remove from the share ACL db. */
3522 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
3524 delete_share_security(servname);
3525 free_service_byindex(iService);
3528 talloc_free(tmp_ctx);
3530 return lp_numservices();
3533 /********************************************************
3534 Destroy global resources allocated in this file
3535 ********************************************************/
3537 void gfree_loadparm(void)
3543 /* Free resources allocated to services */
3545 for ( i = 0; i < iNumServices; i++ ) {
3547 free_service_byindex(i);
3551 TALLOC_FREE( ServicePtrs );
3554 /* Now release all resources allocated to global
3555 parameters and the default service */
3557 free_global_parameters();
3561 /***************************************************************************
3562 Allow client apps to specify that they are a client
3563 ***************************************************************************/
3564 static void lp_set_in_client(bool b)
3570 /***************************************************************************
3571 Determine if we're running in a client app
3572 ***************************************************************************/
3573 static bool lp_is_in_client(void)
3578 static void lp_enforce_ad_dc_settings(void)
3580 lp_do_parameter(GLOBAL_SECTION_SNUM, "passdb backend", "samba_dsdb");
3581 lp_do_parameter(GLOBAL_SECTION_SNUM,
3582 "winbindd:use external pipes", "true");
3583 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:default", "external");
3584 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:svcctl", "embedded");
3585 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:srvsvc", "embedded");
3586 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:eventlog", "embedded");
3587 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:ntsvcs", "embedded");
3588 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:winreg", "embedded");
3589 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:spoolss", "embedded");
3590 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_daemon:spoolssd", "embedded");
3591 lp_do_parameter(GLOBAL_SECTION_SNUM, "rpc_server:tcpip", "no");
3594 /***************************************************************************
3595 Load the services array from the services file. Return true on success,
3597 ***************************************************************************/
3599 static bool lp_load_ex(const char *pszFname,
3603 bool reinit_globals,
3604 bool allow_include_registry,
3605 bool load_all_shares)
3609 TALLOC_CTX *frame = talloc_stackframe();
3610 struct loadparm_context *lp_ctx;
3614 DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
3616 bInGlobalSection = true;
3617 bGlobalOnly = global_only;
3618 bAllowIncludeRegistry = allow_include_registry;
3620 lp_ctx = setup_lp_context(talloc_tos());
3622 init_globals(lp_ctx, reinit_globals);
3626 if (save_defaults) {
3631 if (!reinit_globals) {
3632 free_param_opts(&Globals.param_opt);
3633 apply_lp_set_cmdline();
3636 lp_do_parameter(-1, "idmap config * : backend", Globals.szIdmapBackend);
3638 /* We get sections first, so have to start 'behind' to make up */
3641 if (lp_config_backend_is_file()) {
3642 n2 = talloc_sub_basic(talloc_tos(), get_current_username(),
3643 current_user_info.domain,
3646 smb_panic("lp_load_ex: out of memory");
3649 add_to_file_list(NULL, &file_lists, pszFname, n2);
3651 bRetval = pm_process(n2, lp_do_section, do_parameter, lp_ctx);
3654 /* finish up the last section */
3655 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
3657 if (iServiceIndex >= 0) {
3658 bRetval = lpcfg_service_ok(ServicePtrs[iServiceIndex]);
3662 if (lp_config_backend_is_registry()) {
3664 /* config backend changed to registry in config file */
3666 * We need to use this extra global variable here to
3667 * survive restart: init_globals uses this as a default
3668 * for config_backend. Otherwise, init_globals would
3669 * send us into an endless loop here.
3672 config_backend = CONFIG_BACKEND_REGISTRY;
3674 DEBUG(1, ("lp_load_ex: changing to config backend "
3676 init_globals(lp_ctx, true);
3678 TALLOC_FREE(lp_ctx);
3680 lp_kill_all_services();
3681 ok = lp_load_ex(pszFname, global_only, save_defaults,
3682 add_ipc, reinit_globals,
3683 allow_include_registry,
3688 } else if (lp_config_backend_is_registry()) {
3689 bRetval = process_registry_globals();
3691 DEBUG(0, ("Illegal config backend given: %d\n",
3692 lp_config_backend()));
3696 if (bRetval && lp_registry_shares()) {
3697 if (load_all_shares) {
3698 bRetval = process_registry_shares();
3700 bRetval = reload_registry_shares();
3705 char *serv = lp_auto_services(talloc_tos());
3706 lp_add_auto_services(serv);
3711 /* When 'restrict anonymous = 2' guest connections to ipc$
3713 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
3714 if ( lp_enable_asu_support() ) {
3715 lp_add_ipc("ADMIN$", false);
3719 set_allowed_client_auth();
3721 if (lp_security() == SEC_ADS && strchr(lp_password_server(), ':')) {
3722 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
3723 lp_password_server()));
3728 /* Now we check we_are_a_wins_server and set szWINSserver to 127.0.0.1 */
3729 /* if we_are_a_wins_server is true and we are in the client */
3730 if (lp_is_in_client() && Globals.we_are_a_wins_server) {
3731 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
3736 fault_configure(smb_panic_s3);
3739 * We run this check once the whole smb.conf is parsed, to
3740 * force some settings for the standard way a AD DC is
3741 * operated. We may change these as our code evolves, which
3742 * is why we force these settings.
3744 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
3745 lp_enforce_ad_dc_settings();
3748 bAllowIncludeRegistry = true;
3754 static bool lp_load(const char *pszFname,
3758 bool reinit_globals)
3760 return lp_load_ex(pszFname,
3765 true, /* allow_include_registry */
3766 false); /* load_all_shares*/
3769 bool lp_load_initial_only(const char *pszFname)
3771 return lp_load_ex(pszFname,
3772 true, /* global only */
3773 true, /* save_defaults */
3774 false, /* add_ipc */
3775 true, /* reinit_globals */
3776 false, /* allow_include_registry */
3777 false); /* load_all_shares*/
3781 * most common lp_load wrapper, loading only the globals
3783 bool lp_load_global(const char *file_name)
3785 return lp_load(file_name,
3786 true, /* global_only */
3787 false, /* save_defaults */
3788 false, /* add_ipc */
3789 true); /* reinit_globals */
3793 * The typical lp_load wrapper with shares, loads global and
3794 * shares, including IPC, but does not force immediate
3795 * loading of all shares from registry.
3797 bool lp_load_with_shares(const char *file_name)
3799 return lp_load(file_name,
3800 false, /* global_only */
3801 false, /* save_defaults */
3803 true); /* reinit_globals */
3807 * lp_load wrapper, especially for clients
3809 bool lp_load_client(const char *file_name)
3811 lp_set_in_client(true);
3813 return lp_load_global(file_name);
3817 * lp_load wrapper, loading only globals, but intended
3818 * for subsequent calls, not reinitializing the globals
3821 bool lp_load_global_no_reinit(const char *file_name)
3823 return lp_load(file_name,
3824 true, /* global_only */
3825 false, /* save_defaults */
3826 false, /* add_ipc */
3827 false); /* reinit_globals */
3831 * lp_load wrapper, loading globals and shares,
3832 * intended for subsequent calls, i.e. not reinitializing
3833 * the globals to default values.
3835 bool lp_load_no_reinit(const char *file_name)
3837 return lp_load(file_name,
3838 false, /* global_only */
3839 false, /* save_defaults */
3840 false, /* add_ipc */
3841 false); /* reinit_globals */
3846 * lp_load wrapper, especially for clients, no reinitialization
3848 bool lp_load_client_no_reinit(const char *file_name)
3850 lp_set_in_client(true);
3852 return lp_load_global_no_reinit(file_name);
3855 bool lp_load_with_registry_shares(const char *pszFname)
3857 return lp_load_ex(pszFname,
3858 false, /* global_only */
3859 true, /* save_defaults */
3860 false, /* add_ipc */
3861 false, /* reinit_globals */
3862 true, /* allow_include_registry */
3863 true); /* load_all_shares*/
3866 /***************************************************************************
3867 Return the max number of services.
3868 ***************************************************************************/
3870 int lp_numservices(void)
3872 return (iNumServices);
3875 /***************************************************************************
3876 Display the contents of the services array in human-readable form.
3877 ***************************************************************************/
3879 void lp_dump(FILE *f, bool show_defaults, int maxtoprint)
3882 struct loadparm_context *lp_ctx;
3885 defaults_saved = false;
3887 lp_ctx = setup_lp_context(talloc_tos());
3888 if (lp_ctx == NULL) {
3892 lpcfg_dump_globals(lp_ctx, f, !defaults_saved);
3894 lpcfg_dump_a_service(&sDefault, &sDefault, f, flags_list, show_defaults);
3896 for (iService = 0; iService < maxtoprint; iService++) {
3898 lp_dump_one(f, show_defaults, iService);
3902 /***************************************************************************
3903 Display the contents of one service in human-readable form.
3904 ***************************************************************************/
3906 void lp_dump_one(FILE * f, bool show_defaults, int snum)
3909 if (ServicePtrs[snum]->szService[0] == '\0')
3911 lpcfg_dump_a_service(ServicePtrs[snum], &sDefault, f,
3912 flags_list, show_defaults);
3916 /***************************************************************************
3917 Return the number of the service with the given name, or -1 if it doesn't
3918 exist. Note that this is a DIFFERENT ANIMAL from the internal function
3919 getservicebyname()! This works ONLY if all services have been loaded, and
3920 does not copy the found service.
3921 ***************************************************************************/
3923 int lp_servicenumber(const char *pszServiceName)
3926 fstring serviceName;
3928 if (!pszServiceName) {
3929 return GLOBAL_SECTION_SNUM;
3932 for (iService = iNumServices - 1; iService >= 0; iService--) {
3933 if (VALID(iService) && ServicePtrs[iService]->szService) {
3935 * The substitution here is used to support %U in
3938 fstrcpy(serviceName, ServicePtrs[iService]->szService);
3939 standard_sub_basic(get_current_username(),
3940 current_user_info.domain,
3941 serviceName,sizeof(serviceName));
3942 if (strequal(serviceName, pszServiceName)) {
3948 if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
3949 struct timespec last_mod;
3951 if (!usershare_exists(iService, &last_mod)) {
3952 /* Remove the share security tdb entry for it. */
3953 delete_share_security(lp_servicename(talloc_tos(), iService));
3954 /* Remove it from the array. */
3955 free_service_byindex(iService);
3956 /* Doesn't exist anymore. */
3957 return GLOBAL_SECTION_SNUM;
3960 /* Has it been modified ? If so delete and reload. */
3961 if (timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
3963 /* Remove it from the array. */
3964 free_service_byindex(iService);
3965 /* and now reload it. */
3966 iService = load_usershare_service(pszServiceName);
3971 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
3972 return GLOBAL_SECTION_SNUM;
3978 /*******************************************************************
3979 A useful volume label function.
3980 ********************************************************************/
3982 const char *volume_label(TALLOC_CTX *ctx, int snum)
3985 const char *label = lp_volume(ctx, snum);
3987 label = lp_servicename(ctx, snum);
3990 /* This returns a 33 byte guarenteed null terminated string. */
3991 ret = talloc_strndup(ctx, label, 32);
3998 /*******************************************************************
3999 Get the default server type we will announce as via nmbd.
4000 ********************************************************************/
4002 int lp_default_server_announce(void)
4004 int default_server_announce = 0;
4005 default_server_announce |= SV_TYPE_WORKSTATION;
4006 default_server_announce |= SV_TYPE_SERVER;
4007 default_server_announce |= SV_TYPE_SERVER_UNIX;
4009 /* note that the flag should be set only if we have a
4010 printer service but nmbd doesn't actually load the
4011 services so we can't tell --jerry */
4013 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
4015 default_server_announce |= SV_TYPE_SERVER_NT;
4016 default_server_announce |= SV_TYPE_NT;
4018 switch (lp_server_role()) {
4019 case ROLE_DOMAIN_MEMBER:
4020 default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
4022 case ROLE_DOMAIN_PDC:
4023 default_server_announce |= SV_TYPE_DOMAIN_CTRL;
4025 case ROLE_DOMAIN_BDC:
4026 default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
4028 case ROLE_STANDALONE:
4032 if (lp_time_server())
4033 default_server_announce |= SV_TYPE_TIME_SOURCE;
4035 if (lp_host_msdfs())
4036 default_server_announce |= SV_TYPE_DFS_SERVER;
4038 return default_server_announce;
4041 /***********************************************************
4042 If we are PDC then prefer us as DMB
4043 ************************************************************/
4045 bool lp_domain_master(void)
4047 if (Globals._domain_master == Auto)
4048 return (lp_server_role() == ROLE_DOMAIN_PDC);
4050 return (bool)Globals._domain_master;
4053 /***********************************************************
4054 If we are PDC then prefer us as DMB
4055 ************************************************************/
4057 static bool lp_domain_master_true_or_auto(void)
4059 if (Globals._domain_master) /* auto or yes */
4065 /***********************************************************
4066 If we are DMB then prefer us as LMB
4067 ************************************************************/
4069 bool lp_preferred_master(void)
4071 int preferred_master = lp__preferred_master();
4073 if (preferred_master == Auto)
4074 return (lp_local_master() && lp_domain_master());
4076 return (bool)preferred_master;
4079 /*******************************************************************
4081 ********************************************************************/
4083 void lp_remove_service(int snum)
4085 ServicePtrs[snum]->valid = false;
4088 const char *lp_printername(TALLOC_CTX *ctx, int snum)
4090 const char *ret = lp__printername(ctx, snum);
4091 if (ret == NULL || *ret == '\0') {
4092 ret = lp_const_servicename(snum);
4099 /***********************************************************
4100 Allow daemons such as winbindd to fix their logfile name.
4101 ************************************************************/
4103 void lp_set_logfile(const char *name)
4105 string_set(Globals.ctx, &Globals.logfile, name);
4106 debug_set_logfile(name);
4109 /*******************************************************************
4110 Return the max print jobs per queue.
4111 ********************************************************************/
4113 int lp_maxprintjobs(int snum)
4115 int maxjobs = lp_max_print_jobs(snum);
4117 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
4118 maxjobs = PRINT_MAX_JOBID - 1;
4123 const char *lp_printcapname(void)
4125 const char *printcap_name = lp_printcap_name();
4127 if ((printcap_name != NULL) &&
4128 (printcap_name[0] != '\0'))
4129 return printcap_name;
4131 if (sDefault.printing == PRINT_CUPS) {
4135 if (sDefault.printing == PRINT_BSD)
4136 return "/etc/printcap";
4138 return PRINTCAP_NAME;
4141 static uint32_t spoolss_state;
4143 bool lp_disable_spoolss( void )
4145 if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
4146 spoolss_state = lp__disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4148 return spoolss_state == SVCCTL_STOPPED ? true : false;
4151 void lp_set_spoolss_state( uint32_t state )
4153 SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
4155 spoolss_state = state;
4158 uint32_t lp_get_spoolss_state( void )
4160 return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
4163 /*******************************************************************
4164 Ensure we don't use sendfile if server smb signing is active.
4165 ********************************************************************/
4167 bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state)
4169 bool sign_active = false;
4171 /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
4172 if (get_Protocol() < PROTOCOL_NT1) {
4175 if (signing_state) {
4176 sign_active = smb_signing_is_active(signing_state);
4178 return (lp__use_sendfile(snum) &&
4179 (get_remote_arch() != RA_WIN95) &&
4183 /*******************************************************************
4184 Turn off sendfile if we find the underlying OS doesn't support it.
4185 ********************************************************************/
4187 void set_use_sendfile(int snum, bool val)
4189 if (LP_SNUM_OK(snum))
4190 ServicePtrs[snum]->_use_sendfile = val;
4192 sDefault._use_sendfile = val;
4195 /*******************************************************************
4196 Turn off storing DOS attributes if this share doesn't support it.
4197 ********************************************************************/
4199 void set_store_dos_attributes(int snum, bool val)
4201 if (!LP_SNUM_OK(snum))
4203 ServicePtrs[(snum)]->store_dos_attributes = val;
4206 void lp_set_mangling_method(const char *new_method)
4208 string_set(Globals.ctx, &Globals.mangling_method, new_method);
4211 /*******************************************************************
4212 Global state for POSIX pathname processing.
4213 ********************************************************************/
4215 static bool posix_pathnames;
4217 bool lp_posix_pathnames(void)
4219 return posix_pathnames;
4222 /*******************************************************************
4223 Change everything needed to ensure POSIX pathname processing (currently
4225 ********************************************************************/
4227 void lp_set_posix_pathnames(void)
4229 posix_pathnames = true;
4232 /*******************************************************************
4233 Global state for POSIX lock processing - CIFS unix extensions.
4234 ********************************************************************/
4236 bool posix_default_lock_was_set;
4237 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
4239 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
4241 if (posix_default_lock_was_set) {
4242 return posix_cifsx_locktype;
4244 return fsp->posix_open ? POSIX_LOCK : WINDOWS_LOCK;
4248 /*******************************************************************
4249 ********************************************************************/
4251 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
4253 posix_default_lock_was_set = true;
4254 posix_cifsx_locktype = val;
4257 int lp_min_receive_file_size(void)
4259 int min_receivefile_size = lp_min_receivefile_size();
4261 if (min_receivefile_size < 0) {
4264 return min_receivefile_size;
4267 /*******************************************************************
4268 Safe wide links checks.
4269 This helper function always verify the validity of wide links,
4270 even after a configuration file reload.
4271 ********************************************************************/
4273 void widelinks_warning(int snum)
4275 if (lp_allow_insecure_wide_links()) {
4279 if (lp_unix_extensions() && lp_wide_links(snum)) {
4280 DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
4281 "These parameters are incompatible. "
4282 "Wide links will be disabled for this share.\n",
4283 lp_servicename(talloc_tos(), snum) ));
4287 bool lp_widelinks(int snum)
4289 /* wide links is always incompatible with unix extensions */
4290 if (lp_unix_extensions()) {
4292 * Unless we have "allow insecure widelinks"
4295 if (!lp_allow_insecure_wide_links()) {
4300 return lp_wide_links(snum);
4303 int lp_server_role(void)
4305 return lp_find_server_role(lp__server_role(),
4307 lp__domain_logons(),
4308 lp_domain_master_true_or_auto());
4311 int lp_security(void)
4313 return lp_find_security(lp__server_role(),
4317 int lp_client_max_protocol(void)
4319 int client_max_protocol = lp__client_max_protocol();
4320 if (client_max_protocol == PROTOCOL_DEFAULT) {
4321 return PROTOCOL_NT1;
4323 return client_max_protocol;
4326 int lp_winbindd_max_protocol(void)
4328 int client_max_protocol = lp__client_max_protocol();
4329 if (client_max_protocol == PROTOCOL_DEFAULT) {
4330 return PROTOCOL_LATEST;
4332 return client_max_protocol;
4335 struct loadparm_global * get_globals(void)
4340 unsigned int * get_flags(void)
4342 if (flags_list == NULL) {
4343 flags_list = talloc_zero_array(NULL, unsigned int, num_parameters());