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"
61 #include "lib/smbconf/smbconf.h"
62 #include "lib/smbconf/smbconf_init.h"
65 #include "../librpc/gen_ndr/svcctl.h"
67 #include "../libcli/smb/smb_signing.h"
68 #include "dbwrap/dbwrap.h"
69 #include "dbwrap/dbwrap_rbt.h"
70 #include "../lib/util/bitmap.h"
72 #ifdef HAVE_SYS_SYSCTL_H
73 #include <sys/sysctl.h>
76 #ifdef HAVE_HTTPCONNECTENCRYPT
77 #include <cups/http.h>
80 #ifdef CLUSTER_SUPPORT
81 #include "ctdb_private.h"
86 extern userdom_struct current_user_info
;
88 /* the special value for the include parameter
89 * to be interpreted not as a file name but to
90 * trigger loading of the global smb.conf options
92 #ifndef INCLUDE_REGISTRY_NAME
93 #define INCLUDE_REGISTRY_NAME "registry"
96 static bool in_client
= false; /* Not in the client by default */
97 static struct smbconf_csn conf_last_csn
;
99 static int config_backend
= CONFIG_BACKEND_FILE
;
101 /* some helpful bits */
102 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && (ServicePtrs != NULL) && ServicePtrs[(i)]->valid)
103 #define VALID(i) (ServicePtrs != NULL && ServicePtrs[i]->valid)
105 #define USERSHARE_VALID 1
106 #define USERSHARE_PENDING_DELETE 2
108 static bool defaults_saved
= false;
110 #define LOADPARM_EXTRA_GLOBALS \
111 struct parmlist_entry *param_opt; \
114 int iminreceivefile; \
115 char *szPrintcapname; \
117 int iPreferredMaster; \
118 char *szLdapMachineSuffix; \
119 char *szLdapUserSuffix; \
120 char *szLdapIdmapSuffix; \
121 char *szLdapGroupSuffix; \
124 char *szUsershareTemplateShare; \
127 char *szIdmapBackend; \
128 int winbindMaxDomainConnections; \
129 int ismb2_max_credits; \
131 char *tls_certfile; \
135 int bPreferredMaster;
137 #include "param/param_global.h"
139 static struct loadparm_global Globals
;
141 /* This is a default service used to prime a services structure */
142 static struct loadparm_service sDefault
=
147 .usershare_last_mod
= {0, 0},
151 .szInvalidUsers
= NULL
,
152 .szValidUsers
= NULL
,
153 .szAdminUsers
= NULL
,
158 .szRootPreExec
= NULL
,
159 .szRootPostExec
= NULL
,
160 .szCupsOptions
= NULL
,
161 .szPrintcommand
= NULL
,
162 .szLpqcommand
= NULL
,
163 .szLprmcommand
= NULL
,
164 .szLppausecommand
= NULL
,
165 .szLpresumecommand
= NULL
,
166 .szQueuepausecommand
= NULL
,
167 .szQueueresumecommand
= NULL
,
168 .szPrintername
= NULL
,
169 .szPrintjobUsername
= NULL
,
170 .szDontdescend
= NULL
,
171 .szHostsallow
= NULL
,
173 .szMagicScript
= NULL
,
174 .szMagicOutput
= NULL
,
177 .szVetoOplockFiles
= NULL
,
185 .szVfsObjects
= NULL
,
186 .szMSDfsProxy
= NULL
,
187 .szAioWriteBehind
= NULL
,
190 .iMaxPrintJobs
= 1000,
191 .iMaxReportedPrintJobs
= 0,
192 .iWriteCacheSize
= 0,
193 .iCreate_mask
= 0744,
194 .iCreate_force_mode
= 0,
196 .iDir_force_mode
= 0,
197 .iMaxConnections
= 0,
198 .iDefaultCase
= CASE_LOWER
,
199 .iPrinting
= DEFAULT_PRINTING
,
200 .iOplockContentionLimit
= 2,
203 .iDfreeCacheTime
= 0,
204 .bPreexecClose
= false,
205 .bRootpreexecClose
= false,
206 .iCaseSensitive
= Auto
,
207 .bCasePreserve
= true,
208 .bShortCasePreserve
= true,
209 .bHideDotFiles
= true,
210 .bHideSpecialFiles
= false,
211 .bHideUnReadable
= false,
212 .bHideUnWriteableFiles
= false,
214 .bAccessBasedShareEnum
= false,
217 .bGuest_only
= false,
218 .bAdministrative_share
= false,
221 .bPrintNotifyBackchannel
= true,
222 .bMap_system
= false,
223 .bMap_hidden
= false,
224 .bMap_archive
= true,
225 .bStoreDosAttributes
= false,
226 .bDmapiSupport
= false,
228 .iStrictLocking
= Auto
,
229 .bPosixLocking
= true,
231 .bKernelOplocks
= false,
232 .bLevel2OpLocks
= true,
234 .bMangledNames
= true,
237 .bSyncAlways
= false,
238 .bStrictAllocate
= false,
239 .bStrictSync
= false,
242 .bDeleteReadonly
= false,
243 .bFakeOplocks
= false,
244 .bDeleteVetoFiles
= false,
245 .bDosFilemode
= false,
246 .bDosFiletimes
= true,
247 .bDosFiletimeResolution
= false,
248 .bFakeDirCreateTimes
= false,
249 .bBlockingLocks
= true,
250 .bInheritPerms
= false,
251 .bInheritACLS
= false,
252 .bInheritOwner
= false,
254 .bUseClientDriver
= false,
255 .bDefaultDevmode
= true,
256 .bForcePrintername
= false,
257 .bNTAclSupport
= true,
258 .bForceUnknownAclUser
= false,
259 .bUseSendfile
= false,
260 .bProfileAcls
= false,
261 .bMap_acl_inherit
= false,
264 .bAclCheckPermissions
= true,
265 .bAclMapFullControl
= true,
266 .bAclGroupControl
= false,
267 .bAclAllowExecuteAlways
= false,
268 .bChangeNotify
= true,
269 .bKernelChangeNotify
= true,
270 .iallocation_roundup_size
= SMB_ROUNDUP_ALLOCATION_SIZE
,
273 .iMap_readonly
= MAP_READONLY_YES
,
274 #ifdef BROKEN_DIRECTORY_HANDLING
275 .iDirectoryNameCacheSize
= 0,
277 .iDirectoryNameCacheSize
= 100,
279 .ismb_encrypt
= SMB_SIGNING_DEFAULT
,
280 .bKernelShareModes
= true,
281 .bDurableHandles
= true,
286 /* local variables */
287 static struct loadparm_service
**ServicePtrs
= NULL
;
288 static int iNumServices
= 0;
289 static int iServiceIndex
= 0;
290 static struct db_context
*ServiceHash
;
291 static int *invalid_services
= NULL
;
292 static int num_invalid_services
= 0;
293 static bool bInGlobalSection
= true;
294 static bool bGlobalOnly
= false;
296 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
298 /* prototypes for the special type handlers */
299 static bool handle_include(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
300 static bool handle_copy(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
301 static bool handle_idmap_backend(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
302 static bool handle_idmap_uid(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
303 static bool handle_idmap_gid(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
304 static bool handle_debug_list(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
305 static bool handle_realm(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
306 static bool handle_netbios_aliases(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
307 static bool handle_charset(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
308 static bool handle_dos_charset(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
309 static bool handle_printing(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
310 static bool handle_ldap_debug_level(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
);
312 /* these are parameter handlers which are not needed in the
316 #define handle_logfile NULL
318 static void set_allowed_client_auth(void);
320 static void add_to_file_list(const char *fname
, const char *subfname
);
321 static bool lp_set_cmdline_helper(const char *pszParmName
, const char *pszParmValue
, bool store_values
);
322 static void free_param_opts(struct parmlist_entry
**popts
);
324 #include "lib/param/param_table.c"
326 /* this is used to prevent lots of mallocs of size 1 */
327 static const char null_string
[] = "";
330 Set a string value, allocing the space for the string
333 static bool string_init(char **dest
,const char *src
)
343 *dest
= discard_const_p(char, null_string
);
345 (*dest
) = SMB_STRDUP(src
);
346 if ((*dest
) == NULL
) {
347 DEBUG(0,("Out of memory in string_init\n"));
358 static void string_free(char **s
)
362 if (*s
== null_string
)
368 Set a string value, deallocating any existing space, and allocing the space
372 static bool string_set(char **dest
,const char *src
)
375 return(string_init(dest
,src
));
378 /***************************************************************************
379 Initialise the sDefault parameter structure for the printer values.
380 ***************************************************************************/
382 static void init_printer_values(struct loadparm_service
*pService
)
384 /* choose defaults depending on the type of printing */
385 switch (pService
->iPrinting
) {
390 string_set(&pService
->szLpqcommand
, "lpq -P'%p'");
391 string_set(&pService
->szLprmcommand
, "lprm -P'%p' %j");
392 string_set(&pService
->szPrintcommand
, "lpr -r -P'%p' %s");
397 string_set(&pService
->szLpqcommand
, "lpq -P'%p'");
398 string_set(&pService
->szLprmcommand
, "lprm -P'%p' %j");
399 string_set(&pService
->szPrintcommand
, "lpr -r -P'%p' %s");
400 string_set(&pService
->szQueuepausecommand
, "lpc stop '%p'");
401 string_set(&pService
->szQueueresumecommand
, "lpc start '%p'");
402 string_set(&pService
->szLppausecommand
, "lpc hold '%p' %j");
403 string_set(&pService
->szLpresumecommand
, "lpc release '%p' %j");
408 /* set the lpq command to contain the destination printer
409 name only. This is used by cups_queue_get() */
410 string_set(&pService
->szLpqcommand
, "%p");
411 string_set(&pService
->szLprmcommand
, "");
412 string_set(&pService
->szPrintcommand
, "");
413 string_set(&pService
->szLppausecommand
, "");
414 string_set(&pService
->szLpresumecommand
, "");
415 string_set(&pService
->szQueuepausecommand
, "");
416 string_set(&pService
->szQueueresumecommand
, "");
421 string_set(&pService
->szLpqcommand
, "lpstat -o%p");
422 string_set(&pService
->szLprmcommand
, "cancel %p-%j");
423 string_set(&pService
->szPrintcommand
, "lp -c -d%p %s; rm %s");
424 string_set(&pService
->szQueuepausecommand
, "disable %p");
425 string_set(&pService
->szQueueresumecommand
, "enable %p");
427 string_set(&pService
->szLppausecommand
, "lp -i %p-%j -H hold");
428 string_set(&pService
->szLpresumecommand
, "lp -i %p-%j -H resume");
433 string_set(&pService
->szLpqcommand
, "lpq -P%p");
434 string_set(&pService
->szLprmcommand
, "lprm -P%p %j");
435 string_set(&pService
->szPrintcommand
, "lp -r -P%p %s");
438 #if defined(DEVELOPER) || defined(ENABLE_SELFTEST)
443 TALLOC_CTX
*tmp_ctx
= talloc_stackframe();
446 tdbfile
= talloc_asprintf(
447 tmp_ctx
, "tdbfile=%s",
448 lp_parm_const_string(-1, "vlp", "tdbfile",
450 if (tdbfile
== NULL
) {
451 tdbfile
="tdbfile=/tmp/vlp.tdb";
454 tmp
= talloc_asprintf(tmp_ctx
, "vlp %s print %%p %%s",
456 string_set(&pService
->szPrintcommand
,
457 tmp
? tmp
: "vlp print %p %s");
459 tmp
= talloc_asprintf(tmp_ctx
, "vlp %s lpq %%p",
461 string_set(&pService
->szLpqcommand
,
462 tmp
? tmp
: "vlp lpq %p");
464 tmp
= talloc_asprintf(tmp_ctx
, "vlp %s lprm %%p %%j",
466 string_set(&pService
->szLprmcommand
,
467 tmp
? tmp
: "vlp lprm %p %j");
469 tmp
= talloc_asprintf(tmp_ctx
, "vlp %s lppause %%p %%j",
471 string_set(&pService
->szLppausecommand
,
472 tmp
? tmp
: "vlp lppause %p %j");
474 tmp
= talloc_asprintf(tmp_ctx
, "vlp %s lpresume %%p %%j",
476 string_set(&pService
->szLpresumecommand
,
477 tmp
? tmp
: "vlp lpresume %p %j");
479 tmp
= talloc_asprintf(tmp_ctx
, "vlp %s queuepause %%p",
481 string_set(&pService
->szQueuepausecommand
,
482 tmp
? tmp
: "vlp queuepause %p");
484 tmp
= talloc_asprintf(tmp_ctx
, "vlp %s queueresume %%p",
486 string_set(&pService
->szQueueresumecommand
,
487 tmp
? tmp
: "vlp queueresume %p");
488 TALLOC_FREE(tmp_ctx
);
492 #endif /* DEVELOPER */
497 * Function to return the default value for the maximum number of open
498 * file descriptors permitted. This function tries to consult the
499 * kernel-level (sysctl) and ulimit (getrlimit()) values and goes
500 * the smaller of those.
502 static int max_open_files(void)
504 int sysctl_max
= MAX_OPEN_FILES
;
505 int rlimit_max
= MAX_OPEN_FILES
;
507 #ifdef HAVE_SYSCTLBYNAME
509 size_t size
= sizeof(sysctl_max
);
510 sysctlbyname("kern.maxfilesperproc", &sysctl_max
, &size
, NULL
,
515 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
521 if (getrlimit(RLIMIT_NOFILE
, &rl
) == 0)
522 rlimit_max
= rl
.rlim_cur
;
524 #if defined(RLIM_INFINITY)
525 if(rl
.rlim_cur
== RLIM_INFINITY
)
526 rlimit_max
= MAX_OPEN_FILES
;
531 if (sysctl_max
< MIN_OPEN_FILES_WINDOWS
) {
532 DEBUG(2,("max_open_files: increasing sysctl_max (%d) to "
533 "minimum Windows limit (%d)\n",
535 MIN_OPEN_FILES_WINDOWS
));
536 sysctl_max
= MIN_OPEN_FILES_WINDOWS
;
539 if (rlimit_max
< MIN_OPEN_FILES_WINDOWS
) {
540 DEBUG(2,("rlimit_max: increasing rlimit_max (%d) to "
541 "minimum Windows limit (%d)\n",
543 MIN_OPEN_FILES_WINDOWS
));
544 rlimit_max
= MIN_OPEN_FILES_WINDOWS
;
547 return MIN(sysctl_max
, rlimit_max
);
551 * Common part of freeing allocated data for one parameter.
553 static void free_one_parameter_common(void *parm_ptr
,
554 struct parm_struct parm
)
556 if ((parm
.type
== P_STRING
) ||
557 (parm
.type
== P_USTRING
))
559 string_free((char**)parm_ptr
);
560 } else if (parm
.type
== P_LIST
) {
561 TALLOC_FREE(*((char***)parm_ptr
));
566 * Free the allocated data for one parameter for a share
567 * given as a service struct.
569 static void free_one_parameter(struct loadparm_service
*service
,
570 struct parm_struct parm
)
574 if (parm
.p_class
!= P_LOCAL
) {
578 parm_ptr
= lp_parm_ptr(service
, &parm
);
580 free_one_parameter_common(parm_ptr
, parm
);
584 * Free the allocated parameter data of a share given
585 * as a service struct.
587 static void free_parameters(struct loadparm_service
*service
)
591 for (i
=0; parm_table
[i
].label
; i
++) {
592 free_one_parameter(service
, parm_table
[i
]);
597 * Free the allocated data for one parameter for a given share
598 * specified by an snum.
600 static void free_one_parameter_by_snum(int snum
, struct parm_struct parm
)
605 parm_ptr
= lp_parm_ptr(NULL
, &parm
);
606 } else if (parm
.p_class
!= P_LOCAL
) {
609 parm_ptr
= lp_local_ptr_by_snum(snum
, &parm
);
612 free_one_parameter_common(parm_ptr
, parm
);
616 * Free the allocated parameter data for a share specified
619 static void free_parameters_by_snum(int snum
)
623 for (i
=0; parm_table
[i
].label
; i
++) {
624 free_one_parameter_by_snum(snum
, parm_table
[i
]);
629 * Free the allocated global parameters.
631 static void free_global_parameters(void)
633 free_param_opts(&Globals
.param_opt
);
634 free_parameters_by_snum(GLOBAL_SECTION_SNUM
);
635 TALLOC_FREE(Globals
.ctx
);
638 static int map_parameter(const char *pszParmName
);
640 struct lp_stored_option
{
641 struct lp_stored_option
*prev
, *next
;
646 static struct lp_stored_option
*stored_options
;
649 save options set by lp_set_cmdline() into a list. This list is
650 re-applied when we do a globals reset, so that cmdline set options
651 are sticky across reloads of smb.conf
653 static bool store_lp_set_cmdline(const char *pszParmName
, const char *pszParmValue
)
655 struct lp_stored_option
*entry
, *entry_next
;
656 for (entry
= stored_options
; entry
!= NULL
; entry
= entry_next
) {
657 entry_next
= entry
->next
;
658 if (strcmp(pszParmName
, entry
->label
) == 0) {
659 DLIST_REMOVE(stored_options
, entry
);
665 entry
= talloc(NULL
, struct lp_stored_option
);
670 entry
->label
= talloc_strdup(entry
, pszParmName
);
676 entry
->value
= talloc_strdup(entry
, pszParmValue
);
682 DLIST_ADD_END(stored_options
, entry
, struct lp_stored_option
);
687 static bool apply_lp_set_cmdline(void)
689 struct lp_stored_option
*entry
= NULL
;
690 for (entry
= stored_options
; entry
!= NULL
; entry
= entry
->next
) {
691 if (!lp_set_cmdline_helper(entry
->label
, entry
->value
, false)) {
692 DEBUG(0, ("Failed to re-apply cmdline parameter %s = %s\n",
693 entry
->label
, entry
->value
));
700 /***************************************************************************
701 Initialise the global parameter structure.
702 ***************************************************************************/
704 static void init_globals(bool reinit_globals
)
706 static bool done_init
= false;
710 /* If requested to initialize only once and we've already done it... */
711 if (!reinit_globals
&& done_init
) {
712 /* ... then we have nothing more to do */
717 /* The logfile can be set before this is invoked. Free it if so. */
718 if (Globals
.logfile
!= NULL
) {
719 string_free(&Globals
.logfile
);
720 Globals
.logfile
= NULL
;
724 free_global_parameters();
727 /* This memset and the free_global_parameters() above will
728 * wipe out smb.conf options set with lp_set_cmdline(). The
729 * apply_lp_set_cmdline() call puts these values back in the
730 * table once the defaults are set */
731 ZERO_STRUCT(Globals
);
733 Globals
.ctx
= talloc_new(NULL
);
735 for (i
= 0; parm_table
[i
].label
; i
++) {
736 if ((parm_table
[i
].type
== P_STRING
||
737 parm_table
[i
].type
== P_USTRING
))
739 string_set((char **)lp_parm_ptr(NULL
, &parm_table
[i
]), "");
744 string_set(&sDefault
.fstype
, FSTYPE_STRING
);
745 string_set(&sDefault
.szPrintjobUsername
, "%U");
747 init_printer_values(&sDefault
);
750 DEBUG(3, ("Initialising global parameters\n"));
752 /* Must manually force to upper case here, as this does not go via the handler */
753 string_set(&Globals
.szNetbiosName
, myhostname_upper());
755 string_set(&Globals
.szSMBPasswdFile
, get_dyn_SMB_PASSWD_FILE());
756 string_set(&Globals
.szPrivateDir
, get_dyn_PRIVATE_DIR());
758 /* use the new 'hash2' method by default, with a prefix of 1 */
759 string_set(&Globals
.szManglingMethod
, "hash2");
760 Globals
.mangle_prefix
= 1;
762 string_set(&Globals
.szGuestaccount
, GUEST_ACCOUNT
);
764 /* using UTF8 by default allows us to support all chars */
765 string_set(&Globals
.unix_charset
, DEFAULT_UNIX_CHARSET
);
767 /* Use codepage 850 as a default for the dos character set */
768 string_set(&Globals
.dos_charset
, DEFAULT_DOS_CHARSET
);
771 * Allow the default PASSWD_CHAT to be overridden in local.h.
773 string_set(&Globals
.szPasswdChat
, DEFAULT_PASSWD_CHAT
);
775 string_set(&Globals
.szWorkgroup
, DEFAULT_WORKGROUP
);
777 string_set(&Globals
.szPasswdProgram
, "");
778 string_set(&Globals
.szLockDir
, get_dyn_LOCKDIR());
779 string_set(&Globals
.szStateDir
, get_dyn_STATEDIR());
780 string_set(&Globals
.szCacheDir
, get_dyn_CACHEDIR());
781 string_set(&Globals
.szPidDir
, get_dyn_PIDDIR());
782 string_set(&Globals
.nbt_client_socket_address
, "0.0.0.0");
784 * By default support explicit binding to broadcast
787 Globals
.bNmbdBindExplicitBroadcast
= true;
789 if (asprintf(&s
, "Samba %s", samba_version_string()) < 0) {
790 smb_panic("init_globals: ENOMEM");
792 string_set(&Globals
.szServerString
, s
);
795 string_set(&Globals
.szPanicAction
, "/bin/sleep 999999999");
798 string_set(&Globals
.socket_options
, DEFAULT_SOCKET_OPTIONS
);
800 string_set(&Globals
.szLogonDrive
, "");
801 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
802 string_set(&Globals
.szLogonHome
, "\\\\%N\\%U");
803 string_set(&Globals
.szLogonPath
, "\\\\%N\\%U\\profile");
805 Globals
.szNameResolveOrder
= (const char **)str_list_make_v3(NULL
, "lmhosts wins host bcast", NULL
);
806 string_set(&Globals
.szPasswordServer
, "*");
808 Globals
.AlgorithmicRidBase
= BASE_RID
;
810 Globals
.bLoadPrinters
= true;
811 Globals
.PrintcapCacheTime
= 750; /* 12.5 minutes */
813 Globals
.ConfigBackend
= config_backend
;
814 Globals
.server_role
= ROLE_AUTO
;
816 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
817 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
818 Globals
.max_xmit
= 0x4104;
819 Globals
.max_mux
= 50; /* This is *needed* for profile support. */
820 Globals
.lpqcachetime
= 30; /* changed to handle large print servers better -- jerry */
821 Globals
.bDisableSpoolss
= false;
822 Globals
.iMaxSmbdProcesses
= 0;/* no limit specified */
823 Globals
.unamelevel
= 0;
824 Globals
.deadtime
= 0;
825 Globals
.getwd_cache
= true;
826 Globals
.bLargeReadwrite
= true;
827 Globals
.max_log_size
= 5000;
828 Globals
.max_open_files
= max_open_files();
829 Globals
.open_files_db_hash_size
= SMB_OPEN_DATABASE_TDB_HASH_SIZE
;
830 Globals
.srv_maxprotocol
= PROTOCOL_SMB3_00
;
831 Globals
.srv_minprotocol
= PROTOCOL_LANMAN1
;
832 Globals
.cli_maxprotocol
= PROTOCOL_NT1
;
833 Globals
.cli_minprotocol
= PROTOCOL_CORE
;
834 Globals
.security
= SEC_USER
;
835 Globals
.bEncryptPasswords
= true;
836 Globals
.clientSchannel
= Auto
;
837 Globals
.serverSchannel
= Auto
;
838 Globals
.bReadRaw
= true;
839 Globals
.bWriteRaw
= true;
840 Globals
.bNullPasswords
= false;
841 Globals
.bObeyPamRestrictions
= false;
843 Globals
.bSyslogOnly
= false;
844 Globals
.bTimestampLogs
= true;
845 string_set(&Globals
.loglevel
, "0");
846 Globals
.bDebugPrefixTimestamp
= false;
847 Globals
.bDebugHiresTimestamp
= true;
848 Globals
.bDebugPid
= false;
849 Globals
.bDebugUid
= false;
850 Globals
.bDebugClass
= false;
851 Globals
.bEnableCoreFiles
= true;
852 Globals
.max_ttl
= 60 * 60 * 24 * 3; /* 3 days default. */
853 Globals
.max_wins_ttl
= 60 * 60 * 24 * 6; /* 6 days default. */
854 Globals
.min_wins_ttl
= 60 * 60 * 6; /* 6 hours default. */
855 Globals
.machine_password_timeout
= 60 * 60 * 24 * 7; /* 7 days default. */
856 Globals
.lm_announce
= Auto
; /* = Auto: send only if LM clients found */
857 Globals
.lm_interval
= 60;
858 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
859 Globals
.bNISHomeMap
= false;
860 #ifdef WITH_NISPLUS_HOME
861 string_set(&Globals
.szNISHomeMapName
, "auto_home.org_dir");
863 string_set(&Globals
.szNISHomeMapName
, "auto.home");
866 Globals
.bTimeServer
= false;
867 Globals
.bBindInterfacesOnly
= false;
868 Globals
.bUnixPasswdSync
= false;
869 Globals
.bPamPasswordChange
= false;
870 Globals
.bPasswdChatDebug
= false;
871 Globals
.iPasswdChatTimeout
= 2; /* 2 second default. */
872 Globals
.bNTPipeSupport
= true; /* Do NT pipes by default. */
873 Globals
.bNTStatusSupport
= true; /* Use NT status by default. */
874 Globals
.bStatCache
= true; /* use stat cache by default */
875 Globals
.iMaxStatCacheSize
= 256; /* 256k by default */
876 Globals
.restrict_anonymous
= 0;
877 Globals
.bClientLanManAuth
= false; /* Do NOT use the LanMan hash if it is available */
878 Globals
.bClientPlaintextAuth
= false; /* Do NOT use a plaintext password even if is requested by the server */
879 Globals
.bLanmanAuth
= false; /* Do NOT use the LanMan hash, even if it is supplied */
880 Globals
.bNTLMAuth
= true; /* Do use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
881 Globals
.bClientNTLMv2Auth
= true; /* Client should always use use NTLMv2, as we can't tell that the server supports it, but most modern servers do */
882 /* Note, that we will also use NTLM2 session security (which is different), if it is available */
884 Globals
.map_to_guest
= 0; /* By Default, "Never" */
885 Globals
.oplock_break_wait_time
= 0; /* By Default, 0 msecs. */
886 Globals
.enhanced_browsing
= true;
887 Globals
.iLockSpinTime
= WINDOWS_MINIMUM_LOCK_TIMEOUT_MS
; /* msec. */
888 #ifdef MMAP_BLACKLIST
889 Globals
.bUseMmap
= false;
891 Globals
.bUseMmap
= true;
893 Globals
.bUnicode
= true;
894 Globals
.bUnixExtensions
= true;
895 Globals
.bResetOnZeroVC
= false;
896 Globals
.bLogWriteableFilesOnExit
= false;
897 Globals
.bCreateKrb5Conf
= true;
898 Globals
.winbindMaxDomainConnections
= 1;
900 /* hostname lookups can be very expensive and are broken on
901 a large number of sites (tridge) */
902 Globals
.bHostnameLookups
= false;
904 string_set(&Globals
.passdb_backend
, "tdbsam");
905 string_set(&Globals
.szLdapSuffix
, "");
906 string_set(&Globals
.szLdapMachineSuffix
, "");
907 string_set(&Globals
.szLdapUserSuffix
, "");
908 string_set(&Globals
.szLdapGroupSuffix
, "");
909 string_set(&Globals
.szLdapIdmapSuffix
, "");
911 string_set(&Globals
.szLdapAdminDn
, "");
912 Globals
.ldap_ssl
= LDAP_SSL_START_TLS
;
913 Globals
.ldap_ssl_ads
= false;
914 Globals
.ldap_deref
= -1;
915 Globals
.ldap_passwd_sync
= LDAP_PASSWD_SYNC_OFF
;
916 Globals
.ldap_delete_dn
= false;
917 Globals
.ldap_replication_sleep
= 1000; /* wait 1 sec for replication */
918 Globals
.ldap_follow_referral
= Auto
;
919 Globals
.ldap_timeout
= LDAP_DEFAULT_TIMEOUT
;
920 Globals
.ldap_connection_timeout
= LDAP_CONNECTION_DEFAULT_TIMEOUT
;
921 Globals
.ldap_page_size
= LDAP_PAGE_SIZE
;
923 Globals
.ldap_debug_level
= 0;
924 Globals
.ldap_debug_threshold
= 10;
926 /* This is what we tell the afs client. in reality we set the token
927 * to never expire, though, when this runs out the afs client will
928 * forget the token. Set to 0 to get NEVERDATE.*/
929 Globals
.iAfsTokenLifetime
= 604800;
930 Globals
.cups_connection_timeout
= CUPS_DEFAULT_CONNECTION_TIMEOUT
;
932 /* these parameters are set to defaults that are more appropriate
933 for the increasing samba install base:
935 as a member of the workgroup, that will possibly become a
936 _local_ master browser (lm = true). this is opposed to a forced
937 local master browser startup (pm = true).
939 doesn't provide WINS server service by default (wsupp = false),
940 and doesn't provide domain master browser services by default, either.
944 Globals
.bMsAddPrinterWizard
= true;
945 Globals
.os_level
= 20;
946 Globals
.bLocalMaster
= true;
947 Globals
.domain_master
= Auto
; /* depending on bDomainLogons */
948 Globals
.bDomainLogons
= false;
949 Globals
.bBrowseList
= true;
950 Globals
.bWINSsupport
= false;
951 Globals
.bWINSproxy
= false;
953 TALLOC_FREE(Globals
.szInitLogonDelayedHosts
);
954 Globals
.InitLogonDelay
= 100; /* 100 ms default delay */
956 Globals
.bWINSdnsProxy
= true;
958 Globals
.bAllowTrustedDomains
= true;
959 string_set(&Globals
.szIdmapBackend
, "tdb");
961 string_set(&Globals
.szTemplateShell
, "/bin/false");
962 string_set(&Globals
.szTemplateHomedir
, "/home/%D/%U");
963 string_set(&Globals
.szWinbindSeparator
, "\\");
965 string_set(&Globals
.szCupsServer
, "");
966 string_set(&Globals
.szIPrintServer
, "");
968 #ifdef CLUSTER_SUPPORT
969 string_set(&Globals
.ctdbdSocket
, CTDB_PATH
);
971 string_set(&Globals
.ctdbdSocket
, "");
974 Globals
.szClusterAddresses
= NULL
;
975 Globals
.clustering
= false;
976 Globals
.ctdb_timeout
= 0;
977 Globals
.ctdb_locktime_warn_threshold
= 0;
979 Globals
.winbind_cache_time
= 300; /* 5 minutes */
980 Globals
.winbind_reconnect_delay
= 30; /* 30 seconds */
981 Globals
.winbind_request_timeout
= 60; /* 60 seconds */
982 Globals
.winbind_max_clients
= 200;
983 Globals
.bWinbindEnumUsers
= false;
984 Globals
.bWinbindEnumGroups
= false;
985 Globals
.bWinbindUseDefaultDomain
= false;
986 Globals
.bWinbindTrustedDomainsOnly
= false;
987 Globals
.bWinbindNestedGroups
= true;
988 Globals
.winbind_expand_groups
= 1;
989 Globals
.szWinbindNssInfo
= (const char **)str_list_make_v3(NULL
, "template", NULL
);
990 Globals
.bWinbindRefreshTickets
= false;
991 Globals
.bWinbindOfflineLogon
= false;
993 Globals
.iIdmapCacheTime
= 86400 * 7; /* a week by default */
994 Globals
.iIdmapNegativeCacheTime
= 120; /* 2 minutes by default */
996 Globals
.bPassdbExpandExplicit
= false;
998 Globals
.name_cache_timeout
= 660; /* In seconds */
1000 Globals
.bUseSpnego
= true;
1001 Globals
.bClientUseSpnego
= true;
1003 Globals
.client_signing
= SMB_SIGNING_DEFAULT
;
1004 Globals
.server_signing
= SMB_SIGNING_DEFAULT
;
1006 Globals
.bDeferSharingViolations
= true;
1007 Globals
.smb_ports
= (const char **)str_list_make_v3(NULL
, SMB_PORTS
, NULL
);
1009 Globals
.bEnablePrivileges
= true;
1010 Globals
.bHostMSDfs
= true;
1011 Globals
.bASUSupport
= false;
1013 /* User defined shares. */
1014 if (asprintf(&s
, "%s/usershares", get_dyn_STATEDIR()) < 0) {
1015 smb_panic("init_globals: ENOMEM");
1017 string_set(&Globals
.szUsersharePath
, s
);
1019 string_set(&Globals
.szUsershareTemplateShare
, "");
1020 Globals
.iUsershareMaxShares
= 0;
1021 /* By default disallow sharing of directories not owned by the sharer. */
1022 Globals
.bUsershareOwnerOnly
= true;
1023 /* By default disallow guest access to usershares. */
1024 Globals
.bUsershareAllowGuests
= false;
1026 Globals
.iKeepalive
= DEFAULT_KEEPALIVE
;
1028 /* By default no shares out of the registry */
1029 Globals
.bRegistryShares
= false;
1031 Globals
.iminreceivefile
= 0;
1033 Globals
.bMapUntrustedToDomain
= false;
1034 Globals
.bMulticastDnsRegister
= true;
1036 Globals
.ismb2_max_read
= DEFAULT_SMB2_MAX_READ
;
1037 Globals
.ismb2_max_write
= DEFAULT_SMB2_MAX_WRITE
;
1038 Globals
.ismb2_max_trans
= DEFAULT_SMB2_MAX_TRANSACT
;
1039 Globals
.ismb2_max_credits
= DEFAULT_SMB2_MAX_CREDITS
;
1041 string_set(&Globals
.ncalrpc_dir
, get_dyn_NCALRPCDIR());
1043 /* Now put back the settings that were set with lp_set_cmdline() */
1044 apply_lp_set_cmdline();
1047 /*******************************************************************
1048 Convenience routine to grab string parameters into talloced memory
1049 and run standard_sub_basic on them. The buffers can be written to by
1050 callers without affecting the source string.
1051 ********************************************************************/
1053 static char *lp_string(TALLOC_CTX
*ctx
, const char *s
)
1057 /* The follow debug is useful for tracking down memory problems
1058 especially if you have an inner loop that is calling a lp_*()
1059 function that returns a string. Perhaps this debug should be
1060 present all the time? */
1063 DEBUG(10, ("lp_string(%s)\n", s
));
1069 ret
= talloc_sub_basic(ctx
,
1070 get_current_username(),
1071 current_user_info
.domain
,
1073 if (trim_char(ret
, '\"', '\"')) {
1074 if (strchr(ret
,'\"') != NULL
) {
1076 ret
= talloc_sub_basic(ctx
,
1077 get_current_username(),
1078 current_user_info
.domain
,
1086 In this section all the functions that are used to access the
1087 parameters from the rest of the program are defined
1090 #define FN_GLOBAL_STRING(fn_name,ptr) \
1091 char *lp_ ## fn_name(TALLOC_CTX *ctx) {return(lp_string((ctx), *(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : ""));}
1092 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1093 const char *lp_ ## fn_name(void) {return(*(const char * const *)(&Globals.ptr) ? *(const char * const *)(&Globals.ptr) : "");}
1094 #define FN_GLOBAL_LIST(fn_name,ptr) \
1095 const char **lp_ ## fn_name(void) {return(*(const char ***)(&Globals.ptr));}
1096 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1097 bool lp_ ## fn_name(void) {return(*(bool *)(&Globals.ptr));}
1098 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1099 char lp_ ## fn_name(void) {return(*(char *)(&Globals.ptr));}
1100 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1101 int lp_ ## fn_name(void) {return(*(int *)(&Globals.ptr));}
1103 #define FN_LOCAL_STRING(fn_name,val) \
1104 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));}
1105 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1106 const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1107 #define FN_LOCAL_LIST(fn_name,val) \
1108 const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1109 #define FN_LOCAL_BOOL(fn_name,val) \
1110 bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1111 #define FN_LOCAL_INTEGER(fn_name,val) \
1112 int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1114 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1115 bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1116 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1117 int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1118 #define FN_LOCAL_CHAR(fn_name,val) \
1119 char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1122 static FN_GLOBAL_BOOL(_readraw
, bReadRaw
)
1123 static FN_GLOBAL_BOOL(_writeraw
, bWriteRaw
)
1125 /* If lp_statedir() and lp_cachedir() are explicitely set during the
1126 * build process or in smb.conf, we use that value. Otherwise they
1127 * default to the value of lp_lockdir(). */
1128 const char *lp_statedir(void) {
1129 if ((strcmp(get_dyn_STATEDIR(), get_dyn_LOCKDIR()) != 0) ||
1130 (strcmp(get_dyn_STATEDIR(), Globals
.szStateDir
) != 0))
1131 return(*(char **)(&Globals
.szStateDir
) ?
1132 *(char **)(&Globals
.szStateDir
) : "");
1134 return(*(char **)(&Globals
.szLockDir
) ?
1135 *(char **)(&Globals
.szLockDir
) : "");
1137 const char *lp_cachedir(void) {
1138 if ((strcmp(get_dyn_CACHEDIR(), get_dyn_LOCKDIR()) != 0) ||
1139 (strcmp(get_dyn_CACHEDIR(), Globals
.szCacheDir
) != 0))
1140 return(*(char **)(&Globals
.szCacheDir
) ?
1141 *(char **)(&Globals
.szCacheDir
) : "");
1143 return(*(char **)(&Globals
.szLockDir
) ?
1144 *(char **)(&Globals
.szLockDir
) : "");
1146 static FN_GLOBAL_INTEGER(winbind_max_domain_connections_int
,
1147 winbindMaxDomainConnections
)
1149 int lp_winbind_max_domain_connections(void)
1151 if (lp_winbind_offline_logon() &&
1152 lp_winbind_max_domain_connections_int() > 1) {
1153 DEBUG(1, ("offline logons active, restricting max domain "
1154 "connections to 1\n"));
1157 return MAX(1, lp_winbind_max_domain_connections_int());
1160 int lp_smb2_max_credits(void)
1162 if (Globals
.ismb2_max_credits
== 0) {
1163 Globals
.ismb2_max_credits
= DEFAULT_SMB2_MAX_CREDITS
;
1165 return Globals
.ismb2_max_credits
;
1167 int lp_cups_encrypt(void)
1170 #ifdef HAVE_HTTPCONNECTENCRYPT
1171 switch (Globals
.CupsEncrypt
) {
1173 result
= HTTP_ENCRYPT_REQUIRED
;
1176 result
= HTTP_ENCRYPT_ALWAYS
;
1179 result
= HTTP_ENCRYPT_NEVER
;
1186 /* These functions remain in source3/param for now */
1188 FN_GLOBAL_STRING(configfile
, szConfigFile
)
1190 #include "lib/param/param_functions.c"
1192 FN_LOCAL_STRING(servicename
, szService
)
1193 FN_LOCAL_CONST_STRING(const_servicename
, szService
)
1195 /* local prototypes */
1197 static int map_parameter_canonical(const char *pszParmName
, bool *inverse
);
1198 static const char *get_boolean(bool bool_value
);
1199 static int getservicebyname(const char *pszServiceName
,
1200 struct loadparm_service
*pserviceDest
);
1201 static void copy_service(struct loadparm_service
*pserviceDest
,
1202 struct loadparm_service
*pserviceSource
,
1203 struct bitmap
*pcopymapDest
);
1204 static bool do_parameter(const char *pszParmName
, const char *pszParmValue
,
1206 static bool do_section(const char *pszSectionName
, void *userdata
);
1207 static void init_copymap(struct loadparm_service
*pservice
);
1208 static bool hash_a_service(const char *name
, int number
);
1209 static void free_service_byindex(int iService
);
1210 static void show_parameter(int parmIndex
);
1211 static bool is_synonym_of(int parm1
, int parm2
, bool *inverse
);
1214 * This is a helper function for parametrical options support. It returns a
1215 * pointer to parametrical option value if it exists or NULL otherwise. Actual
1216 * parametrical functions are quite simple
1218 static struct parmlist_entry
*get_parametrics_by_service(struct loadparm_service
*service
, const char *type
,
1221 bool global_section
= false;
1223 struct parmlist_entry
*data
;
1225 if (service
== NULL
) {
1226 data
= Globals
.param_opt
;
1227 global_section
= true;
1229 data
= service
->param_opt
;
1232 if (asprintf(¶m_key
, "%s:%s", type
, option
) == -1) {
1233 DEBUG(0,("asprintf failed!\n"));
1238 if (strwicmp(data
->key
, param_key
) == 0) {
1239 string_free(¶m_key
);
1245 if (!global_section
) {
1246 /* Try to fetch the same option but from globals */
1247 /* but only if we are not already working with Globals */
1248 data
= Globals
.param_opt
;
1250 if (strwicmp(data
->key
, param_key
) == 0) {
1251 string_free(¶m_key
);
1258 string_free(¶m_key
);
1264 * This is a helper function for parametrical options support. It returns a
1265 * pointer to parametrical option value if it exists or NULL otherwise. Actual
1266 * parametrical functions are quite simple
1268 static struct parmlist_entry
*get_parametrics(int snum
, const char *type
,
1271 if (snum
>= iNumServices
) return NULL
;
1274 return get_parametrics_by_service(NULL
, type
, option
);
1276 return get_parametrics_by_service(ServicePtrs
[snum
], type
, option
);
1281 #define MISSING_PARAMETER(name) \
1282 DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
1284 /*******************************************************************
1285 convenience routine to return int parameters.
1286 ********************************************************************/
1287 static int lp_int(const char *s
)
1291 MISSING_PARAMETER(lp_int
);
1295 return (int)strtol(s
, NULL
, 0);
1298 /*******************************************************************
1299 convenience routine to return unsigned long parameters.
1300 ********************************************************************/
1301 static unsigned long lp_ulong(const char *s
)
1305 MISSING_PARAMETER(lp_ulong
);
1309 return strtoul(s
, NULL
, 0);
1312 /*******************************************************************
1313 convenience routine to return boolean parameters.
1314 ********************************************************************/
1315 static bool lp_bool(const char *s
)
1320 MISSING_PARAMETER(lp_bool
);
1324 if (!set_boolean(s
, &ret
)) {
1325 DEBUG(0,("lp_bool(%s): value is not boolean!\n",s
));
1332 /*******************************************************************
1333 convenience routine to return enum parameters.
1334 ********************************************************************/
1335 static int lp_enum(const char *s
,const struct enum_list
*_enum
)
1339 if (!s
|| !*s
|| !_enum
) {
1340 MISSING_PARAMETER(lp_enum
);
1344 for (i
=0; _enum
[i
].name
; i
++) {
1345 if (strequal(_enum
[i
].name
,s
))
1346 return _enum
[i
].value
;
1349 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s
));
1353 #undef MISSING_PARAMETER
1355 /* Return parametric option from a given service. Type is a part of option before ':' */
1356 /* Parametric option has following syntax: 'Type: option = value' */
1357 char *lp_parm_talloc_string(TALLOC_CTX
*ctx
, int snum
, const char *type
, const char *option
, const char *def
)
1359 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1361 if (data
== NULL
||data
->value
==NULL
) {
1363 return lp_string(ctx
, def
);
1369 return lp_string(ctx
, data
->value
);
1372 /* Return parametric option from a given service. Type is a part of option before ':' */
1373 /* Parametric option has following syntax: 'Type: option = value' */
1374 const char *lp_parm_const_string(int snum
, const char *type
, const char *option
, const char *def
)
1376 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1378 if (data
== NULL
||data
->value
==NULL
)
1384 const char *lp_parm_const_string_service(struct loadparm_service
*service
, const char *type
, const char *option
)
1386 struct parmlist_entry
*data
= get_parametrics_by_service(service
, type
, option
);
1388 if (data
== NULL
||data
->value
==NULL
)
1395 /* Return parametric option from a given service. Type is a part of option before ':' */
1396 /* Parametric option has following syntax: 'Type: option = value' */
1398 const char **lp_parm_string_list(int snum
, const char *type
, const char *option
, const char **def
)
1400 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1402 if (data
== NULL
||data
->value
==NULL
)
1403 return (const char **)def
;
1405 if (data
->list
==NULL
) {
1406 data
->list
= str_list_make_v3(NULL
, data
->value
, NULL
);
1409 return (const char **)data
->list
;
1412 /* Return parametric option from a given service. Type is a part of option before ':' */
1413 /* Parametric option has following syntax: 'Type: option = value' */
1415 int lp_parm_int(int snum
, const char *type
, const char *option
, int def
)
1417 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1419 if (data
&& data
->value
&& *data
->value
)
1420 return lp_int(data
->value
);
1425 /* Return parametric option from a given service. Type is a part of option before ':' */
1426 /* Parametric option has following syntax: 'Type: option = value' */
1428 unsigned long lp_parm_ulong(int snum
, const char *type
, const char *option
, unsigned long def
)
1430 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1432 if (data
&& data
->value
&& *data
->value
)
1433 return lp_ulong(data
->value
);
1438 /* Return parametric option from a given service. Type is a part of option before ':' */
1439 /* Parametric option has following syntax: 'Type: option = value' */
1441 bool lp_parm_bool(int snum
, const char *type
, const char *option
, bool def
)
1443 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1445 if (data
&& data
->value
&& *data
->value
)
1446 return lp_bool(data
->value
);
1451 /* Return parametric option from a given service. Type is a part of option before ':' */
1452 /* Parametric option has following syntax: 'Type: option = value' */
1454 int lp_parm_enum(int snum
, const char *type
, const char *option
,
1455 const struct enum_list
*_enum
, int def
)
1457 struct parmlist_entry
*data
= get_parametrics(snum
, type
, option
);
1459 if (data
&& data
->value
&& *data
->value
&& _enum
)
1460 return lp_enum(data
->value
, _enum
);
1466 /***************************************************************************
1467 Initialise a service to the defaults.
1468 ***************************************************************************/
1470 static void init_service(struct loadparm_service
*pservice
)
1472 memset((char *)pservice
, '\0', sizeof(struct loadparm_service
));
1473 copy_service(pservice
, &sDefault
, NULL
);
1478 * free a param_opts structure.
1479 * param_opts handling should be moved to talloc;
1480 * then this whole functions reduces to a TALLOC_FREE().
1483 static void free_param_opts(struct parmlist_entry
**popts
)
1485 struct parmlist_entry
*opt
, *next_opt
;
1487 if (*popts
!= NULL
) {
1488 DEBUG(5, ("Freeing parametrics:\n"));
1491 while (opt
!= NULL
) {
1492 string_free(&opt
->key
);
1493 string_free(&opt
->value
);
1494 TALLOC_FREE(opt
->list
);
1495 next_opt
= opt
->next
;
1502 /***************************************************************************
1503 Free the dynamically allocated parts of a service struct.
1504 ***************************************************************************/
1506 static void free_service(struct loadparm_service
*pservice
)
1511 if (pservice
->szService
)
1512 DEBUG(5, ("free_service: Freeing service %s\n",
1513 pservice
->szService
));
1515 free_parameters(pservice
);
1517 string_free(&pservice
->szService
);
1518 TALLOC_FREE(pservice
->copymap
);
1520 free_param_opts(&pservice
->param_opt
);
1522 ZERO_STRUCTP(pservice
);
1526 /***************************************************************************
1527 remove a service indexed in the ServicePtrs array from the ServiceHash
1528 and free the dynamically allocated parts
1529 ***************************************************************************/
1531 static void free_service_byindex(int idx
)
1533 if ( !LP_SNUM_OK(idx
) )
1536 ServicePtrs
[idx
]->valid
= false;
1537 invalid_services
[num_invalid_services
++] = idx
;
1539 /* we have to cleanup the hash record */
1541 if (ServicePtrs
[idx
]->szService
) {
1542 char *canon_name
= canonicalize_servicename(
1544 ServicePtrs
[idx
]->szService
);
1546 dbwrap_delete_bystring(ServiceHash
, canon_name
);
1547 TALLOC_FREE(canon_name
);
1550 free_service(ServicePtrs
[idx
]);
1551 talloc_free_children(ServicePtrs
[idx
]);
1554 /***************************************************************************
1555 Add a new service to the services array initialising it with the given
1557 ***************************************************************************/
1559 static int add_a_service(const struct loadparm_service
*pservice
, const char *name
)
1562 struct loadparm_service tservice
;
1563 int num_to_alloc
= iNumServices
+ 1;
1565 tservice
= *pservice
;
1567 /* it might already exist */
1569 i
= getservicebyname(name
, NULL
);
1575 /* find an invalid one */
1577 if (num_invalid_services
> 0) {
1578 i
= invalid_services
[--num_invalid_services
];
1581 /* if not, then create one */
1582 if (i
== iNumServices
) {
1583 struct loadparm_service
**tsp
;
1586 tsp
= SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(ServicePtrs
, struct loadparm_service
*, num_to_alloc
);
1588 DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
1592 ServicePtrs
[iNumServices
] = talloc(NULL
, struct loadparm_service
);
1593 if (!ServicePtrs
[iNumServices
]) {
1594 DEBUG(0,("add_a_service: out of memory!\n"));
1599 /* enlarge invalid_services here for now... */
1600 tinvalid
= SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(invalid_services
, int,
1602 if (tinvalid
== NULL
) {
1603 DEBUG(0,("add_a_service: failed to enlarge "
1604 "invalid_services!\n"));
1607 invalid_services
= tinvalid
;
1609 free_service_byindex(i
);
1612 ServicePtrs
[i
]->valid
= true;
1614 init_service(ServicePtrs
[i
]);
1615 copy_service(ServicePtrs
[i
], &tservice
, NULL
);
1617 string_set(&ServicePtrs
[i
]->szService
, name
);
1619 DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
1620 i
, ServicePtrs
[i
]->szService
));
1622 if (!hash_a_service(ServicePtrs
[i
]->szService
, i
)) {
1629 /***************************************************************************
1630 Convert a string to uppercase and remove whitespaces.
1631 ***************************************************************************/
1633 char *canonicalize_servicename(TALLOC_CTX
*ctx
, const char *src
)
1638 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
1642 result
= talloc_strdup(ctx
, src
);
1643 SMB_ASSERT(result
!= NULL
);
1645 if (!strlower_m(result
)) {
1646 TALLOC_FREE(result
);
1652 /***************************************************************************
1653 Add a name/index pair for the services array to the hash table.
1654 ***************************************************************************/
1656 static bool hash_a_service(const char *name
, int idx
)
1660 if ( !ServiceHash
) {
1661 DEBUG(10,("hash_a_service: creating servicehash\n"));
1662 ServiceHash
= db_open_rbt(NULL
);
1663 if ( !ServiceHash
) {
1664 DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
1669 DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
1672 canon_name
= canonicalize_servicename(talloc_tos(), name
);
1674 dbwrap_store_bystring(ServiceHash
, canon_name
,
1675 make_tdb_data((uint8
*)&idx
, sizeof(idx
)),
1678 TALLOC_FREE(canon_name
);
1683 /***************************************************************************
1684 Add a new home service, with the specified home directory, defaults coming
1686 ***************************************************************************/
1688 bool lp_add_home(const char *pszHomename
, int iDefaultService
,
1689 const char *user
, const char *pszHomedir
)
1693 if (pszHomename
== NULL
|| user
== NULL
|| pszHomedir
== NULL
||
1694 pszHomedir
[0] == '\0') {
1698 i
= add_a_service(ServicePtrs
[iDefaultService
], pszHomename
);
1703 if (!(*(ServicePtrs
[iDefaultService
]->szPath
))
1704 || strequal(ServicePtrs
[iDefaultService
]->szPath
,
1705 lp_pathname(talloc_tos(), GLOBAL_SECTION_SNUM
))) {
1706 string_set(&ServicePtrs
[i
]->szPath
, pszHomedir
);
1709 if (!(*(ServicePtrs
[i
]->comment
))) {
1710 char *comment
= NULL
;
1711 if (asprintf(&comment
, "Home directory of %s", user
) < 0) {
1714 string_set(&ServicePtrs
[i
]->comment
, comment
);
1718 /* set the browseable flag from the global default */
1720 ServicePtrs
[i
]->bBrowseable
= sDefault
.bBrowseable
;
1721 ServicePtrs
[i
]->bAccessBasedShareEnum
= sDefault
.bAccessBasedShareEnum
;
1723 ServicePtrs
[i
]->autoloaded
= true;
1725 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename
,
1726 user
, ServicePtrs
[i
]->szPath
));
1731 /***************************************************************************
1732 Add a new service, based on an old one.
1733 ***************************************************************************/
1735 int lp_add_service(const char *pszService
, int iDefaultService
)
1737 if (iDefaultService
< 0) {
1738 return add_a_service(&sDefault
, pszService
);
1741 return (add_a_service(ServicePtrs
[iDefaultService
], pszService
));
1744 /***************************************************************************
1745 Add the IPC service.
1746 ***************************************************************************/
1748 static bool lp_add_ipc(const char *ipc_name
, bool guest_ok
)
1750 char *comment
= NULL
;
1751 int i
= add_a_service(&sDefault
, ipc_name
);
1756 if (asprintf(&comment
, "IPC Service (%s)",
1757 Globals
.szServerString
) < 0) {
1761 string_set(&ServicePtrs
[i
]->szPath
, tmpdir());
1762 string_set(&ServicePtrs
[i
]->szUsername
, "");
1763 string_set(&ServicePtrs
[i
]->comment
, comment
);
1764 string_set(&ServicePtrs
[i
]->fstype
, "IPC");
1765 ServicePtrs
[i
]->iMaxConnections
= 0;
1766 ServicePtrs
[i
]->bAvailable
= true;
1767 ServicePtrs
[i
]->bRead_only
= true;
1768 ServicePtrs
[i
]->bGuest_only
= false;
1769 ServicePtrs
[i
]->bAdministrative_share
= true;
1770 ServicePtrs
[i
]->bGuest_ok
= guest_ok
;
1771 ServicePtrs
[i
]->bPrint_ok
= false;
1772 ServicePtrs
[i
]->bBrowseable
= sDefault
.bBrowseable
;
1774 DEBUG(3, ("adding IPC service\n"));
1780 /***************************************************************************
1781 Add a new printer service, with defaults coming from service iFrom.
1782 ***************************************************************************/
1784 bool lp_add_printer(const char *pszPrintername
, int iDefaultService
)
1786 const char *comment
= "From Printcap";
1787 int i
= add_a_service(ServicePtrs
[iDefaultService
], pszPrintername
);
1792 /* note that we do NOT default the availability flag to true - */
1793 /* we take it from the default service passed. This allows all */
1794 /* dynamic printers to be disabled by disabling the [printers] */
1795 /* entry (if/when the 'available' keyword is implemented!). */
1797 /* the printer name is set to the service name. */
1798 string_set(&ServicePtrs
[i
]->szPrintername
, pszPrintername
);
1799 string_set(&ServicePtrs
[i
]->comment
, comment
);
1801 /* set the browseable flag from the gloabl default */
1802 ServicePtrs
[i
]->bBrowseable
= sDefault
.bBrowseable
;
1804 /* Printers cannot be read_only. */
1805 ServicePtrs
[i
]->bRead_only
= false;
1806 /* No oplocks on printer services. */
1807 ServicePtrs
[i
]->bOpLocks
= false;
1808 /* Printer services must be printable. */
1809 ServicePtrs
[i
]->bPrint_ok
= true;
1811 DEBUG(3, ("adding printer service %s\n", pszPrintername
));
1817 /***************************************************************************
1818 Check whether the given parameter name is valid.
1819 Parametric options (names containing a colon) are considered valid.
1820 ***************************************************************************/
1822 bool lp_parameter_is_valid(const char *pszParmName
)
1824 return ((map_parameter(pszParmName
) != -1) ||
1825 (strchr(pszParmName
, ':') != NULL
));
1828 /***************************************************************************
1829 Check whether the given name is the name of a global parameter.
1830 Returns true for strings belonging to parameters of class
1831 P_GLOBAL, false for all other strings, also for parametric options
1832 and strings not belonging to any option.
1833 ***************************************************************************/
1835 bool lp_parameter_is_global(const char *pszParmName
)
1837 int num
= map_parameter(pszParmName
);
1840 return (parm_table
[num
].p_class
== P_GLOBAL
);
1846 /**************************************************************************
1847 Check whether the given name is the canonical name of a parameter.
1848 Returns false if it is not a valid parameter Name.
1849 For parametric options, true is returned.
1850 **************************************************************************/
1852 bool lp_parameter_is_canonical(const char *parm_name
)
1854 if (!lp_parameter_is_valid(parm_name
)) {
1858 return (map_parameter(parm_name
) ==
1859 map_parameter_canonical(parm_name
, NULL
));
1862 /**************************************************************************
1863 Determine the canonical name for a parameter.
1864 Indicate when it is an inverse (boolean) synonym instead of a
1866 **************************************************************************/
1868 bool lp_canonicalize_parameter(const char *parm_name
, const char **canon_parm
,
1873 if (!lp_parameter_is_valid(parm_name
)) {
1878 num
= map_parameter_canonical(parm_name
, inverse
);
1880 /* parametric option */
1881 *canon_parm
= parm_name
;
1883 *canon_parm
= parm_table
[num
].label
;
1890 /**************************************************************************
1891 Determine the canonical name for a parameter.
1892 Turn the value given into the inverse boolean expression when
1893 the synonym is an invers boolean synonym.
1895 Return true if parm_name is a valid parameter name and
1896 in case it is an invers boolean synonym, if the val string could
1897 successfully be converted to the reverse bool.
1898 Return false in all other cases.
1899 **************************************************************************/
1901 bool lp_canonicalize_parameter_with_value(const char *parm_name
,
1903 const char **canon_parm
,
1904 const char **canon_val
)
1909 if (!lp_parameter_is_valid(parm_name
)) {
1915 num
= map_parameter_canonical(parm_name
, &inverse
);
1917 /* parametric option */
1918 *canon_parm
= parm_name
;
1921 *canon_parm
= parm_table
[num
].label
;
1923 if (!lp_invert_boolean(val
, canon_val
)) {
1935 /***************************************************************************
1936 Map a parameter's string representation to something we can use.
1937 Returns false if the parameter string is not recognised, else TRUE.
1938 ***************************************************************************/
1940 static int map_parameter(const char *pszParmName
)
1944 if (*pszParmName
== '-' && !strequal(pszParmName
, "-valid"))
1947 for (iIndex
= 0; parm_table
[iIndex
].label
; iIndex
++)
1948 if (strwicmp(parm_table
[iIndex
].label
, pszParmName
) == 0)
1951 /* Warn only if it isn't parametric option */
1952 if (strchr(pszParmName
, ':') == NULL
)
1953 DEBUG(1, ("Unknown parameter encountered: \"%s\"\n", pszParmName
));
1954 /* We do return 'fail' for parametric options as well because they are
1955 stored in different storage
1960 /***************************************************************************
1961 Map a parameter's string representation to the index of the canonical
1962 form of the parameter (it might be a synonym).
1963 Returns -1 if the parameter string is not recognised.
1964 ***************************************************************************/
1966 static int map_parameter_canonical(const char *pszParmName
, bool *inverse
)
1968 int parm_num
, canon_num
;
1969 bool loc_inverse
= false;
1971 parm_num
= map_parameter(pszParmName
);
1972 if ((parm_num
< 0) || !(parm_table
[parm_num
].flags
& FLAG_HIDE
)) {
1973 /* invalid, parametric or no canidate for synonyms ... */
1977 for (canon_num
= 0; parm_table
[canon_num
].label
; canon_num
++) {
1978 if (is_synonym_of(parm_num
, canon_num
, &loc_inverse
)) {
1979 parm_num
= canon_num
;
1985 if (inverse
!= NULL
) {
1986 *inverse
= loc_inverse
;
1991 /***************************************************************************
1992 return true if parameter number parm1 is a synonym of parameter
1993 number parm2 (parm2 being the principal name).
1994 set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
1996 ***************************************************************************/
1998 static bool is_synonym_of(int parm1
, int parm2
, bool *inverse
)
2000 if ((parm_table
[parm1
].offset
== parm_table
[parm2
].offset
) &&
2001 (parm_table
[parm1
].p_class
== parm_table
[parm2
].p_class
) &&
2002 (parm_table
[parm1
].flags
& FLAG_HIDE
) &&
2003 !(parm_table
[parm2
].flags
& FLAG_HIDE
))
2005 if (inverse
!= NULL
) {
2006 if ((parm_table
[parm1
].type
== P_BOOLREV
) &&
2007 (parm_table
[parm2
].type
== P_BOOL
))
2019 /***************************************************************************
2020 Show one parameter's name, type, [values,] and flags.
2021 (helper functions for show_parameter_list)
2022 ***************************************************************************/
2024 static void show_parameter(int parmIndex
)
2026 int enumIndex
, flagIndex
;
2031 const char *type
[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
2032 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
2034 unsigned flags
[] = { FLAG_BASIC
, FLAG_SHARE
, FLAG_PRINT
, FLAG_GLOBAL
,
2035 FLAG_WIZARD
, FLAG_ADVANCED
, FLAG_DEVELOPER
, FLAG_DEPRECATED
,
2037 const char *flag_names
[] = { "FLAG_BASIC", "FLAG_SHARE", "FLAG_PRINT",
2038 "FLAG_GLOBAL", "FLAG_WIZARD", "FLAG_ADVANCED", "FLAG_DEVELOPER",
2039 "FLAG_DEPRECATED", "FLAG_HIDE", NULL
};
2041 printf("%s=%s", parm_table
[parmIndex
].label
,
2042 type
[parm_table
[parmIndex
].type
]);
2043 if (parm_table
[parmIndex
].type
== P_ENUM
) {
2046 parm_table
[parmIndex
].enum_list
[enumIndex
].name
;
2050 enumIndex
? "|" : "",
2051 parm_table
[parmIndex
].enum_list
[enumIndex
].name
);
2056 for (flagIndex
=0; flag_names
[flagIndex
]; flagIndex
++) {
2057 if (parm_table
[parmIndex
].flags
& flags
[flagIndex
]) {
2060 flag_names
[flagIndex
]);
2065 /* output synonyms */
2067 for (parmIndex2
=0; parm_table
[parmIndex2
].label
; parmIndex2
++) {
2068 if (is_synonym_of(parmIndex
, parmIndex2
, &inverse
)) {
2069 printf(" (%ssynonym of %s)", inverse
? "inverse " : "",
2070 parm_table
[parmIndex2
].label
);
2071 } else if (is_synonym_of(parmIndex2
, parmIndex
, &inverse
)) {
2073 printf(" (synonyms: ");
2078 printf("%s%s", parm_table
[parmIndex2
].label
,
2079 inverse
? "[i]" : "");
2089 /***************************************************************************
2090 Show all parameter's name, type, [values,] and flags.
2091 ***************************************************************************/
2093 void show_parameter_list(void)
2095 int classIndex
, parmIndex
;
2096 const char *section_names
[] = { "local", "global", NULL
};
2098 for (classIndex
=0; section_names
[classIndex
]; classIndex
++) {
2099 printf("[%s]\n", section_names
[classIndex
]);
2100 for (parmIndex
= 0; parm_table
[parmIndex
].label
; parmIndex
++) {
2101 if (parm_table
[parmIndex
].p_class
== classIndex
) {
2102 show_parameter(parmIndex
);
2108 /***************************************************************************
2109 Check if a given string correctly represents a boolean value.
2110 ***************************************************************************/
2112 bool lp_string_is_valid_boolean(const char *parm_value
)
2114 return set_boolean(parm_value
, NULL
);
2117 /***************************************************************************
2118 Get the standard string representation of a boolean value ("yes" or "no")
2119 ***************************************************************************/
2121 static const char *get_boolean(bool bool_value
)
2123 static const char *yes_str
= "yes";
2124 static const char *no_str
= "no";
2126 return (bool_value
? yes_str
: no_str
);
2129 /***************************************************************************
2130 Provide the string of the negated boolean value associated to the boolean
2131 given as a string. Returns false if the passed string does not correctly
2132 represent a boolean.
2133 ***************************************************************************/
2135 bool lp_invert_boolean(const char *str
, const char **inverse_str
)
2139 if (!set_boolean(str
, &val
)) {
2143 *inverse_str
= get_boolean(!val
);
2147 /***************************************************************************
2148 Provide the canonical string representation of a boolean value given
2149 as a string. Return true on success, false if the string given does
2150 not correctly represent a boolean.
2151 ***************************************************************************/
2153 bool lp_canonicalize_boolean(const char *str
, const char**canon_str
)
2157 if (!set_boolean(str
, &val
)) {
2161 *canon_str
= get_boolean(val
);
2165 /***************************************************************************
2166 Find a service by name. Otherwise works like get_service.
2167 ***************************************************************************/
2169 static int getservicebyname(const char *pszServiceName
, struct loadparm_service
*pserviceDest
)
2176 if (ServiceHash
== NULL
) {
2180 canon_name
= canonicalize_servicename(talloc_tos(), pszServiceName
);
2182 status
= dbwrap_fetch_bystring(ServiceHash
, canon_name
, canon_name
,
2185 if (NT_STATUS_IS_OK(status
) &&
2186 (data
.dptr
!= NULL
) &&
2187 (data
.dsize
== sizeof(iService
)))
2189 iService
= *(int *)data
.dptr
;
2192 TALLOC_FREE(canon_name
);
2194 if ((iService
!= -1) && (LP_SNUM_OK(iService
))
2195 && (pserviceDest
!= NULL
)) {
2196 copy_service(pserviceDest
, ServicePtrs
[iService
], NULL
);
2202 /* Return a pointer to a service by name. Unlike getservicebyname, it does not copy the service */
2203 struct loadparm_service
*lp_service(const char *pszServiceName
)
2205 int iService
= getservicebyname(pszServiceName
, NULL
);
2206 if (iService
== -1 || !LP_SNUM_OK(iService
)) {
2209 return ServicePtrs
[iService
];
2212 struct loadparm_service
*lp_servicebynum(int snum
)
2214 if ((snum
== -1) || !LP_SNUM_OK(snum
)) {
2217 return ServicePtrs
[snum
];
2220 struct loadparm_service
*lp_default_loadparm_service()
2226 /***************************************************************************
2227 Copy a service structure to another.
2228 If pcopymapDest is NULL then copy all fields
2229 ***************************************************************************/
2232 * Add a parametric option to a parmlist_entry,
2233 * replacing old value, if already present.
2235 static void set_param_opt(struct parmlist_entry
**opt_list
,
2236 const char *opt_name
,
2237 const char *opt_value
,
2240 struct parmlist_entry
*new_opt
, *opt
;
2246 /* Traverse destination */
2248 /* If we already have same option, override it */
2249 if (strwicmp(opt
->key
, opt_name
) == 0) {
2250 if ((opt
->priority
& FLAG_CMDLINE
) &&
2251 !(priority
& FLAG_CMDLINE
)) {
2252 /* it's been marked as not to be
2256 string_free(&opt
->value
);
2257 TALLOC_FREE(opt
->list
);
2258 opt
->value
= SMB_STRDUP(opt_value
);
2259 opt
->priority
= priority
;
2266 new_opt
= SMB_XMALLOC_P(struct parmlist_entry
);
2267 new_opt
->key
= SMB_STRDUP(opt_name
);
2268 new_opt
->value
= SMB_STRDUP(opt_value
);
2269 new_opt
->list
= NULL
;
2270 new_opt
->priority
= priority
;
2271 DLIST_ADD(*opt_list
, new_opt
);
2275 static void copy_service(struct loadparm_service
*pserviceDest
, struct loadparm_service
*pserviceSource
,
2276 struct bitmap
*pcopymapDest
)
2279 bool bcopyall
= (pcopymapDest
== NULL
);
2280 struct parmlist_entry
*data
;
2282 for (i
= 0; parm_table
[i
].label
; i
++)
2283 if (parm_table
[i
].p_class
== P_LOCAL
&&
2284 (bcopyall
|| bitmap_query(pcopymapDest
,i
))) {
2285 void *src_ptr
= lp_parm_ptr(pserviceSource
, &parm_table
[i
]);
2286 void *dest_ptr
= lp_parm_ptr(pserviceDest
, &parm_table
[i
]);
2288 switch (parm_table
[i
].type
) {
2291 *(bool *)dest_ptr
= *(bool *)src_ptr
;
2298 *(int *)dest_ptr
= *(int *)src_ptr
;
2302 *(char *)dest_ptr
= *(char *)src_ptr
;
2306 string_set((char **)dest_ptr
,
2312 char *upper_string
= strupper_talloc(talloc_tos(),
2314 string_set((char **)dest_ptr
,
2316 TALLOC_FREE(upper_string
);
2320 TALLOC_FREE(*((char ***)dest_ptr
));
2321 *((char ***)dest_ptr
) = str_list_copy(NULL
,
2322 *(const char ***)src_ptr
);
2330 init_copymap(pserviceDest
);
2331 if (pserviceSource
->copymap
)
2332 bitmap_copy(pserviceDest
->copymap
,
2333 pserviceSource
->copymap
);
2336 data
= pserviceSource
->param_opt
;
2338 set_param_opt(&pserviceDest
->param_opt
, data
->key
, data
->value
, data
->priority
);
2343 /***************************************************************************
2344 Check a service for consistency. Return false if the service is in any way
2345 incomplete or faulty, else true.
2346 ***************************************************************************/
2348 bool service_ok(int iService
)
2353 if (ServicePtrs
[iService
]->szService
[0] == '\0') {
2354 DEBUG(0, ("The following message indicates an internal error:\n"));
2355 DEBUG(0, ("No service name in service entry.\n"));
2359 /* The [printers] entry MUST be printable. I'm all for flexibility, but */
2360 /* I can't see why you'd want a non-printable printer service... */
2361 if (strwicmp(ServicePtrs
[iService
]->szService
, PRINTERS_NAME
) == 0) {
2362 if (!ServicePtrs
[iService
]->bPrint_ok
) {
2363 DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
2364 ServicePtrs
[iService
]->szService
));
2365 ServicePtrs
[iService
]->bPrint_ok
= true;
2367 /* [printers] service must also be non-browsable. */
2368 if (ServicePtrs
[iService
]->bBrowseable
)
2369 ServicePtrs
[iService
]->bBrowseable
= false;
2372 if (ServicePtrs
[iService
]->szPath
[0] == '\0' &&
2373 strwicmp(ServicePtrs
[iService
]->szService
, HOMES_NAME
) != 0 &&
2374 ServicePtrs
[iService
]->szMSDfsProxy
[0] == '\0'
2376 DEBUG(0, ("WARNING: No path in service %s - making it unavailable!\n",
2377 ServicePtrs
[iService
]->szService
));
2378 ServicePtrs
[iService
]->bAvailable
= false;
2381 /* If a service is flagged unavailable, log the fact at level 1. */
2382 if (!ServicePtrs
[iService
]->bAvailable
)
2383 DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
2384 ServicePtrs
[iService
]->szService
));
2389 static struct smbconf_ctx
*lp_smbconf_ctx(void)
2392 static struct smbconf_ctx
*conf_ctx
= NULL
;
2394 if (conf_ctx
== NULL
) {
2395 err
= smbconf_init(NULL
, &conf_ctx
, "registry:");
2396 if (!SBC_ERROR_IS_OK(err
)) {
2397 DEBUG(1, ("error initializing registry configuration: "
2398 "%s\n", sbcErrorString(err
)));
2406 static bool process_smbconf_service(struct smbconf_service
*service
)
2411 if (service
== NULL
) {
2415 ret
= do_section(service
->name
, NULL
);
2419 for (count
= 0; count
< service
->num_params
; count
++) {
2420 ret
= do_parameter(service
->param_names
[count
],
2421 service
->param_values
[count
],
2427 if (iServiceIndex
>= 0) {
2428 return service_ok(iServiceIndex
);
2434 * load a service from registry and activate it
2436 bool process_registry_service(const char *service_name
)
2439 struct smbconf_service
*service
= NULL
;
2440 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
2441 struct smbconf_ctx
*conf_ctx
= lp_smbconf_ctx();
2444 if (conf_ctx
== NULL
) {
2448 DEBUG(5, ("process_registry_service: service name %s\n", service_name
));
2450 if (!smbconf_share_exists(conf_ctx
, service_name
)) {
2452 * Registry does not contain data for this service (yet),
2453 * but make sure lp_load doesn't return false.
2459 err
= smbconf_get_share(conf_ctx
, mem_ctx
, service_name
, &service
);
2460 if (!SBC_ERROR_IS_OK(err
)) {
2464 ret
= process_smbconf_service(service
);
2470 smbconf_changed(conf_ctx
, &conf_last_csn
, NULL
, NULL
);
2473 TALLOC_FREE(mem_ctx
);
2478 * process_registry_globals
2480 static bool process_registry_globals(void)
2484 add_to_file_list(INCLUDE_REGISTRY_NAME
, INCLUDE_REGISTRY_NAME
);
2486 ret
= do_parameter("registry shares", "yes", NULL
);
2491 return process_registry_service(GLOBAL_NAME
);
2494 bool process_registry_shares(void)
2498 struct smbconf_service
**service
= NULL
;
2499 uint32_t num_shares
= 0;
2500 TALLOC_CTX
*mem_ctx
= talloc_stackframe();
2501 struct smbconf_ctx
*conf_ctx
= lp_smbconf_ctx();
2504 if (conf_ctx
== NULL
) {
2508 err
= smbconf_get_config(conf_ctx
, mem_ctx
, &num_shares
, &service
);
2509 if (!SBC_ERROR_IS_OK(err
)) {
2515 for (count
= 0; count
< num_shares
; count
++) {
2516 if (strequal(service
[count
]->name
, GLOBAL_NAME
)) {
2519 ret
= process_smbconf_service(service
[count
]);
2526 smbconf_changed(conf_ctx
, &conf_last_csn
, NULL
, NULL
);
2529 TALLOC_FREE(mem_ctx
);
2534 * reload those shares from registry that are already
2535 * activated in the services array.
2537 static bool reload_registry_shares(void)
2542 for (i
= 0; i
< iNumServices
; i
++) {
2547 if (ServicePtrs
[i
]->usershare
== USERSHARE_VALID
) {
2551 ret
= process_registry_service(ServicePtrs
[i
]->szService
);
2562 #define MAX_INCLUDE_DEPTH 100
2564 static uint8_t include_depth
;
2566 static struct file_lists
{
2567 struct file_lists
*next
;
2571 } *file_lists
= NULL
;
2573 /*******************************************************************
2574 Keep a linked list of all config files so we know when one has changed
2575 it's date and needs to be reloaded.
2576 ********************************************************************/
2578 static void add_to_file_list(const char *fname
, const char *subfname
)
2580 struct file_lists
*f
= file_lists
;
2583 if (f
->name
&& !strcmp(f
->name
, fname
))
2589 f
= SMB_MALLOC_P(struct file_lists
);
2592 f
->next
= file_lists
;
2593 f
->name
= SMB_STRDUP(fname
);
2598 f
->subfname
= SMB_STRDUP(subfname
);
2605 f
->modtime
= file_modtime(subfname
);
2607 time_t t
= file_modtime(subfname
);
2615 * Free the file lists
2617 static void free_file_list(void)
2619 struct file_lists
*f
;
2620 struct file_lists
*next
;
2625 SAFE_FREE( f
->name
);
2626 SAFE_FREE( f
->subfname
);
2635 * Utility function for outsiders to check if we're running on registry.
2637 bool lp_config_backend_is_registry(void)
2639 return (lp_config_backend() == CONFIG_BACKEND_REGISTRY
);
2643 * Utility function to check if the config backend is FILE.
2645 bool lp_config_backend_is_file(void)
2647 return (lp_config_backend() == CONFIG_BACKEND_FILE
);
2650 /*******************************************************************
2651 Check if a config file has changed date.
2652 ********************************************************************/
2654 bool lp_file_list_changed(void)
2656 struct file_lists
*f
= file_lists
;
2658 DEBUG(6, ("lp_file_list_changed()\n"));
2663 if (strequal(f
->name
, INCLUDE_REGISTRY_NAME
)) {
2664 struct smbconf_ctx
*conf_ctx
= lp_smbconf_ctx();
2666 if (conf_ctx
== NULL
) {
2669 if (smbconf_changed(conf_ctx
, &conf_last_csn
, NULL
,
2672 DEBUGADD(6, ("registry config changed\n"));
2677 n2
= talloc_sub_basic(talloc_tos(),
2678 get_current_username(),
2679 current_user_info
.domain
,
2684 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
2685 f
->name
, n2
, ctime(&f
->modtime
)));
2687 mod_time
= file_modtime(n2
);
2690 ((f
->modtime
!= mod_time
) ||
2691 (f
->subfname
== NULL
) ||
2692 (strcmp(n2
, f
->subfname
) != 0)))
2695 ("file %s modified: %s\n", n2
,
2697 f
->modtime
= mod_time
;
2698 SAFE_FREE(f
->subfname
);
2699 f
->subfname
= SMB_STRDUP(n2
);
2712 * Initialize iconv conversion descriptors.
2714 * This is called the first time it is needed, and also called again
2715 * every time the configuration is reloaded, because the charset or
2716 * codepage might have changed.
2718 static void init_iconv(void)
2720 global_iconv_handle
= smb_iconv_handle_reinit(NULL
, lp_dos_charset(),
2722 true, global_iconv_handle
);
2725 static bool handle_charset(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
2727 if (strcmp(*ptr
, pszParmValue
) != 0) {
2728 string_set(ptr
, pszParmValue
);
2734 static bool handle_dos_charset(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
2736 bool is_utf8
= false;
2737 size_t len
= strlen(pszParmValue
);
2739 if (len
== 4 || len
== 5) {
2740 /* Don't use StrCaseCmp here as we don't want to
2741 initialize iconv. */
2742 if ((toupper_m(pszParmValue
[0]) == 'U') &&
2743 (toupper_m(pszParmValue
[1]) == 'T') &&
2744 (toupper_m(pszParmValue
[2]) == 'F')) {
2746 if (pszParmValue
[3] == '8') {
2750 if (pszParmValue
[3] == '-' &&
2751 pszParmValue
[4] == '8') {
2758 if (strcmp(*ptr
, pszParmValue
) != 0) {
2760 DEBUG(0,("ERROR: invalid DOS charset: 'dos charset' must not "
2761 "be UTF8, using (default value) %s instead.\n",
2762 DEFAULT_DOS_CHARSET
));
2763 pszParmValue
= DEFAULT_DOS_CHARSET
;
2765 string_set(ptr
, pszParmValue
);
2771 static bool handle_realm(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
2774 TALLOC_CTX
*frame
= talloc_stackframe();
2775 char *realm
= strupper_talloc(frame
, pszParmValue
);
2776 char *dnsdomain
= strlower_talloc(realm
, pszParmValue
);
2778 ret
&= string_set(&Globals
.szRealm
, pszParmValue
);
2779 ret
&= string_set(&Globals
.szRealm_upper
, realm
);
2780 ret
&= string_set(&Globals
.szRealm_lower
, dnsdomain
);
2786 static bool handle_netbios_aliases(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
2788 TALLOC_FREE(Globals
.szNetbiosAliases
);
2789 Globals
.szNetbiosAliases
= (const char **)str_list_make_v3(NULL
, pszParmValue
, NULL
);
2790 return set_netbios_aliases(Globals
.szNetbiosAliases
);
2793 /***************************************************************************
2794 Handle the include operation.
2795 ***************************************************************************/
2796 static bool bAllowIncludeRegistry
= true;
2798 static bool handle_include(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
2802 if (include_depth
>= MAX_INCLUDE_DEPTH
) {
2803 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
2808 if (strequal(pszParmValue
, INCLUDE_REGISTRY_NAME
)) {
2809 if (!bAllowIncludeRegistry
) {
2812 if (bInGlobalSection
) {
2815 ret
= process_registry_globals();
2819 DEBUG(1, ("\"include = registry\" only effective "
2820 "in %s section\n", GLOBAL_NAME
));
2825 fname
= talloc_sub_basic(talloc_tos(), get_current_username(),
2826 current_user_info
.domain
,
2829 add_to_file_list(pszParmValue
, fname
);
2831 string_set(ptr
, fname
);
2833 if (file_exist(fname
)) {
2836 ret
= pm_process(fname
, do_section
, do_parameter
, NULL
);
2842 DEBUG(2, ("Can't find include file %s\n", fname
));
2847 /***************************************************************************
2848 Handle the interpretation of the copy parameter.
2849 ***************************************************************************/
2851 static bool handle_copy(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
2855 struct loadparm_service serviceTemp
;
2857 string_set(ptr
, pszParmValue
);
2859 init_service(&serviceTemp
);
2863 DEBUG(3, ("Copying service from service %s\n", pszParmValue
));
2865 if ((iTemp
= getservicebyname(pszParmValue
, &serviceTemp
)) >= 0) {
2866 if (iTemp
== iServiceIndex
) {
2867 DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue
));
2869 copy_service(ServicePtrs
[iServiceIndex
],
2871 ServicePtrs
[iServiceIndex
]->copymap
);
2875 DEBUG(0, ("Unable to copy service - source not found: %s\n", pszParmValue
));
2879 free_service(&serviceTemp
);
2883 static bool handle_ldap_debug_level(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
2885 Globals
.ldap_debug_level
= lp_int(pszParmValue
);
2886 init_ldap_debugging();
2891 * idmap related parameters
2894 static bool handle_idmap_backend(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
2896 lp_do_parameter(snum
, "idmap config * : backend", pszParmValue
);
2901 static bool handle_idmap_uid(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
2903 lp_do_parameter(snum
, "idmap config * : range", pszParmValue
);
2908 static bool handle_idmap_gid(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
2910 lp_do_parameter(snum
, "idmap config * : range", pszParmValue
);
2915 bool lp_idmap_range(const char *domain_name
, uint32_t *low
, uint32_t *high
)
2917 char *config_option
= NULL
;
2918 const char *range
= NULL
;
2921 SMB_ASSERT(low
!= NULL
);
2922 SMB_ASSERT(high
!= NULL
);
2924 if ((domain_name
== NULL
) || (domain_name
[0] == '\0')) {
2928 config_option
= talloc_asprintf(talloc_tos(), "idmap config %s",
2930 if (config_option
== NULL
) {
2931 DEBUG(0, ("out of memory\n"));
2935 range
= lp_parm_const_string(-1, config_option
, "range", NULL
);
2936 if (range
== NULL
) {
2937 DEBUG(1, ("idmap range not specified for domain '%s'\n", domain_name
));
2941 if (sscanf(range
, "%u - %u", low
, high
) != 2) {
2942 DEBUG(1, ("error parsing idmap range '%s' for domain '%s'\n",
2943 range
, domain_name
));
2950 talloc_free(config_option
);
2955 bool lp_idmap_default_range(uint32_t *low
, uint32_t *high
)
2957 return lp_idmap_range("*", low
, high
);
2960 const char *lp_idmap_backend(const char *domain_name
)
2962 char *config_option
= NULL
;
2963 const char *backend
= NULL
;
2965 if ((domain_name
== NULL
) || (domain_name
[0] == '\0')) {
2969 config_option
= talloc_asprintf(talloc_tos(), "idmap config %s",
2971 if (config_option
== NULL
) {
2972 DEBUG(0, ("out of memory\n"));
2976 backend
= lp_parm_const_string(-1, config_option
, "backend", NULL
);
2977 if (backend
== NULL
) {
2978 DEBUG(1, ("idmap backend not specified for domain '%s'\n", domain_name
));
2983 talloc_free(config_option
);
2987 const char *lp_idmap_default_backend(void)
2989 return lp_idmap_backend("*");
2992 /***************************************************************************
2993 Handle the DEBUG level list.
2994 ***************************************************************************/
2996 static bool handle_debug_list(struct loadparm_context
*unused
, int snum
, const char *pszParmValueIn
, char **ptr
)
2998 string_set(ptr
, pszParmValueIn
);
2999 return debug_parse_levels(pszParmValueIn
);
3002 /***************************************************************************
3003 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
3004 ***************************************************************************/
3006 static const char *append_ldap_suffix(TALLOC_CTX
*ctx
, const char *str
)
3008 const char *suffix_string
;
3010 suffix_string
= talloc_asprintf(ctx
, "%s,%s", str
,
3011 Globals
.szLdapSuffix
);
3012 if ( !suffix_string
) {
3013 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
3017 return suffix_string
;
3020 const char *lp_ldap_machine_suffix(TALLOC_CTX
*ctx
)
3022 if (Globals
.szLdapMachineSuffix
[0])
3023 return append_ldap_suffix(ctx
, Globals
.szLdapMachineSuffix
);
3025 return lp_string(ctx
, Globals
.szLdapSuffix
);
3028 const char *lp_ldap_user_suffix(TALLOC_CTX
*ctx
)
3030 if (Globals
.szLdapUserSuffix
[0])
3031 return append_ldap_suffix(ctx
, Globals
.szLdapUserSuffix
);
3033 return lp_string(ctx
, Globals
.szLdapSuffix
);
3036 const char *lp_ldap_group_suffix(TALLOC_CTX
*ctx
)
3038 if (Globals
.szLdapGroupSuffix
[0])
3039 return append_ldap_suffix(ctx
, Globals
.szLdapGroupSuffix
);
3041 return lp_string(ctx
, Globals
.szLdapSuffix
);
3044 const char *lp_ldap_idmap_suffix(TALLOC_CTX
*ctx
)
3046 if (Globals
.szLdapIdmapSuffix
[0])
3047 return append_ldap_suffix(ctx
, Globals
.szLdapIdmapSuffix
);
3049 return lp_string(ctx
, Globals
.szLdapSuffix
);
3052 /****************************************************************************
3053 set the value for a P_ENUM
3054 ***************************************************************************/
3056 static void lp_set_enum_parm( struct parm_struct
*parm
, const char *pszParmValue
,
3061 for (i
= 0; parm
->enum_list
[i
].name
; i
++) {
3062 if ( strequal(pszParmValue
, parm
->enum_list
[i
].name
)) {
3063 *ptr
= parm
->enum_list
[i
].value
;
3067 DEBUG(0, ("WARNING: Ignoring invalid value '%s' for parameter '%s'\n",
3068 pszParmValue
, parm
->label
));
3071 /***************************************************************************
3072 ***************************************************************************/
3074 static bool handle_printing(struct loadparm_context
*unused
, int snum
, const char *pszParmValue
, char **ptr
)
3076 static int parm_num
= -1;
3077 struct loadparm_service
*s
;
3079 if ( parm_num
== -1 )
3080 parm_num
= map_parameter( "printing" );
3082 lp_set_enum_parm( &parm_table
[parm_num
], pszParmValue
, (int*)ptr
);
3087 s
= ServicePtrs
[snum
];
3089 init_printer_values( s
);
3095 /***************************************************************************
3096 Initialise a copymap.
3097 ***************************************************************************/
3099 static void init_copymap(struct loadparm_service
*pservice
)
3103 TALLOC_FREE(pservice
->copymap
);
3105 pservice
->copymap
= bitmap_talloc(NULL
, NUMPARAMETERS
);
3106 if (!pservice
->copymap
)
3108 ("Couldn't allocate copymap!! (size %d)\n",
3109 (int)NUMPARAMETERS
));
3111 for (i
= 0; i
< NUMPARAMETERS
; i
++)
3112 bitmap_set(pservice
->copymap
, i
);
3116 return the parameter pointer for a parameter
3118 void *lp_parm_ptr(struct loadparm_service
*service
, struct parm_struct
*parm
)
3120 if (service
== NULL
) {
3121 if (parm
->p_class
== P_LOCAL
)
3122 return (void *)(((char *)&sDefault
)+parm
->offset
);
3123 else if (parm
->p_class
== P_GLOBAL
)
3124 return (void *)(((char *)&Globals
)+parm
->offset
);
3127 return (void *)(((char *)service
) + parm
->offset
);
3131 /***************************************************************************
3132 Return the local pointer to a parameter given the service number and parameter
3133 ***************************************************************************/
3135 void *lp_local_ptr_by_snum(int snum
, struct parm_struct
*parm
)
3137 return lp_parm_ptr(ServicePtrs
[snum
], parm
);
3140 /***************************************************************************
3141 Process a parameter for a particular service number. If snum < 0
3142 then assume we are in the globals.
3143 ***************************************************************************/
3145 bool lp_do_parameter(int snum
, const char *pszParmName
, const char *pszParmValue
)
3148 void *parm_ptr
= NULL
; /* where we are going to store the result */
3149 struct parmlist_entry
**opt_list
;
3151 parmnum
= map_parameter(pszParmName
);
3154 if (strchr(pszParmName
, ':') == NULL
) {
3155 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n",
3161 * We've got a parametric option
3164 opt_list
= (snum
< 0)
3165 ? &Globals
.param_opt
: &ServicePtrs
[snum
]->param_opt
;
3166 set_param_opt(opt_list
, pszParmName
, pszParmValue
, 0);
3171 /* if it's already been set by the command line, then we don't
3173 if (parm_table
[parmnum
].flags
& FLAG_CMDLINE
) {
3177 if (parm_table
[parmnum
].flags
& FLAG_DEPRECATED
) {
3178 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
3182 /* we might point at a service, the default service or a global */
3184 parm_ptr
= lp_parm_ptr(NULL
, &parm_table
[parmnum
]);
3186 if (parm_table
[parmnum
].p_class
== P_GLOBAL
) {
3188 ("Global parameter %s found in service section!\n",
3192 parm_ptr
= lp_local_ptr_by_snum(snum
, &parm_table
[parmnum
]);
3196 if (!ServicePtrs
[snum
]->copymap
)
3197 init_copymap(ServicePtrs
[snum
]);
3199 /* this handles the aliases - set the copymap for other entries with
3200 the same data pointer */
3201 for (i
= 0; parm_table
[i
].label
; i
++) {
3202 if ((parm_table
[i
].offset
== parm_table
[parmnum
].offset
)
3203 && (parm_table
[i
].p_class
== parm_table
[parmnum
].p_class
)) {
3204 bitmap_clear(ServicePtrs
[snum
]->copymap
, i
);
3209 /* if it is a special case then go ahead */
3210 if (parm_table
[parmnum
].special
) {
3211 return parm_table
[parmnum
].special(NULL
, snum
, pszParmValue
,
3215 /* now switch on the type of variable it is */
3216 switch (parm_table
[parmnum
].type
)
3219 *(bool *)parm_ptr
= lp_bool(pszParmValue
);
3223 *(bool *)parm_ptr
= !lp_bool(pszParmValue
);
3227 *(int *)parm_ptr
= lp_int(pszParmValue
);
3231 *(char *)parm_ptr
= *pszParmValue
;
3235 i
= sscanf(pszParmValue
, "%o", (int *)parm_ptr
);
3237 DEBUG ( 0, ("Invalid octal number %s\n", pszParmName
));
3244 if (conv_str_size_error(pszParmValue
, &val
)) {
3245 if (val
<= INT_MAX
) {
3246 *(int *)parm_ptr
= (int)val
;
3251 DEBUG(0,("lp_do_parameter(%s): value is not "
3252 "a valid size specifier!\n", pszParmValue
));
3258 TALLOC_FREE(*((char ***)parm_ptr
));
3259 *(char ***)parm_ptr
= str_list_make_v3(
3260 NULL
, pszParmValue
, NULL
);
3264 string_set((char **)parm_ptr
, pszParmValue
);
3269 char *upper_string
= strupper_talloc(talloc_tos(),
3271 string_set((char **)parm_ptr
, upper_string
);
3272 TALLOC_FREE(upper_string
);
3276 lp_set_enum_parm( &parm_table
[parmnum
], pszParmValue
, (int*)parm_ptr
);
3285 /***************************************************************************
3286 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
3287 FLAG_CMDLINE won't be overridden by loads from smb.conf.
3288 ***************************************************************************/
3290 static bool lp_set_cmdline_helper(const char *pszParmName
, const char *pszParmValue
, bool store_values
)
3293 parmnum
= map_parameter(pszParmName
);
3295 parm_table
[parmnum
].flags
&= ~FLAG_CMDLINE
;
3296 if (!lp_do_parameter(-1, pszParmName
, pszParmValue
)) {
3299 parm_table
[parmnum
].flags
|= FLAG_CMDLINE
;
3301 /* we have to also set FLAG_CMDLINE on aliases. Aliases must
3302 * be grouped in the table, so we don't have to search the
3305 i
>=0 && parm_table
[i
].offset
== parm_table
[parmnum
].offset
3306 && parm_table
[i
].p_class
== parm_table
[parmnum
].p_class
;
3308 parm_table
[i
].flags
|= FLAG_CMDLINE
;
3310 for (i
=parmnum
+1;i
<NUMPARAMETERS
&& parm_table
[i
].offset
== parm_table
[parmnum
].offset
3311 && parm_table
[i
].p_class
== parm_table
[parmnum
].p_class
;i
++) {
3312 parm_table
[i
].flags
|= FLAG_CMDLINE
;
3316 store_lp_set_cmdline(pszParmName
, pszParmValue
);
3321 /* it might be parametric */
3322 if (strchr(pszParmName
, ':') != NULL
) {
3323 set_param_opt(&Globals
.param_opt
, pszParmName
, pszParmValue
, FLAG_CMDLINE
);
3325 store_lp_set_cmdline(pszParmName
, pszParmValue
);
3330 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName
));
3334 bool lp_set_cmdline(const char *pszParmName
, const char *pszParmValue
)
3336 return lp_set_cmdline_helper(pszParmName
, pszParmValue
, true);
3339 /***************************************************************************
3340 Process a parameter.
3341 ***************************************************************************/
3343 static bool do_parameter(const char *pszParmName
, const char *pszParmValue
,
3346 if (!bInGlobalSection
&& bGlobalOnly
)
3349 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName
, pszParmValue
));
3351 return (lp_do_parameter(bInGlobalSection
? -2 : iServiceIndex
,
3352 pszParmName
, pszParmValue
));
3356 set a option from the commandline in 'a=b' format. Use to support --option
3358 bool lp_set_option(const char *option
)
3363 s
= talloc_strdup(NULL
, option
);
3376 /* skip white spaces after the = sign */
3379 } while (*p
== ' ');
3381 ret
= lp_set_cmdline(s
, p
);
3386 /**************************************************************************
3387 Print a parameter of the specified type.
3388 ***************************************************************************/
3390 static void print_parameter(struct parm_struct
*p
, void *ptr
, FILE * f
)
3392 /* For the seperation of lists values that we print below */
3393 const char *list_sep
= ", ";
3398 for (i
= 0; p
->enum_list
[i
].name
; i
++) {
3399 if (*(int *)ptr
== p
->enum_list
[i
].value
) {
3401 p
->enum_list
[i
].name
);
3408 fprintf(f
, "%s", BOOLSTR(*(bool *)ptr
));
3412 fprintf(f
, "%s", BOOLSTR(!*(bool *)ptr
));
3417 fprintf(f
, "%d", *(int *)ptr
);
3421 fprintf(f
, "%c", *(char *)ptr
);
3425 int val
= *(int *)ptr
;
3429 fprintf(f
, "0%o", val
);
3438 if ((char ***)ptr
&& *(char ***)ptr
) {
3439 char **list
= *(char ***)ptr
;
3440 for (; *list
; list
++) {
3441 /* surround strings with whitespace in double quotes */
3442 if (*(list
+1) == NULL
) {
3443 /* last item, no extra separator */
3446 if ( strchr_m( *list
, ' ' ) ) {
3447 fprintf(f
, "\"%s\"%s", *list
, list_sep
);
3449 fprintf(f
, "%s%s", *list
, list_sep
);
3457 if (*(char **)ptr
) {
3458 fprintf(f
, "%s", *(char **)ptr
);
3466 /***************************************************************************
3467 Check if two parameters are equal.
3468 ***************************************************************************/
3470 static bool equal_parameter(parm_type type
, void *ptr1
, void *ptr2
)
3475 return (*((bool *)ptr1
) == *((bool *)ptr2
));
3481 return (*((int *)ptr1
) == *((int *)ptr2
));
3484 return (*((char *)ptr1
) == *((char *)ptr2
));
3488 return str_list_equal(*(const char ***)ptr1
, *(const char ***)ptr2
);
3493 char *p1
= *(char **)ptr1
, *p2
= *(char **)ptr2
;
3498 return (p1
== p2
|| strequal(p1
, p2
));
3506 /***************************************************************************
3507 Initialize any local variables in the sDefault table, after parsing a
3509 ***************************************************************************/
3511 static void init_locals(void)
3514 * We run this check once the [globals] is parsed, to force
3515 * the VFS objects and other per-share settings we need for
3516 * the standard way a AD DC is operated. We may change these
3517 * as our code evolves, which is why we force these settings.
3519 * We can't do this at the end of lp_load_ex(), as by that
3520 * point the services have been loaded and they will already
3521 * have "" as their vfs objects.
3523 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
) {
3524 const char **vfs_objects
= lp_vfs_objects(-1);
3525 if (!vfs_objects
|| !vfs_objects
[0]) {
3526 if (lp_parm_const_string(-1, "xattr_tdb", "file", NULL
)) {
3527 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr xattr_tdb");
3528 } else if (lp_parm_const_string(-1, "posix", "eadb", NULL
)) {
3529 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr posix_eadb");
3531 lp_do_parameter(-1, "vfs objects", "dfs_samba4 acl_xattr");
3535 lp_do_parameter(-1, "map hidden", "no");
3536 lp_do_parameter(-1, "map system", "no");
3537 lp_do_parameter(-1, "map readonly", "no");
3538 lp_do_parameter(-1, "map archive", "no");
3539 lp_do_parameter(-1, "store dos attributes", "yes");
3543 /***************************************************************************
3544 Process a new section (service). At this stage all sections are services.
3545 Later we'll have special sections that permit server parameters to be set.
3546 Returns true on success, false on failure.
3547 ***************************************************************************/
3549 static bool do_section(const char *pszSectionName
, void *userdata
)
3552 bool isglobal
= ((strwicmp(pszSectionName
, GLOBAL_NAME
) == 0) ||
3553 (strwicmp(pszSectionName
, GLOBAL_NAME2
) == 0));
3556 /* if we were in a global section then do the local inits */
3557 if (bInGlobalSection
&& !isglobal
)
3560 /* if we've just struck a global section, note the fact. */
3561 bInGlobalSection
= isglobal
;
3563 /* check for multiple global sections */
3564 if (bInGlobalSection
) {
3565 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName
));
3569 if (!bInGlobalSection
&& bGlobalOnly
)
3572 /* if we have a current service, tidy it up before moving on */
3575 if (iServiceIndex
>= 0)
3576 bRetval
= service_ok(iServiceIndex
);
3578 /* if all is still well, move to the next record in the services array */
3580 /* We put this here to avoid an odd message order if messages are */
3581 /* issued by the post-processing of a previous section. */
3582 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName
));
3584 iServiceIndex
= add_a_service(&sDefault
, pszSectionName
);
3585 if (iServiceIndex
< 0) {
3586 DEBUG(0, ("Failed to add a new service\n"));
3589 /* Clean all parametric options for service */
3590 /* They will be added during parsing again */
3591 free_param_opts(&ServicePtrs
[iServiceIndex
]->param_opt
);
3598 /***************************************************************************
3599 Determine if a partcular base parameter is currentl set to the default value.
3600 ***************************************************************************/
3602 static bool is_default(int i
)
3604 if (!defaults_saved
)
3606 switch (parm_table
[i
].type
) {
3609 return str_list_equal((const char **)parm_table
[i
].def
.lvalue
,
3610 *(const char ***)lp_parm_ptr(NULL
,
3614 return strequal(parm_table
[i
].def
.svalue
,
3615 *(char **)lp_parm_ptr(NULL
,
3619 return parm_table
[i
].def
.bvalue
==
3620 *(bool *)lp_parm_ptr(NULL
,
3623 return parm_table
[i
].def
.cvalue
==
3624 *(char *)lp_parm_ptr(NULL
,
3630 return parm_table
[i
].def
.ivalue
==
3631 *(int *)lp_parm_ptr(NULL
,
3639 /***************************************************************************
3640 Display the contents of the global structure.
3641 ***************************************************************************/
3643 static void dump_globals(FILE *f
)
3646 struct parmlist_entry
*data
;
3648 fprintf(f
, "[global]\n");
3650 for (i
= 0; parm_table
[i
].label
; i
++)
3651 if (parm_table
[i
].p_class
== P_GLOBAL
&&
3652 !(parm_table
[i
].flags
& FLAG_META
) &&
3653 (i
== 0 || (parm_table
[i
].offset
!= parm_table
[i
- 1].offset
))) {
3654 if (defaults_saved
&& is_default(i
))
3656 fprintf(f
, "\t%s = ", parm_table
[i
].label
);
3657 print_parameter(&parm_table
[i
], lp_parm_ptr(NULL
,
3662 if (Globals
.param_opt
!= NULL
) {
3663 data
= Globals
.param_opt
;
3665 fprintf(f
, "\t%s = %s\n", data
->key
, data
->value
);
3672 /***************************************************************************
3673 Return true if a local parameter is currently set to the global default.
3674 ***************************************************************************/
3676 bool lp_is_default(int snum
, struct parm_struct
*parm
)
3678 return equal_parameter(parm
->type
,
3679 lp_parm_ptr(ServicePtrs
[snum
], parm
),
3680 lp_parm_ptr(NULL
, parm
));
3683 /***************************************************************************
3684 Display the contents of a single services record.
3685 ***************************************************************************/
3687 static void dump_a_service(struct loadparm_service
*pService
, FILE * f
)
3690 struct parmlist_entry
*data
;
3692 if (pService
!= &sDefault
)
3693 fprintf(f
, "[%s]\n", pService
->szService
);
3695 for (i
= 0; parm_table
[i
].label
; i
++) {
3697 if (parm_table
[i
].p_class
== P_LOCAL
&&
3698 !(parm_table
[i
].flags
& FLAG_META
) &&
3699 (*parm_table
[i
].label
!= '-') &&
3700 (i
== 0 || (parm_table
[i
].offset
!= parm_table
[i
- 1].offset
)))
3702 if (pService
== &sDefault
) {
3703 if (defaults_saved
&& is_default(i
))
3706 if (equal_parameter(parm_table
[i
].type
,
3707 lp_parm_ptr(pService
, &parm_table
[i
]),
3708 lp_parm_ptr(NULL
, &parm_table
[i
])))
3712 fprintf(f
, "\t%s = ", parm_table
[i
].label
);
3713 print_parameter(&parm_table
[i
],
3714 lp_parm_ptr(pService
, &parm_table
[i
]),
3720 if (pService
->param_opt
!= NULL
) {
3721 data
= pService
->param_opt
;
3723 fprintf(f
, "\t%s = %s\n", data
->key
, data
->value
);
3729 /***************************************************************************
3730 Display the contents of a parameter of a single services record.
3731 ***************************************************************************/
3733 bool dump_a_parameter(int snum
, char *parm_name
, FILE * f
, bool isGlobal
)
3736 bool result
= false;
3739 fstring local_parm_name
;
3741 const char *parm_opt_value
;
3743 /* check for parametrical option */
3744 fstrcpy( local_parm_name
, parm_name
);
3745 parm_opt
= strchr( local_parm_name
, ':');
3750 if (strlen(parm_opt
)) {
3751 parm_opt_value
= lp_parm_const_string( snum
,
3752 local_parm_name
, parm_opt
, NULL
);
3753 if (parm_opt_value
) {
3754 printf( "%s\n", parm_opt_value
);
3761 /* check for a key and print the value */
3768 for (i
= 0; parm_table
[i
].label
; i
++) {
3769 if (strwicmp(parm_table
[i
].label
, parm_name
) == 0 &&
3770 !(parm_table
[i
].flags
& FLAG_META
) &&
3771 (parm_table
[i
].p_class
== p_class
|| parm_table
[i
].flags
& flag
) &&
3772 (*parm_table
[i
].label
!= '-') &&
3773 (i
== 0 || (parm_table
[i
].offset
!= parm_table
[i
- 1].offset
)))
3778 ptr
= lp_parm_ptr(NULL
,
3781 ptr
= lp_parm_ptr(ServicePtrs
[snum
],
3785 print_parameter(&parm_table
[i
],
3796 /***************************************************************************
3797 Return info about the requested parameter (given as a string).
3798 Return NULL when the string is not a valid parameter name.
3799 ***************************************************************************/
3801 struct parm_struct
*lp_get_parameter(const char *param_name
)
3803 int num
= map_parameter(param_name
);
3809 return &parm_table
[num
];
3812 /***************************************************************************
3813 Return info about the next parameter in a service.
3814 snum==GLOBAL_SECTION_SNUM gives the globals.
3815 Return NULL when out of parameters.
3816 ***************************************************************************/
3818 struct parm_struct
*lp_next_parameter(int snum
, int *i
, int allparameters
)
3821 /* do the globals */
3822 for (; parm_table
[*i
].label
; (*i
)++) {
3823 if (parm_table
[*i
].p_class
== P_SEPARATOR
)
3824 return &parm_table
[(*i
)++];
3826 if ((*parm_table
[*i
].label
== '-'))
3830 && (parm_table
[*i
].offset
==
3831 parm_table
[(*i
) - 1].offset
)
3832 && (parm_table
[*i
].p_class
==
3833 parm_table
[(*i
) - 1].p_class
))
3836 if (is_default(*i
) && !allparameters
)
3839 return &parm_table
[(*i
)++];
3842 struct loadparm_service
*pService
= ServicePtrs
[snum
];
3844 for (; parm_table
[*i
].label
; (*i
)++) {
3845 if (parm_table
[*i
].p_class
== P_SEPARATOR
)
3846 return &parm_table
[(*i
)++];
3848 if (parm_table
[*i
].p_class
== P_LOCAL
&&
3849 (*parm_table
[*i
].label
!= '-') &&
3851 (parm_table
[*i
].offset
!=
3852 parm_table
[(*i
) - 1].offset
)))
3854 if (allparameters
||
3855 !equal_parameter(parm_table
[*i
].type
,
3856 lp_parm_ptr(pService
,
3861 return &parm_table
[(*i
)++];
3872 /***************************************************************************
3873 Display the contents of a single copy structure.
3874 ***************************************************************************/
3875 static void dump_copy_map(bool *pcopymap
)
3881 printf("\n\tNon-Copied parameters:\n");
3883 for (i
= 0; parm_table
[i
].label
; i
++)
3884 if (parm_table
[i
].p_class
== P_LOCAL
&&
3885 parm_table
[i
].ptr
&& !pcopymap
[i
] &&
3886 (i
== 0 || (parm_table
[i
].ptr
!= parm_table
[i
- 1].ptr
)))
3888 printf("\t\t%s\n", parm_table
[i
].label
);
3893 /***************************************************************************
3894 Return TRUE if the passed service number is within range.
3895 ***************************************************************************/
3897 bool lp_snum_ok(int iService
)
3899 return (LP_SNUM_OK(iService
) && ServicePtrs
[iService
]->bAvailable
);
3902 /***************************************************************************
3903 Auto-load some home services.
3904 ***************************************************************************/
3906 static void lp_add_auto_services(char *str
)
3916 s
= SMB_STRDUP(str
);
3920 homes
= lp_servicenumber(HOMES_NAME
);
3922 for (p
= strtok_r(s
, LIST_SEP
, &saveptr
); p
;
3923 p
= strtok_r(NULL
, LIST_SEP
, &saveptr
)) {
3926 if (lp_servicenumber(p
) >= 0)
3929 home
= get_user_home_dir(talloc_tos(), p
);
3931 if (home
&& home
[0] && homes
>= 0)
3932 lp_add_home(p
, homes
, p
, home
);
3939 /***************************************************************************
3940 Auto-load one printer.
3941 ***************************************************************************/
3943 void lp_add_one_printer(const char *name
, const char *comment
,
3944 const char *location
, void *pdata
)
3946 int printers
= lp_servicenumber(PRINTERS_NAME
);
3949 if (lp_servicenumber(name
) < 0) {
3950 lp_add_printer(name
, printers
);
3951 if ((i
= lp_servicenumber(name
)) >= 0) {
3952 string_set(&ServicePtrs
[i
]->comment
, comment
);
3953 ServicePtrs
[i
]->autoloaded
= true;
3958 /***************************************************************************
3959 Have we loaded a services file yet?
3960 ***************************************************************************/
3962 bool lp_loaded(void)
3967 /***************************************************************************
3968 Unload unused services.
3969 ***************************************************************************/
3971 void lp_killunused(struct smbd_server_connection
*sconn
,
3972 bool (*snumused
) (struct smbd_server_connection
*, int))
3975 for (i
= 0; i
< iNumServices
; i
++) {
3979 /* don't kill autoloaded or usershare services */
3980 if ( ServicePtrs
[i
]->autoloaded
||
3981 ServicePtrs
[i
]->usershare
== USERSHARE_VALID
) {
3985 if (!snumused
|| !snumused(sconn
, i
)) {
3986 free_service_byindex(i
);
3992 * Kill all except autoloaded and usershare services - convenience wrapper
3994 void lp_kill_all_services(void)
3996 lp_killunused(NULL
, NULL
);
3999 /***************************************************************************
4001 ***************************************************************************/
4003 void lp_killservice(int iServiceIn
)
4005 if (VALID(iServiceIn
)) {
4006 free_service_byindex(iServiceIn
);
4010 /***************************************************************************
4011 Save the curent values of all global and sDefault parameters into the
4012 defaults union. This allows testparm to show only the
4013 changed (ie. non-default) parameters.
4014 ***************************************************************************/
4016 static void lp_save_defaults(void)
4019 for (i
= 0; parm_table
[i
].label
; i
++) {
4020 if (i
> 0 && parm_table
[i
].offset
== parm_table
[i
- 1].offset
4021 && parm_table
[i
].p_class
== parm_table
[i
- 1].p_class
)
4023 switch (parm_table
[i
].type
) {
4026 parm_table
[i
].def
.lvalue
= str_list_copy(
4027 NULL
, *(const char ***)lp_parm_ptr(NULL
, &parm_table
[i
]));
4031 parm_table
[i
].def
.svalue
= SMB_STRDUP(*(char **)lp_parm_ptr(NULL
, &parm_table
[i
]));
4035 parm_table
[i
].def
.bvalue
=
4036 *(bool *)lp_parm_ptr(NULL
, &parm_table
[i
]);
4039 parm_table
[i
].def
.cvalue
=
4040 *(char *)lp_parm_ptr(NULL
, &parm_table
[i
]);
4046 parm_table
[i
].def
.ivalue
=
4047 *(int *)lp_parm_ptr(NULL
, &parm_table
[i
]);
4053 defaults_saved
= true;
4056 /***********************************************************
4057 If we should send plaintext/LANMAN passwords in the clinet
4058 ************************************************************/
4060 static void set_allowed_client_auth(void)
4062 if (Globals
.bClientNTLMv2Auth
) {
4063 Globals
.bClientLanManAuth
= false;
4065 if (!Globals
.bClientLanManAuth
) {
4066 Globals
.bClientPlaintextAuth
= false;
4070 /***************************************************************************
4072 The following code allows smbd to read a user defined share file.
4073 Yes, this is my intent. Yes, I'm comfortable with that...
4075 THE FOLLOWING IS SECURITY CRITICAL CODE.
4077 It washes your clothes, it cleans your house, it guards you while you sleep...
4078 Do not f%^k with it....
4079 ***************************************************************************/
4081 #define MAX_USERSHARE_FILE_SIZE (10*1024)
4083 /***************************************************************************
4084 Check allowed stat state of a usershare file.
4085 Ensure we print out who is dicking with us so the admin can
4086 get their sorry ass fired.
4087 ***************************************************************************/
4089 static bool check_usershare_stat(const char *fname
,
4090 const SMB_STRUCT_STAT
*psbuf
)
4092 if (!S_ISREG(psbuf
->st_ex_mode
)) {
4093 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
4094 "not a regular file\n",
4095 fname
, (unsigned int)psbuf
->st_ex_uid
));
4099 /* Ensure this doesn't have the other write bit set. */
4100 if (psbuf
->st_ex_mode
& S_IWOTH
) {
4101 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
4102 "public write. Refusing to allow as a usershare file.\n",
4103 fname
, (unsigned int)psbuf
->st_ex_uid
));
4107 /* Should be 10k or less. */
4108 if (psbuf
->st_ex_size
> MAX_USERSHARE_FILE_SIZE
) {
4109 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
4110 "too large (%u) to be a user share file.\n",
4111 fname
, (unsigned int)psbuf
->st_ex_uid
,
4112 (unsigned int)psbuf
->st_ex_size
));
4119 /***************************************************************************
4120 Parse the contents of a usershare file.
4121 ***************************************************************************/
4123 enum usershare_err
parse_usershare_file(TALLOC_CTX
*ctx
,
4124 SMB_STRUCT_STAT
*psbuf
,
4125 const char *servicename
,
4129 char **pp_sharepath
,
4131 char **pp_cp_servicename
,
4132 struct security_descriptor
**ppsd
,
4135 const char **prefixallowlist
= lp_usershare_prefix_allow_list();
4136 const char **prefixdenylist
= lp_usershare_prefix_deny_list();
4139 SMB_STRUCT_STAT sbuf
;
4140 char *sharepath
= NULL
;
4141 char *comment
= NULL
;
4143 *pp_sharepath
= NULL
;
4146 *pallow_guest
= false;
4149 return USERSHARE_MALFORMED_FILE
;
4152 if (strcmp(lines
[0], "#VERSION 1") == 0) {
4154 } else if (strcmp(lines
[0], "#VERSION 2") == 0) {
4157 return USERSHARE_MALFORMED_FILE
;
4160 return USERSHARE_BAD_VERSION
;
4163 if (strncmp(lines
[1], "path=", 5) != 0) {
4164 return USERSHARE_MALFORMED_PATH
;
4167 sharepath
= talloc_strdup(ctx
, &lines
[1][5]);
4169 return USERSHARE_POSIX_ERR
;
4171 trim_string(sharepath
, " ", " ");
4173 if (strncmp(lines
[2], "comment=", 8) != 0) {
4174 return USERSHARE_MALFORMED_COMMENT_DEF
;
4177 comment
= talloc_strdup(ctx
, &lines
[2][8]);
4179 return USERSHARE_POSIX_ERR
;
4181 trim_string(comment
, " ", " ");
4182 trim_char(comment
, '"', '"');
4184 if (strncmp(lines
[3], "usershare_acl=", 14) != 0) {
4185 return USERSHARE_MALFORMED_ACL_DEF
;
4188 if (!parse_usershare_acl(ctx
, &lines
[3][14], ppsd
)) {
4189 return USERSHARE_ACL_ERR
;
4193 if (strncmp(lines
[4], "guest_ok=", 9) != 0) {
4194 return USERSHARE_MALFORMED_ACL_DEF
;
4196 if (lines
[4][9] == 'y') {
4197 *pallow_guest
= true;
4200 /* Backwards compatible extension to file version #2. */
4202 if (strncmp(lines
[5], "sharename=", 10) != 0) {
4203 return USERSHARE_MALFORMED_SHARENAME_DEF
;
4205 if (!strequal(&lines
[5][10], servicename
)) {
4206 return USERSHARE_BAD_SHARENAME
;
4208 *pp_cp_servicename
= talloc_strdup(ctx
, &lines
[5][10]);
4209 if (!*pp_cp_servicename
) {
4210 return USERSHARE_POSIX_ERR
;
4215 if (*pp_cp_servicename
== NULL
) {
4216 *pp_cp_servicename
= talloc_strdup(ctx
, servicename
);
4217 if (!*pp_cp_servicename
) {
4218 return USERSHARE_POSIX_ERR
;
4222 if (snum
!= -1 && (strcmp(sharepath
, ServicePtrs
[snum
]->szPath
) == 0)) {
4223 /* Path didn't change, no checks needed. */
4224 *pp_sharepath
= sharepath
;
4225 *pp_comment
= comment
;
4226 return USERSHARE_OK
;
4229 /* The path *must* be absolute. */
4230 if (sharepath
[0] != '/') {
4231 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
4232 servicename
, sharepath
));
4233 return USERSHARE_PATH_NOT_ABSOLUTE
;
4236 /* If there is a usershare prefix deny list ensure one of these paths
4237 doesn't match the start of the user given path. */
4238 if (prefixdenylist
) {
4240 for ( i
=0; prefixdenylist
[i
]; i
++ ) {
4241 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
4242 servicename
, i
, prefixdenylist
[i
], sharepath
));
4243 if (memcmp( sharepath
, prefixdenylist
[i
], strlen(prefixdenylist
[i
])) == 0) {
4244 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
4245 "usershare prefix deny list entries.\n",
4246 servicename
, sharepath
));
4247 return USERSHARE_PATH_IS_DENIED
;
4252 /* If there is a usershare prefix allow list ensure one of these paths
4253 does match the start of the user given path. */
4255 if (prefixallowlist
) {
4257 for ( i
=0; prefixallowlist
[i
]; i
++ ) {
4258 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
4259 servicename
, i
, prefixallowlist
[i
], sharepath
));
4260 if (memcmp( sharepath
, prefixallowlist
[i
], strlen(prefixallowlist
[i
])) == 0) {
4264 if (prefixallowlist
[i
] == NULL
) {
4265 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
4266 "usershare prefix allow list entries.\n",
4267 servicename
, sharepath
));
4268 return USERSHARE_PATH_NOT_ALLOWED
;
4272 /* Ensure this is pointing to a directory. */
4273 dp
= opendir(sharepath
);
4276 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
4277 servicename
, sharepath
));
4278 return USERSHARE_PATH_NOT_DIRECTORY
;
4281 /* Ensure the owner of the usershare file has permission to share
4284 if (sys_stat(sharepath
, &sbuf
, false) == -1) {
4285 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
4286 servicename
, sharepath
, strerror(errno
) ));
4288 return USERSHARE_POSIX_ERR
;
4293 if (!S_ISDIR(sbuf
.st_ex_mode
)) {
4294 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
4295 servicename
, sharepath
));
4296 return USERSHARE_PATH_NOT_DIRECTORY
;
4299 /* Check if sharing is restricted to owner-only. */
4300 /* psbuf is the stat of the usershare definition file,
4301 sbuf is the stat of the target directory to be shared. */
4303 if (lp_usershare_owner_only()) {
4304 /* root can share anything. */
4305 if ((psbuf
->st_ex_uid
!= 0) && (sbuf
.st_ex_uid
!= psbuf
->st_ex_uid
)) {
4306 return USERSHARE_PATH_NOT_ALLOWED
;
4310 *pp_sharepath
= sharepath
;
4311 *pp_comment
= comment
;
4312 return USERSHARE_OK
;
4315 /***************************************************************************
4316 Deal with a usershare file.
4319 -1 - Bad name, invalid contents.
4320 - service name already existed and not a usershare, problem
4321 with permissions to share directory etc.
4322 ***************************************************************************/
4324 static int process_usershare_file(const char *dir_name
, const char *file_name
, int snum_template
)
4326 SMB_STRUCT_STAT sbuf
;
4327 SMB_STRUCT_STAT lsbuf
;
4329 char *sharepath
= NULL
;
4330 char *comment
= NULL
;
4331 char *cp_service_name
= NULL
;
4332 char **lines
= NULL
;
4336 TALLOC_CTX
*ctx
= talloc_stackframe();
4337 struct security_descriptor
*psd
= NULL
;
4338 bool guest_ok
= false;
4339 char *canon_name
= NULL
;
4340 bool added_service
= false;
4343 /* Ensure share name doesn't contain invalid characters. */
4344 if (!validate_net_name(file_name
, INVALID_SHARENAME_CHARS
, strlen(file_name
))) {
4345 DEBUG(0,("process_usershare_file: share name %s contains "
4346 "invalid characters (any of %s)\n",
4347 file_name
, INVALID_SHARENAME_CHARS
));
4351 canon_name
= canonicalize_servicename(ctx
, file_name
);
4356 fname
= talloc_asprintf(ctx
, "%s/%s", dir_name
, file_name
);
4361 /* Minimize the race condition by doing an lstat before we
4362 open and fstat. Ensure this isn't a symlink link. */
4364 if (sys_lstat(fname
, &lsbuf
, false) != 0) {
4365 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
4366 fname
, strerror(errno
) ));
4370 /* This must be a regular file, not a symlink, directory or
4371 other strange filetype. */
4372 if (!check_usershare_stat(fname
, &lsbuf
)) {
4380 status
= dbwrap_fetch_bystring(ServiceHash
, canon_name
,
4385 if (NT_STATUS_IS_OK(status
) &&
4386 (data
.dptr
!= NULL
) &&
4387 (data
.dsize
== sizeof(iService
))) {
4388 memcpy(&iService
, data
.dptr
, sizeof(iService
));
4392 if (iService
!= -1 &&
4393 timespec_compare(&ServicePtrs
[iService
]->usershare_last_mod
,
4394 &lsbuf
.st_ex_mtime
) == 0) {
4395 /* Nothing changed - Mark valid and return. */
4396 DEBUG(10,("process_usershare_file: service %s not changed.\n",
4398 ServicePtrs
[iService
]->usershare
= USERSHARE_VALID
;
4403 /* Try and open the file read only - no symlinks allowed. */
4405 fd
= open(fname
, O_RDONLY
|O_NOFOLLOW
, 0);
4407 fd
= open(fname
, O_RDONLY
, 0);
4411 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
4412 fname
, strerror(errno
) ));
4416 /* Now fstat to be *SURE* it's a regular file. */
4417 if (sys_fstat(fd
, &sbuf
, false) != 0) {
4419 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
4420 fname
, strerror(errno
) ));
4424 /* Is it the same dev/inode as was lstated ? */
4425 if (!check_same_stat(&lsbuf
, &sbuf
)) {
4427 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
4428 "Symlink spoofing going on ?\n", fname
));
4432 /* This must be a regular file, not a symlink, directory or
4433 other strange filetype. */
4434 if (!check_usershare_stat(fname
, &sbuf
)) {
4439 lines
= fd_lines_load(fd
, &numlines
, MAX_USERSHARE_FILE_SIZE
, NULL
);
4442 if (lines
== NULL
) {
4443 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
4444 fname
, (unsigned int)sbuf
.st_ex_uid
));
4448 if (parse_usershare_file(ctx
, &sbuf
, file_name
,
4449 iService
, lines
, numlines
, &sharepath
,
4450 &comment
, &cp_service_name
,
4451 &psd
, &guest_ok
) != USERSHARE_OK
) {
4455 /* Everything ok - add the service possibly using a template. */
4457 const struct loadparm_service
*sp
= &sDefault
;
4458 if (snum_template
!= -1) {
4459 sp
= ServicePtrs
[snum_template
];
4462 if ((iService
= add_a_service(sp
, cp_service_name
)) < 0) {
4463 DEBUG(0, ("process_usershare_file: Failed to add "
4464 "new service %s\n", cp_service_name
));
4468 added_service
= true;
4470 /* Read only is controlled by usershare ACL below. */
4471 ServicePtrs
[iService
]->bRead_only
= false;
4474 /* Write the ACL of the new/modified share. */
4475 if (!set_share_security(canon_name
, psd
)) {
4476 DEBUG(0, ("process_usershare_file: Failed to set share "
4477 "security for user share %s\n",
4482 /* If from a template it may be marked invalid. */
4483 ServicePtrs
[iService
]->valid
= true;
4485 /* Set the service as a valid usershare. */
4486 ServicePtrs
[iService
]->usershare
= USERSHARE_VALID
;
4488 /* Set guest access. */
4489 if (lp_usershare_allow_guests()) {
4490 ServicePtrs
[iService
]->bGuest_ok
= guest_ok
;
4493 /* And note when it was loaded. */
4494 ServicePtrs
[iService
]->usershare_last_mod
= sbuf
.st_ex_mtime
;
4495 string_set(&ServicePtrs
[iService
]->szPath
, sharepath
);
4496 string_set(&ServicePtrs
[iService
]->comment
, comment
);
4502 if (ret
== -1 && iService
!= -1 && added_service
) {
4503 lp_remove_service(iService
);
4511 /***************************************************************************
4512 Checks if a usershare entry has been modified since last load.
4513 ***************************************************************************/
4515 static bool usershare_exists(int iService
, struct timespec
*last_mod
)
4517 SMB_STRUCT_STAT lsbuf
;
4518 const char *usersharepath
= Globals
.szUsersharePath
;
4521 if (asprintf(&fname
, "%s/%s",
4523 ServicePtrs
[iService
]->szService
) < 0) {
4527 if (sys_lstat(fname
, &lsbuf
, false) != 0) {
4532 if (!S_ISREG(lsbuf
.st_ex_mode
)) {
4538 *last_mod
= lsbuf
.st_ex_mtime
;
4542 /***************************************************************************
4543 Load a usershare service by name. Returns a valid servicenumber or -1.
4544 ***************************************************************************/
4546 int load_usershare_service(const char *servicename
)
4548 SMB_STRUCT_STAT sbuf
;
4549 const char *usersharepath
= Globals
.szUsersharePath
;
4550 int max_user_shares
= Globals
.iUsershareMaxShares
;
4551 int snum_template
= -1;
4553 if (*usersharepath
== 0 || max_user_shares
== 0) {
4557 if (sys_stat(usersharepath
, &sbuf
, false) != 0) {
4558 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
4559 usersharepath
, strerror(errno
) ));
4563 if (!S_ISDIR(sbuf
.st_ex_mode
)) {
4564 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
4570 * This directory must be owned by root, and have the 't' bit set.
4571 * It also must not be writable by "other".
4575 if (sbuf
.st_ex_uid
!= 0 || !(sbuf
.st_ex_mode
& S_ISVTX
) || (sbuf
.st_ex_mode
& S_IWOTH
)) {
4577 if (sbuf
.st_ex_uid
!= 0 || (sbuf
.st_ex_mode
& S_IWOTH
)) {
4579 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
4580 "or does not have the sticky bit 't' set or is writable by anyone.\n",
4585 /* Ensure the template share exists if it's set. */
4586 if (Globals
.szUsershareTemplateShare
[0]) {
4587 /* We can't use lp_servicenumber here as we are recommending that
4588 template shares have -valid=false set. */
4589 for (snum_template
= iNumServices
- 1; snum_template
>= 0; snum_template
--) {
4590 if (ServicePtrs
[snum_template
]->szService
&&
4591 strequal(ServicePtrs
[snum_template
]->szService
,
4592 Globals
.szUsershareTemplateShare
)) {
4597 if (snum_template
== -1) {
4598 DEBUG(0,("load_usershare_service: usershare template share %s "
4599 "does not exist.\n",
4600 Globals
.szUsershareTemplateShare
));
4605 return process_usershare_file(usersharepath
, servicename
, snum_template
);
4608 /***************************************************************************
4609 Load all user defined shares from the user share directory.
4610 We only do this if we're enumerating the share list.
4611 This is the function that can delete usershares that have
4613 ***************************************************************************/
4615 int load_usershare_shares(struct smbd_server_connection
*sconn
,
4616 bool (*snumused
) (struct smbd_server_connection
*, int))
4619 SMB_STRUCT_STAT sbuf
;
4621 int num_usershares
= 0;
4622 int max_user_shares
= Globals
.iUsershareMaxShares
;
4623 unsigned int num_dir_entries
, num_bad_dir_entries
, num_tmp_dir_entries
;
4624 unsigned int allowed_bad_entries
= ((2*max_user_shares
)/10);
4625 unsigned int allowed_tmp_entries
= ((2*max_user_shares
)/10);
4627 int snum_template
= -1;
4628 const char *usersharepath
= Globals
.szUsersharePath
;
4629 int ret
= lp_numservices();
4630 TALLOC_CTX
*tmp_ctx
;
4632 if (max_user_shares
== 0 || *usersharepath
== '\0') {
4633 return lp_numservices();
4636 if (sys_stat(usersharepath
, &sbuf
, false) != 0) {
4637 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
4638 usersharepath
, strerror(errno
) ));
4643 * This directory must be owned by root, and have the 't' bit set.
4644 * It also must not be writable by "other".
4648 if (sbuf
.st_ex_uid
!= 0 || !(sbuf
.st_ex_mode
& S_ISVTX
) || (sbuf
.st_ex_mode
& S_IWOTH
)) {
4650 if (sbuf
.st_ex_uid
!= 0 || (sbuf
.st_ex_mode
& S_IWOTH
)) {
4652 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
4653 "or does not have the sticky bit 't' set or is writable by anyone.\n",
4658 /* Ensure the template share exists if it's set. */
4659 if (Globals
.szUsershareTemplateShare
[0]) {
4660 /* We can't use lp_servicenumber here as we are recommending that
4661 template shares have -valid=false set. */
4662 for (snum_template
= iNumServices
- 1; snum_template
>= 0; snum_template
--) {
4663 if (ServicePtrs
[snum_template
]->szService
&&
4664 strequal(ServicePtrs
[snum_template
]->szService
,
4665 Globals
.szUsershareTemplateShare
)) {
4670 if (snum_template
== -1) {
4671 DEBUG(0,("load_usershare_shares: usershare template share %s "
4672 "does not exist.\n",
4673 Globals
.szUsershareTemplateShare
));
4678 /* Mark all existing usershares as pending delete. */
4679 for (iService
= iNumServices
- 1; iService
>= 0; iService
--) {
4680 if (VALID(iService
) && ServicePtrs
[iService
]->usershare
) {
4681 ServicePtrs
[iService
]->usershare
= USERSHARE_PENDING_DELETE
;
4685 dp
= opendir(usersharepath
);
4687 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
4688 usersharepath
, strerror(errno
) ));
4692 for (num_dir_entries
= 0, num_bad_dir_entries
= 0, num_tmp_dir_entries
= 0;
4694 num_dir_entries
++ ) {
4696 const char *n
= de
->d_name
;
4698 /* Ignore . and .. */
4700 if ((n
[1] == '\0') || (n
[1] == '.' && n
[2] == '\0')) {
4706 /* Temporary file used when creating a share. */
4707 num_tmp_dir_entries
++;
4710 /* Allow 20% tmp entries. */
4711 if (num_tmp_dir_entries
> allowed_tmp_entries
) {
4712 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
4713 "in directory %s\n",
4714 num_tmp_dir_entries
, usersharepath
));
4718 r
= process_usershare_file(usersharepath
, n
, snum_template
);
4720 /* Update the services count. */
4722 if (num_usershares
>= max_user_shares
) {
4723 DEBUG(0,("load_usershare_shares: max user shares reached "
4724 "on file %s in directory %s\n",
4725 n
, usersharepath
));
4728 } else if (r
== -1) {
4729 num_bad_dir_entries
++;
4732 /* Allow 20% bad entries. */
4733 if (num_bad_dir_entries
> allowed_bad_entries
) {
4734 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
4735 "in directory %s\n",
4736 num_bad_dir_entries
, usersharepath
));
4740 /* Allow 20% bad entries. */
4741 if (num_dir_entries
> max_user_shares
+ allowed_bad_entries
) {
4742 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
4743 "in directory %s\n",
4744 num_dir_entries
, usersharepath
));
4751 /* Sweep through and delete any non-refreshed usershares that are
4752 not currently in use. */
4753 tmp_ctx
= talloc_stackframe();
4754 for (iService
= iNumServices
- 1; iService
>= 0; iService
--) {
4755 if (VALID(iService
) && (ServicePtrs
[iService
]->usershare
== USERSHARE_PENDING_DELETE
)) {
4758 if (snumused
&& snumused(sconn
, iService
)) {
4762 servname
= lp_servicename(tmp_ctx
, iService
);
4764 /* Remove from the share ACL db. */
4765 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
4767 delete_share_security(servname
);
4768 free_service_byindex(iService
);
4771 talloc_free(tmp_ctx
);
4773 return lp_numservices();
4776 /********************************************************
4777 Destroy global resources allocated in this file
4778 ********************************************************/
4780 void gfree_loadparm(void)
4786 /* Free resources allocated to services */
4788 for ( i
= 0; i
< iNumServices
; i
++ ) {
4790 free_service_byindex(i
);
4794 SAFE_FREE( ServicePtrs
);
4797 /* Now release all resources allocated to global
4798 parameters and the default service */
4800 free_global_parameters();
4804 /***************************************************************************
4805 Allow client apps to specify that they are a client
4806 ***************************************************************************/
4807 static void lp_set_in_client(bool b
)
4813 /***************************************************************************
4814 Determine if we're running in a client app
4815 ***************************************************************************/
4816 static bool lp_is_in_client(void)
4821 /***************************************************************************
4822 Load the services array from the services file. Return true on success,
4824 ***************************************************************************/
4826 static bool lp_load_ex(const char *pszFname
,
4830 bool initialize_globals
,
4831 bool allow_include_registry
,
4832 bool load_all_shares
)
4839 DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
4841 bInGlobalSection
= true;
4842 bGlobalOnly
= global_only
;
4843 bAllowIncludeRegistry
= allow_include_registry
;
4845 init_globals(initialize_globals
);
4849 if (save_defaults
) {
4854 if (!initialize_globals
) {
4855 free_param_opts(&Globals
.param_opt
);
4856 apply_lp_set_cmdline();
4859 lp_do_parameter(-1, "idmap config * : backend", Globals
.szIdmapBackend
);
4861 /* We get sections first, so have to start 'behind' to make up */
4864 if (lp_config_backend_is_file()) {
4865 n2
= talloc_sub_basic(talloc_tos(), get_current_username(),
4866 current_user_info
.domain
,
4869 smb_panic("lp_load_ex: out of memory");
4872 add_to_file_list(pszFname
, n2
);
4874 bRetval
= pm_process(n2
, do_section
, do_parameter
, NULL
);
4877 /* finish up the last section */
4878 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval
)));
4880 if (iServiceIndex
>= 0) {
4881 bRetval
= service_ok(iServiceIndex
);
4885 if (lp_config_backend_is_registry()) {
4886 /* config backend changed to registry in config file */
4888 * We need to use this extra global variable here to
4889 * survive restart: init_globals uses this as a default
4890 * for ConfigBackend. Otherwise, init_globals would
4891 * send us into an endless loop here.
4893 config_backend
= CONFIG_BACKEND_REGISTRY
;
4895 DEBUG(1, ("lp_load_ex: changing to config backend "
4898 lp_kill_all_services();
4899 return lp_load_ex(pszFname
, global_only
, save_defaults
,
4900 add_ipc
, initialize_globals
,
4901 allow_include_registry
,
4904 } else if (lp_config_backend_is_registry()) {
4905 bRetval
= process_registry_globals();
4907 DEBUG(0, ("Illegal config backend given: %d\n",
4908 lp_config_backend()));
4912 if (bRetval
&& lp_registry_shares()) {
4913 if (load_all_shares
) {
4914 bRetval
= process_registry_shares();
4916 bRetval
= reload_registry_shares();
4921 char *serv
= lp_auto_services(talloc_tos());
4922 lp_add_auto_services(serv
);
4927 /* When 'restrict anonymous = 2' guest connections to ipc$
4929 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
4930 if ( lp_enable_asu_support() ) {
4931 lp_add_ipc("ADMIN$", false);
4935 set_allowed_client_auth();
4937 if (lp_security() == SEC_ADS
&& strchr(lp_passwordserver(), ':')) {
4938 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
4939 lp_passwordserver()));
4944 /* Now we check bWINSsupport and set szWINSserver to 127.0.0.1 */
4945 /* if bWINSsupport is true and we are in the client */
4946 if (lp_is_in_client() && Globals
.bWINSsupport
) {
4947 lp_do_parameter(GLOBAL_SECTION_SNUM
, "wins server", "127.0.0.1");
4952 fault_configure(smb_panic_s3
);
4955 * We run this check once the whole smb.conf is parsed, to
4956 * force some settings for the standard way a AD DC is
4957 * operated. We may changed these as our code evolves, which
4958 * is why we force these settings.
4960 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
) {
4961 lp_do_parameter(-1, "passdb backend", "samba_dsdb");
4963 lp_do_parameter(-1, "rpc_server:default", "external");
4964 lp_do_parameter(-1, "rpc_server:svcctl", "embedded");
4965 lp_do_parameter(-1, "rpc_server:srvsvc", "embedded");
4966 lp_do_parameter(-1, "rpc_server:eventlog", "embedded");
4967 lp_do_parameter(-1, "rpc_server:ntsvcs", "embedded");
4968 lp_do_parameter(-1, "rpc_server:winreg", "embedded");
4969 lp_do_parameter(-1, "rpc_server:spoolss", "embedded");
4970 lp_do_parameter(-1, "rpc_daemon:spoolssd", "embedded");
4971 lp_do_parameter(-1, "rpc_server:tcpip", "no");
4974 bAllowIncludeRegistry
= true;
4979 bool lp_load(const char *pszFname
,
4983 bool initialize_globals
)
4985 return lp_load_ex(pszFname
,
4990 true, /* allow_include_registry */
4991 false); /* load_all_shares*/
4994 bool lp_load_initial_only(const char *pszFname
)
4996 return lp_load_ex(pszFname
,
4997 true, /* global only */
4998 false, /* save_defaults */
4999 false, /* add_ipc */
5000 true, /* initialize_globals */
5001 false, /* allow_include_registry */
5002 false); /* load_all_shares*/
5006 * most common lp_load wrapper, loading only the globals
5008 bool lp_load_global(const char *file_name
)
5010 return lp_load_ex(file_name
,
5011 true, /* global_only */
5012 false, /* save_defaults */
5013 false, /* add_ipc */
5014 true, /* initialize_globals */
5015 true, /* allow_include_registry */
5016 false); /* load_all_shares*/
5020 * lp_load wrapper, especially for clients
5022 bool lp_load_client(const char *file_name
)
5024 lp_set_in_client(true);
5026 return lp_load_global(file_name
);
5030 * lp_load wrapper, loading only globals, but intended
5031 * for subsequent calls, not reinitializing the globals
5034 bool lp_load_global_no_reinit(const char *file_name
)
5036 return lp_load_ex(file_name
,
5037 true, /* global_only */
5038 false, /* save_defaults */
5039 false, /* add_ipc */
5040 false, /* initialize_globals */
5041 true, /* allow_include_registry */
5042 false); /* load_all_shares*/
5046 * lp_load wrapper, especially for clients, no reinitialization
5048 bool lp_load_client_no_reinit(const char *file_name
)
5050 lp_set_in_client(true);
5052 return lp_load_global_no_reinit(file_name
);
5055 bool lp_load_with_registry_shares(const char *pszFname
,
5059 bool initialize_globals
)
5061 return lp_load_ex(pszFname
,
5066 true, /* allow_include_registry */
5067 true); /* load_all_shares*/
5070 /***************************************************************************
5071 Return the max number of services.
5072 ***************************************************************************/
5074 int lp_numservices(void)
5076 return (iNumServices
);
5079 /***************************************************************************
5080 Display the contents of the services array in human-readable form.
5081 ***************************************************************************/
5083 void lp_dump(FILE *f
, bool show_defaults
, int maxtoprint
)
5088 defaults_saved
= false;
5092 dump_a_service(&sDefault
, f
);
5094 for (iService
= 0; iService
< maxtoprint
; iService
++) {
5096 lp_dump_one(f
, show_defaults
, iService
);
5100 /***************************************************************************
5101 Display the contents of one service in human-readable form.
5102 ***************************************************************************/
5104 void lp_dump_one(FILE * f
, bool show_defaults
, int snum
)
5107 if (ServicePtrs
[snum
]->szService
[0] == '\0')
5109 dump_a_service(ServicePtrs
[snum
], f
);
5113 /***************************************************************************
5114 Return the number of the service with the given name, or -1 if it doesn't
5115 exist. Note that this is a DIFFERENT ANIMAL from the internal function
5116 getservicebyname()! This works ONLY if all services have been loaded, and
5117 does not copy the found service.
5118 ***************************************************************************/
5120 int lp_servicenumber(const char *pszServiceName
)
5123 fstring serviceName
;
5125 if (!pszServiceName
) {
5126 return GLOBAL_SECTION_SNUM
;
5129 for (iService
= iNumServices
- 1; iService
>= 0; iService
--) {
5130 if (VALID(iService
) && ServicePtrs
[iService
]->szService
) {
5132 * The substitution here is used to support %U is
5135 fstrcpy(serviceName
, ServicePtrs
[iService
]->szService
);
5136 standard_sub_basic(get_current_username(),
5137 current_user_info
.domain
,
5138 serviceName
,sizeof(serviceName
));
5139 if (strequal(serviceName
, pszServiceName
)) {
5145 if (iService
>= 0 && ServicePtrs
[iService
]->usershare
== USERSHARE_VALID
) {
5146 struct timespec last_mod
;
5148 if (!usershare_exists(iService
, &last_mod
)) {
5149 /* Remove the share security tdb entry for it. */
5150 delete_share_security(lp_servicename(talloc_tos(), iService
));
5151 /* Remove it from the array. */
5152 free_service_byindex(iService
);
5153 /* Doesn't exist anymore. */
5154 return GLOBAL_SECTION_SNUM
;
5157 /* Has it been modified ? If so delete and reload. */
5158 if (timespec_compare(&ServicePtrs
[iService
]->usershare_last_mod
,
5160 /* Remove it from the array. */
5161 free_service_byindex(iService
);
5162 /* and now reload it. */
5163 iService
= load_usershare_service(pszServiceName
);
5168 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName
));
5169 return GLOBAL_SECTION_SNUM
;
5175 /*******************************************************************
5176 A useful volume label function.
5177 ********************************************************************/
5179 const char *volume_label(TALLOC_CTX
*ctx
, int snum
)
5182 const char *label
= lp_volume(ctx
, snum
);
5184 label
= lp_servicename(ctx
, snum
);
5187 /* This returns a 33 byte guarenteed null terminated string. */
5188 ret
= talloc_strndup(ctx
, label
, 32);
5195 /*******************************************************************
5196 Get the default server type we will announce as via nmbd.
5197 ********************************************************************/
5199 int lp_default_server_announce(void)
5201 int default_server_announce
= 0;
5202 default_server_announce
|= SV_TYPE_WORKSTATION
;
5203 default_server_announce
|= SV_TYPE_SERVER
;
5204 default_server_announce
|= SV_TYPE_SERVER_UNIX
;
5206 /* note that the flag should be set only if we have a
5207 printer service but nmbd doesn't actually load the
5208 services so we can't tell --jerry */
5210 default_server_announce
|= SV_TYPE_PRINTQ_SERVER
;
5212 default_server_announce
|= SV_TYPE_SERVER_NT
;
5213 default_server_announce
|= SV_TYPE_NT
;
5215 switch (lp_server_role()) {
5216 case ROLE_DOMAIN_MEMBER
:
5217 default_server_announce
|= SV_TYPE_DOMAIN_MEMBER
;
5219 case ROLE_DOMAIN_PDC
:
5220 default_server_announce
|= SV_TYPE_DOMAIN_CTRL
;
5222 case ROLE_DOMAIN_BDC
:
5223 default_server_announce
|= SV_TYPE_DOMAIN_BAKCTRL
;
5225 case ROLE_STANDALONE
:
5229 if (lp_time_server())
5230 default_server_announce
|= SV_TYPE_TIME_SOURCE
;
5232 if (lp_host_msdfs())
5233 default_server_announce
|= SV_TYPE_DFS_SERVER
;
5235 return default_server_announce
;
5238 /***********************************************************
5239 If we are PDC then prefer us as DMB
5240 ************************************************************/
5242 bool lp_domain_master(void)
5244 if (Globals
.domain_master
== Auto
)
5245 return (lp_server_role() == ROLE_DOMAIN_PDC
);
5247 return (bool)Globals
.domain_master
;
5250 /***********************************************************
5251 If we are PDC then prefer us as DMB
5252 ************************************************************/
5254 static bool lp_domain_master_true_or_auto(void)
5256 if (Globals
.domain_master
) /* auto or yes */
5262 /***********************************************************
5263 If we are DMB then prefer us as LMB
5264 ************************************************************/
5266 bool lp_preferred_master(void)
5268 if (Globals
.iPreferredMaster
== Auto
)
5269 return (lp_local_master() && lp_domain_master());
5271 return (bool)Globals
.iPreferredMaster
;
5274 /*******************************************************************
5276 ********************************************************************/
5278 void lp_remove_service(int snum
)
5280 ServicePtrs
[snum
]->valid
= false;
5281 invalid_services
[num_invalid_services
++] = snum
;
5284 /*******************************************************************
5286 ********************************************************************/
5288 void lp_copy_service(int snum
, const char *new_name
)
5290 do_section(new_name
, NULL
);
5292 snum
= lp_servicenumber(new_name
);
5294 char *name
= lp_servicename(talloc_tos(), snum
);
5295 lp_do_parameter(snum
, "copy", name
);
5300 const char *lp_printername(TALLOC_CTX
*ctx
, int snum
)
5302 const char *ret
= lp__printername(talloc_tos(), snum
);
5303 if (ret
== NULL
|| *ret
== '\0') {
5304 ret
= lp_const_servicename(snum
);
5311 /***********************************************************
5312 Allow daemons such as winbindd to fix their logfile name.
5313 ************************************************************/
5315 void lp_set_logfile(const char *name
)
5317 string_set(&Globals
.logfile
, name
);
5318 debug_set_logfile(name
);
5321 /*******************************************************************
5322 Return the max print jobs per queue.
5323 ********************************************************************/
5325 int lp_maxprintjobs(int snum
)
5327 int maxjobs
= LP_SNUM_OK(snum
) ? ServicePtrs
[snum
]->iMaxPrintJobs
: sDefault
.iMaxPrintJobs
;
5328 if (maxjobs
<= 0 || maxjobs
>= PRINT_MAX_JOBID
)
5329 maxjobs
= PRINT_MAX_JOBID
- 1;
5334 const char *lp_printcapname(void)
5336 if ((Globals
.szPrintcapname
!= NULL
) &&
5337 (Globals
.szPrintcapname
[0] != '\0'))
5338 return Globals
.szPrintcapname
;
5340 if (sDefault
.iPrinting
== PRINT_CUPS
) {
5344 if (sDefault
.iPrinting
== PRINT_BSD
)
5345 return "/etc/printcap";
5347 return PRINTCAP_NAME
;
5350 static uint32 spoolss_state
;
5352 bool lp_disable_spoolss( void )
5354 if ( spoolss_state
== SVCCTL_STATE_UNKNOWN
)
5355 spoolss_state
= lp__disable_spoolss() ? SVCCTL_STOPPED
: SVCCTL_RUNNING
;
5357 return spoolss_state
== SVCCTL_STOPPED
? true : false;
5360 void lp_set_spoolss_state( uint32 state
)
5362 SMB_ASSERT( (state
== SVCCTL_STOPPED
) || (state
== SVCCTL_RUNNING
) );
5364 spoolss_state
= state
;
5367 uint32
lp_get_spoolss_state( void )
5369 return lp_disable_spoolss() ? SVCCTL_STOPPED
: SVCCTL_RUNNING
;
5372 /*******************************************************************
5373 Ensure we don't use sendfile if server smb signing is active.
5374 ********************************************************************/
5376 bool lp_use_sendfile(int snum
, struct smb_signing_state
*signing_state
)
5378 bool sign_active
= false;
5380 /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
5381 if (get_Protocol() < PROTOCOL_NT1
) {
5384 if (signing_state
) {
5385 sign_active
= smb_signing_is_active(signing_state
);
5387 return (lp__use_sendfile(snum
) &&
5388 (get_remote_arch() != RA_WIN95
) &&
5392 /*******************************************************************
5393 Turn off sendfile if we find the underlying OS doesn't support it.
5394 ********************************************************************/
5396 void set_use_sendfile(int snum
, bool val
)
5398 if (LP_SNUM_OK(snum
))
5399 ServicePtrs
[snum
]->bUseSendfile
= val
;
5401 sDefault
.bUseSendfile
= val
;
5404 /*******************************************************************
5405 Turn off storing DOS attributes if this share doesn't support it.
5406 ********************************************************************/
5408 void set_store_dos_attributes(int snum
, bool val
)
5410 if (!LP_SNUM_OK(snum
))
5412 ServicePtrs
[(snum
)]->bStoreDosAttributes
= val
;
5415 void lp_set_mangling_method(const char *new_method
)
5417 string_set(&Globals
.szManglingMethod
, new_method
);
5420 /*******************************************************************
5421 Global state for POSIX pathname processing.
5422 ********************************************************************/
5424 static bool posix_pathnames
;
5426 bool lp_posix_pathnames(void)
5428 return posix_pathnames
;
5431 /*******************************************************************
5432 Change everything needed to ensure POSIX pathname processing (currently
5434 ********************************************************************/
5436 void lp_set_posix_pathnames(void)
5438 posix_pathnames
= true;
5441 /*******************************************************************
5442 Global state for POSIX lock processing - CIFS unix extensions.
5443 ********************************************************************/
5445 bool posix_default_lock_was_set
;
5446 static enum brl_flavour posix_cifsx_locktype
; /* By default 0 == WINDOWS_LOCK */
5448 enum brl_flavour
lp_posix_cifsu_locktype(files_struct
*fsp
)
5450 if (posix_default_lock_was_set
) {
5451 return posix_cifsx_locktype
;
5453 return fsp
->posix_open
? POSIX_LOCK
: WINDOWS_LOCK
;
5457 /*******************************************************************
5458 ********************************************************************/
5460 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val
)
5462 posix_default_lock_was_set
= true;
5463 posix_cifsx_locktype
= val
;
5466 int lp_min_receive_file_size(void)
5468 if (Globals
.iminreceivefile
< 0) {
5471 return Globals
.iminreceivefile
;
5474 /*******************************************************************
5475 Safe wide links checks.
5476 This helper function always verify the validity of wide links,
5477 even after a configuration file reload.
5478 ********************************************************************/
5480 static bool lp_widelinks_internal(int snum
)
5482 return (bool)(LP_SNUM_OK(snum
)? ServicePtrs
[(snum
)]->bWidelinks
:
5483 sDefault
.bWidelinks
);
5486 void widelinks_warning(int snum
)
5488 if (lp_allow_insecure_widelinks()) {
5492 if (lp_unix_extensions() && lp_widelinks_internal(snum
)) {
5493 DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
5494 "These parameters are incompatible. "
5495 "Wide links will be disabled for this share.\n",
5496 lp_servicename(talloc_tos(), snum
) ));
5500 bool lp_widelinks(int snum
)
5502 /* wide links is always incompatible with unix extensions */
5503 if (lp_unix_extensions()) {
5505 * Unless we have "allow insecure widelinks"
5508 if (!lp_allow_insecure_widelinks()) {
5513 return lp_widelinks_internal(snum
);
5516 bool lp_writeraw(void)
5518 if (lp_async_smb_echo_handler()) {
5521 return lp__writeraw();
5524 bool lp_readraw(void)
5526 if (lp_async_smb_echo_handler()) {
5529 return lp__readraw();
5532 int lp_server_role(void)
5534 return lp_find_server_role(lp__server_role(),
5536 lp__domain_logons(),
5537 lp_domain_master_true_or_auto());
5540 int lp_security(void)
5542 return lp_find_security(lp__server_role(),