?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-param: inline octal_string into caller to allow code merge
[Samba/gebeck_regimport.git] / source3 / param / loadparm.c
blob255bc7459479e8ec3f19177d07a89e00f2d81834
1 /*
2 Unix SMB/CIFS implementation.
3 Parameter loading functions
4 Copyright (C) Karl Auer 1993-1998
5
6 Largely re-written by Andrew Tridgell, September 1994
7
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
15
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.
20
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.
25
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/>.
28 */
29
30 /*
31 * Load parameters.
32 *
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.
36 *
37 * To add a parameter:
38 *
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
44 *
45 *
46 * Notes:
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
52 * careful!
53 *
54 */
55
56 #include "includes.h"
57 #include "system/filesys.h"
58 #include "util_tdb.h"
59 #include "printing.h"
60 #include "lib/smbconf/smbconf.h"
61 #include "lib/smbconf/smbconf_init.h"
62 #include "lib/param/loadparm.h"
63
64 #include "ads.h"
65 #include "../librpc/gen_ndr/svcctl.h"
66 #include "intl.h"
67 #include "smb_signing.h"
68 #include "dbwrap/dbwrap.h"
69 #include "smbldap.h"
70 #include "../lib/util/bitmap.h"
71
72 #ifdef HAVE_SYS_SYSCTL_H
73 #include <sys/sysctl.h>
74 #endif
75
76 #ifdef HAVE_HTTPCONNECTENCRYPT
77 #include <cups/http.h>
78 #endif
79
80 bool bLoaded = false;
81
82 extern userdom_struct current_user_info;
83
84 /* the special value for the include parameter
85 * to be interpreted not as a file name but to
86 * trigger loading of the global smb.conf options
87 * from registry. */
88 #ifndef INCLUDE_REGISTRY_NAME
89 #define INCLUDE_REGISTRY_NAME "registry"
90 #endif
91
92 static bool in_client = false; /* Not in the client by default */
93 static struct smbconf_csn conf_last_csn;
94
95 #define CONFIG_BACKEND_FILE 0
96 #define CONFIG_BACKEND_REGISTRY 1
97
98 static int config_backend = CONFIG_BACKEND_FILE;
99
100 /* some helpful bits */
101 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && (ServicePtrs != NULL) && ServicePtrs[(i)]->valid)
102 #define VALID(i) (ServicePtrs != NULL && ServicePtrs[i]->valid)
103
104 #define USERSHARE_VALID 1
105 #define USERSHARE_PENDING_DELETE 2
106
107 static bool defaults_saved = false;
108
109 #define LOADPARM_EXTRA_GLOBALS \
110 struct parmlist_entry *param_opt; \
111 char *szRealm; \
112 char *szLogLevel; \
113 int iminreceivefile; \
114 char *szPrintcapname; \
115 int CupsEncrypt; \
116 int iPreferredMaster; \
117 int iDomainMaster; \
118 char *szLdapMachineSuffix; \
119 char *szLdapUserSuffix; \
120 char *szLdapIdmapSuffix; \
121 char *szLdapGroupSuffix; \
122 char *szStateDir; \
123 char *szCacheDir; \
124 char *szSocketAddress; \
125 char *szUsershareTemplateShare; \
126 char *szIdmapUID; \
127 char *szIdmapGID; \
128 int winbindMaxDomainConnections; \
129 int ismb2_max_credits;
130
131 #include "param/param_global.h"
132
133 static struct loadparm_global Globals;
134
135 /* This is a default service used to prime a services structure */
136 static struct loadparm_service sDefault =
137 {
138 .valid = true,
139 .autoloaded = false,
140 .usershare = 0,
141 .usershare_last_mod = {0, 0},
142 .szService = NULL,
143 .szPath = NULL,
144 .szUsername = NULL,
145 .szInvalidUsers = NULL,
146 .szValidUsers = NULL,
147 .szAdminUsers = NULL,
148 .szCopy = NULL,
149 .szInclude = NULL,
150 .szPreExec = NULL,
151 .szPostExec = NULL,
152 .szRootPreExec = NULL,
153 .szRootPostExec = NULL,
154 .szCupsOptions = NULL,
155 .szPrintcommand = NULL,
156 .szLpqcommand = NULL,
157 .szLprmcommand = NULL,
158 .szLppausecommand = NULL,
159 .szLpresumecommand = NULL,
160 .szQueuepausecommand = NULL,
161 .szQueueresumecommand = NULL,
162 .szPrintername = NULL,
163 .szPrintjobUsername = NULL,
164 .szDontdescend = NULL,
165 .szHostsallow = NULL,
166 .szHostsdeny = NULL,
167 .szMagicScript = NULL,
168 .szMagicOutput = NULL,
169 .szVetoFiles = NULL,
170 .szHideFiles = NULL,
171 .szVetoOplockFiles = NULL,
172 .comment = NULL,
173 .force_user = NULL,
174 .force_group = NULL,
175 .readlist = NULL,
176 .writelist = NULL,
177 .printer_admin = NULL,
178 .volume = NULL,
179 .fstype = NULL,
180 .szVfsObjects = NULL,
181 .szMSDfsProxy = NULL,
182 .szAioWriteBehind = NULL,
183 .szDfree = NULL,
184 .iMinPrintSpace = 0,
185 .iMaxPrintJobs = 1000,
186 .iMaxReportedPrintJobs = 0,
187 .iWriteCacheSize = 0,
188 .iCreate_mask = 0744,
189 .iCreate_force_mode = 0,
190 .iSecurity_mask = 0777,
191 .iSecurity_force_mode = 0,
192 .iDir_mask = 0755,
193 .iDir_force_mode = 0,
194 .iDir_Security_mask = 0777,
195 .iDir_Security_force_mode = 0,
196 .iMaxConnections = 0,
197 .iDefaultCase = CASE_LOWER,
198 .iPrinting = DEFAULT_PRINTING,
199 .iOplockContentionLimit = 2,
200 .iCSCPolicy = 0,
201 .iBlock_size = 1024,
202 .iDfreeCacheTime = 0,
203 .bPreexecClose = false,
204 .bRootpreexecClose = false,
205 .iCaseSensitive = Auto,
206 .bCasePreserve = true,
207 .bShortCasePreserve = true,
208 .bHideDotFiles = true,
209 .bHideSpecialFiles = false,
210 .bHideUnReadable = false,
211 .bHideUnWriteableFiles = false,
212 .bBrowseable = true,
213 .bAccessBasedShareEnum = false,
214 .bAvailable = true,
215 .bRead_only = true,
216 .bNo_set_dir = true,
217 .bGuest_only = false,
218 .bAdministrative_share = false,
219 .bGuest_ok = false,
220 .bPrint_ok = false,
221 .bPrintNotifyBackchannel = true,
222 .bMap_system = false,
223 .bMap_hidden = false,
224 .bMap_archive = true,
225 .bStoreDosAttributes = false,
226 .bDmapiSupport = false,
227 .bLocking = true,
228 .iStrictLocking = Auto,
229 .bPosixLocking = true,
230 .bShareModes = true,
231 .bOpLocks = true,
232 .bLevel2OpLocks = true,
233 .bOnlyUser = false,
234 .bMangledNames = true,
235 .bWidelinks = false,
236 .bSymlinks = true,
237 .bSyncAlways = false,
238 .bStrictAllocate = false,
239 .bStrictSync = false,
240 .magic_char = '~',
241 .copymap = NULL,
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,
253 .bMSDfsRoot = 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,
262 .bAfs_Share = false,
263 .bEASupport = false,
264 .bAclCheckPermissions = true,
265 .bAclMapFullControl = true,
266 .bAclGroupControl = false,
267 .bChangeNotify = true,
268 .bKernelChangeNotify = true,
269 .iallocation_roundup_size = SMB_ROUNDUP_ALLOCATION_SIZE,
270 .iAioReadSize = 0,
271 .iAioWriteSize = 0,
272 .iMap_readonly = MAP_READONLY_YES,
273 #ifdef BROKEN_DIRECTORY_HANDLING
274 .iDirectoryNameCacheSize = 0,
275 #else
276 .iDirectoryNameCacheSize = 100,
277 #endif
278 .ismb_encrypt = Auto,
279 .param_opt = NULL,
280 .dummy = ""
281 };
282
283 /* local variables */
284 static struct loadparm_service **ServicePtrs = NULL;
285 static int iNumServices = 0;
286 static int iServiceIndex = 0;
287 static struct db_context *ServiceHash;
288 static int *invalid_services = NULL;
289 static int num_invalid_services = 0;
290 static bool bInGlobalSection = true;
291 static bool bGlobalOnly = false;
292
293 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
294
295 /* prototypes for the special type handlers */
296 static bool handle_include(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr);
297 static bool handle_copy(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr);
298 static bool handle_idmap_backend(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr);
299 static bool handle_idmap_uid(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr);
300 static bool handle_idmap_gid(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr);
301 static bool handle_debug_list(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr );
302 static bool handle_realm(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr );
303 static bool handle_netbios_aliases(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr );
304 static bool handle_charset(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr );
305 static bool handle_dos_charset(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr );
306 static bool handle_printing(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr);
307 static bool handle_ldap_debug_level(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr);
308
309 static void set_allowed_client_auth(void);
310
311 static void add_to_file_list(const char *fname, const char *subfname);
312 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue, bool store_values);
313 static void free_param_opts(struct parmlist_entry **popts);
314
315 static const struct enum_list enum_protocol[] = {
316 {PROTOCOL_SMB2_02, "SMB2"}, /* for now keep PROTOCOL_SMB2_02 */
317 {PROTOCOL_SMB2_10, "SMB2_10"},
318 {PROTOCOL_SMB2_02, "SMB2_02"},
319 {PROTOCOL_NT1, "NT1"},
320 {PROTOCOL_LANMAN2, "LANMAN2"},
321 {PROTOCOL_LANMAN1, "LANMAN1"},
322 {PROTOCOL_CORE, "CORE"},
323 {PROTOCOL_COREPLUS, "COREPLUS"},
324 {PROTOCOL_COREPLUS, "CORE+"},
325 {-1, NULL}
326 };
327
328 static const struct enum_list enum_security[] = {
329 {SEC_SHARE, "SHARE"},
330 {SEC_USER, "USER"},
331 {SEC_SERVER, "SERVER"},
332 {SEC_DOMAIN, "DOMAIN"},
333 #ifdef HAVE_ADS
334 {SEC_ADS, "ADS"},
335 #endif
336 {-1, NULL}
337 };
338
339 static const struct enum_list enum_printing[] = {
340 {PRINT_SYSV, "sysv"},
341 {PRINT_AIX, "aix"},
342 {PRINT_HPUX, "hpux"},
343 {PRINT_BSD, "bsd"},
344 {PRINT_QNX, "qnx"},
345 {PRINT_PLP, "plp"},
346 {PRINT_LPRNG, "lprng"},
347 {PRINT_CUPS, "cups"},
348 {PRINT_IPRINT, "iprint"},
349 {PRINT_LPRNT, "nt"},
350 {PRINT_LPROS2, "os2"},
351 #if defined(DEVELOPER) || defined(ENABLE_BUILD_FARM_HACKS)
352 {PRINT_TEST, "test"},
353 {PRINT_VLP, "vlp"},
354 #endif /* DEVELOPER */
355 {-1, NULL}
356 };
357
358 static const struct enum_list enum_ldap_sasl_wrapping[] = {
359 {0, "plain"},
360 {ADS_AUTH_SASL_SIGN, "sign"},
361 {ADS_AUTH_SASL_SEAL, "seal"},
362 {-1, NULL}
363 };
364
365 static const struct enum_list enum_ldap_ssl[] = {
366 {LDAP_SSL_OFF, "no"},
367 {LDAP_SSL_OFF, "off"},
368 {LDAP_SSL_START_TLS, "start tls"},
369 {LDAP_SSL_START_TLS, "start_tls"},
370 {-1, NULL}
371 };
372
373 /* LDAP Dereferencing Alias types */
374 #define SAMBA_LDAP_DEREF_NEVER 0
375 #define SAMBA_LDAP_DEREF_SEARCHING 1
376 #define SAMBA_LDAP_DEREF_FINDING 2
377 #define SAMBA_LDAP_DEREF_ALWAYS 3
378
379 static const struct enum_list enum_ldap_deref[] = {
380 {SAMBA_LDAP_DEREF_NEVER, "never"},
381 {SAMBA_LDAP_DEREF_SEARCHING, "searching"},
382 {SAMBA_LDAP_DEREF_FINDING, "finding"},
383 {SAMBA_LDAP_DEREF_ALWAYS, "always"},
384 {-1, "auto"}
385 };
386
387 static const struct enum_list enum_ldap_passwd_sync[] = {
388 {LDAP_PASSWD_SYNC_OFF, "no"},
389 {LDAP_PASSWD_SYNC_OFF, "off"},
390 {LDAP_PASSWD_SYNC_ON, "yes"},
391 {LDAP_PASSWD_SYNC_ON, "on"},
392 {LDAP_PASSWD_SYNC_ONLY, "only"},
393 {-1, NULL}
394 };
395
396 static const struct enum_list enum_map_readonly[] = {
397 {MAP_READONLY_NO, "no"},
398 {MAP_READONLY_NO, "false"},
399 {MAP_READONLY_NO, "0"},
400 {MAP_READONLY_YES, "yes"},
401 {MAP_READONLY_YES, "true"},
402 {MAP_READONLY_YES, "1"},
403 {MAP_READONLY_PERMISSIONS, "permissions"},
404 {MAP_READONLY_PERMISSIONS, "perms"},
405 {-1, NULL}
406 };
407
408 static const struct enum_list enum_case[] = {
409 {CASE_LOWER, "lower"},
410 {CASE_UPPER, "upper"},
411 {-1, NULL}
412 };
413
414
415
416 static const struct enum_list enum_bool_auto[] = {
417 {false, "No"},
418 {false, "False"},
419 {false, "0"},
420 {true, "Yes"},
421 {true, "True"},
422 {true, "1"},
423 {Auto, "Auto"},
424 {-1, NULL}
425 };
426
427 static const struct enum_list enum_csc_policy[] = {
428 {CSC_POLICY_MANUAL, "manual"},
429 {CSC_POLICY_DOCUMENTS, "documents"},
430 {CSC_POLICY_PROGRAMS, "programs"},
431 {CSC_POLICY_DISABLE, "disable"},
432 {-1, NULL}
433 };
434
435 /* SMB signing types. */
436 static const struct enum_list enum_smb_signing_vals[] = {
437 {false, "No"},
438 {false, "False"},
439 {false, "0"},
440 {false, "Off"},
441 {false, "disabled"},
442 {true, "Yes"},
443 {true, "True"},
444 {true, "1"},
445 {true, "On"},
446 {true, "enabled"},
447 {Auto, "auto"},
448 {Required, "required"},
449 {Required, "mandatory"},
450 {Required, "force"},
451 {Required, "forced"},
452 {Required, "enforced"},
453 {-1, NULL}
454 };
455
456 /* ACL compatibility options. */
457 static const struct enum_list enum_acl_compat_vals[] = {
458 { ACL_COMPAT_AUTO, "auto" },
459 { ACL_COMPAT_WINNT, "winnt" },
460 { ACL_COMPAT_WIN2K, "win2k" },
461 { -1, NULL}
462 };
463
464 /*
465 Do you want session setups at user level security with a invalid
466 password to be rejected or allowed in as guest? WinNT rejects them
467 but it can be a pain as it means "net view" needs to use a password
468
469 You have 3 choices in the setting of map_to_guest:
470
471 "Never" means session setups with an invalid password
472 are rejected. This is the default.
473
474 "Bad User" means session setups with an invalid password
475 are rejected, unless the username does not exist, in which case it
476 is treated as a guest login
477
478 "Bad Password" means session setups with an invalid password
479 are treated as a guest login
480
481 Note that map_to_guest only has an effect in user or server
482 level security.
483 */
484
485 static const struct enum_list enum_map_to_guest[] = {
486 {NEVER_MAP_TO_GUEST, "Never"},
487 {MAP_TO_GUEST_ON_BAD_USER, "Bad User"},
488 {MAP_TO_GUEST_ON_BAD_PASSWORD, "Bad Password"},
489 {MAP_TO_GUEST_ON_BAD_UID, "Bad Uid"},
490 {-1, NULL}
491 };
492
493 /* Config backend options */
494
495 static const struct enum_list enum_config_backend[] = {
496 {CONFIG_BACKEND_FILE, "file"},
497 {CONFIG_BACKEND_REGISTRY, "registry"},
498 {-1, NULL}
499 };
500
501 /* ADS kerberos ticket verification options */
502
503 static const struct enum_list enum_kerberos_method[] = {
504 {KERBEROS_VERIFY_SECRETS, "default"},
505 {KERBEROS_VERIFY_SECRETS, "secrets only"},
506 {KERBEROS_VERIFY_SYSTEM_KEYTAB, "system keytab"},
507 {KERBEROS_VERIFY_DEDICATED_KEYTAB, "dedicated keytab"},
508 {KERBEROS_VERIFY_SECRETS_AND_KEYTAB, "secrets and keytab"},
509 {-1, NULL}
510 };
511
512 /* Note: We do not initialise the defaults union - it is not allowed in ANSI C
513 *
514 * The FLAG_HIDE is explicit. Parameters set this way do NOT appear in any edit
515 * screen in SWAT. This is used to exclude parameters as well as to squash all
516 * parameters that have been duplicated by pseudonyms.
517 *
518 * NOTE: To display a parameter in BASIC view set FLAG_BASIC
519 * Any parameter that does NOT have FLAG_ADVANCED will not disply at all
520 * Set FLAG_SHARE and FLAG_PRINT to specifically display parameters in
521 * respective views.
522 *
523 * NOTE2: Handling of duplicated (synonym) parameters:
524 * Only the first occurance of a parameter should be enabled by FLAG_BASIC
525 * and/or FLAG_ADVANCED. All duplicates following the first mention should be
526 * set to FLAG_HIDE. ie: Make you must place the parameter that has the preferred
527 * name first, and all synonyms must follow it with the FLAG_HIDE attribute.
528 */
529
530 #define GLOBAL_VAR(name) offsetof(struct loadparm_global, name)
531 #define LOCAL_VAR(name) offsetof(struct loadparm_service, name)
532
533 static struct parm_struct parm_table[] = {
534 {N_("Base Options"), P_SEP, P_SEPARATOR},
535
536 {
537 .label = "dos charset",
538 .type = P_STRING,
539 .p_class = P_GLOBAL,
540 .offset = GLOBAL_VAR(dos_charset),
541 .special = handle_dos_charset,
542 .enum_list = NULL,
543 .flags = FLAG_ADVANCED
544 },
545 {
546 .label = "unix charset",
547 .type = P_STRING,
548 .p_class = P_GLOBAL,
549 .offset = GLOBAL_VAR(unix_charset),
550 .special = handle_charset,
551 .enum_list = NULL,
552 .flags = FLAG_ADVANCED
553 },
554 {
555 .label = "comment",
556 .type = P_STRING,
557 .p_class = P_LOCAL,
558 .offset = LOCAL_VAR(comment),
559 .special = NULL,
560 .enum_list = NULL,
561 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT
562 },
563 {
564 .label = "path",
565 .type = P_STRING,
566 .p_class = P_LOCAL,
567 .offset = LOCAL_VAR(szPath),
568 .special = NULL,
569 .enum_list = NULL,
570 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
571 },
572 {
573 .label = "directory",
574 .type = P_STRING,
575 .p_class = P_LOCAL,
576 .offset = LOCAL_VAR(szPath),
577 .special = NULL,
578 .enum_list = NULL,
579 .flags = FLAG_HIDE,
580 },
581 {
582 .label = "workgroup",
583 .type = P_USTRING,
584 .p_class = P_GLOBAL,
585 .offset = GLOBAL_VAR(szWorkgroup),
586 .special = NULL,
587 .enum_list = NULL,
588 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
589 },
590 {
591 .label = "realm",
592 .type = P_USTRING,
593 .p_class = P_GLOBAL,
594 .offset = GLOBAL_VAR(szRealm),
595 .special = handle_realm,
596 .enum_list = NULL,
597 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
598 },
599 {
600 .label = "netbios name",
601 .type = P_USTRING,
602 .p_class = P_GLOBAL,
603 .offset = GLOBAL_VAR(szNetbiosName),
604 .special = NULL,
605 .enum_list = NULL,
606 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
607 },
608 {
609 .label = "netbios aliases",
610 .type = P_LIST,
611 .p_class = P_GLOBAL,
612 .offset = GLOBAL_VAR(szNetbiosAliases),
613 .special = handle_netbios_aliases,
614 .enum_list = NULL,
615 .flags = FLAG_ADVANCED,
616 },
617 {
618 .label = "netbios scope",
619 .type = P_USTRING,
620 .p_class = P_GLOBAL,
621 .offset = GLOBAL_VAR(szNetbiosScope),
622 .special = NULL,
623 .enum_list = NULL,
624 .flags = FLAG_ADVANCED,
625 },
626 {
627 .label = "server string",
628 .type = P_STRING,
629 .p_class = P_GLOBAL,
630 .offset = GLOBAL_VAR(szServerString),
631 .special = NULL,
632 .enum_list = NULL,
633 .flags = FLAG_BASIC | FLAG_ADVANCED,
634 },
635 {
636 .label = "interfaces",
637 .type = P_LIST,
638 .p_class = P_GLOBAL,
639 .offset = GLOBAL_VAR(szInterfaces),
640 .special = NULL,
641 .enum_list = NULL,
642 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
643 },
644 {
645 .label = "bind interfaces only",
646 .type = P_BOOL,
647 .p_class = P_GLOBAL,
648 .offset = GLOBAL_VAR(bBindInterfacesOnly),
649 .special = NULL,
650 .enum_list = NULL,
651 .flags = FLAG_ADVANCED | FLAG_WIZARD,
652 },
653 {
654 .label = "config backend",
655 .type = P_ENUM,
656 .p_class = P_GLOBAL,
657 .offset = GLOBAL_VAR(ConfigBackend),
658 .special = NULL,
659 .enum_list = enum_config_backend,
660 .flags = FLAG_HIDE|FLAG_ADVANCED|FLAG_META,
661 },
662
663 {N_("Security Options"), P_SEP, P_SEPARATOR},
664
665 {
666 .label = "security",
667 .type = P_ENUM,
668 .p_class = P_GLOBAL,
669 .offset = GLOBAL_VAR(security),
670 .special = NULL,
671 .enum_list = enum_security,
672 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
673 },
674 {
675 .label = "auth methods",
676 .type = P_LIST,
677 .p_class = P_GLOBAL,
678 .offset = GLOBAL_VAR(AuthMethods),
679 .special = NULL,
680 .enum_list = NULL,
681 .flags = FLAG_ADVANCED,
682 },
683 {
684 .label = "encrypt passwords",
685 .type = P_BOOL,
686 .p_class = P_GLOBAL,
687 .offset = GLOBAL_VAR(bEncryptPasswords),
688 .special = NULL,
689 .enum_list = NULL,
690 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
691 },
692 {
693 .label = "client schannel",
694 .type = P_ENUM,
695 .p_class = P_GLOBAL,
696 .offset = GLOBAL_VAR(clientSchannel),
697 .special = NULL,
698 .enum_list = enum_bool_auto,
699 .flags = FLAG_BASIC | FLAG_ADVANCED,
700 },
701 {
702 .label = "server schannel",
703 .type = P_ENUM,
704 .p_class = P_GLOBAL,
705 .offset = GLOBAL_VAR(serverSchannel),
706 .special = NULL,
707 .enum_list = enum_bool_auto,
708 .flags = FLAG_BASIC | FLAG_ADVANCED,
709 },
710 {
711 .label = "allow trusted domains",
712 .type = P_BOOL,
713 .p_class = P_GLOBAL,
714 .offset = GLOBAL_VAR(bAllowTrustedDomains),
715 .special = NULL,
716 .enum_list = NULL,
717 .flags = FLAG_ADVANCED,
718 },
719 {
720 .label = "map to guest",
721 .type = P_ENUM,
722 .p_class = P_GLOBAL,
723 .offset = GLOBAL_VAR(map_to_guest),
724 .special = NULL,
725 .enum_list = enum_map_to_guest,
726 .flags = FLAG_ADVANCED,
727 },
728 {
729 .label = "null passwords",
730 .type = P_BOOL,
731 .p_class = P_GLOBAL,
732 .offset = GLOBAL_VAR(bNullPasswords),
733 .special = NULL,
734 .enum_list = NULL,
735 .flags = FLAG_ADVANCED | FLAG_DEPRECATED,
736 },
737 {
738 .label = "obey pam restrictions",
739 .type = P_BOOL,
740 .p_class = P_GLOBAL,
741 .offset = GLOBAL_VAR(bObeyPamRestrictions),
742 .special = NULL,
743 .enum_list = NULL,
744 .flags = FLAG_ADVANCED,
745 },
746 {
747 .label = "password server",
748 .type = P_STRING,
749 .p_class = P_GLOBAL,
750 .offset = GLOBAL_VAR(szPasswordServer),
751 .special = NULL,
752 .enum_list = NULL,
753 .flags = FLAG_ADVANCED | FLAG_WIZARD,
754 },
755 {
756 .label = "smb passwd file",
757 .type = P_STRING,
758 .p_class = P_GLOBAL,
759 .offset = GLOBAL_VAR(szSMBPasswdFile),
760 .special = NULL,
761 .enum_list = NULL,
762 .flags = FLAG_ADVANCED,
763 },
764 {
765 .label = "private dir",
766 .type = P_STRING,
767 .p_class = P_GLOBAL,
768 .offset = GLOBAL_VAR(szPrivateDir),
769 .special = NULL,
770 .enum_list = NULL,
771 .flags = FLAG_ADVANCED,
772 },
773 {
774 .label = "passdb backend",
775 .type = P_STRING,
776 .p_class = P_GLOBAL,
777 .offset = GLOBAL_VAR(szPassdbBackend),
778 .special = NULL,
779 .enum_list = NULL,
780 .flags = FLAG_ADVANCED | FLAG_WIZARD,
781 },
782 {
783 .label = "algorithmic rid base",
784 .type = P_INTEGER,
785 .p_class = P_GLOBAL,
786 .offset = GLOBAL_VAR(AlgorithmicRidBase),
787 .special = NULL,
788 .enum_list = NULL,
789 .flags = FLAG_ADVANCED,
790 },
791 {
792 .label = "root directory",
793 .type = P_STRING,
794 .p_class = P_GLOBAL,
795 .offset = GLOBAL_VAR(szRootdir),
796 .special = NULL,
797 .enum_list = NULL,
798 .flags = FLAG_ADVANCED,
799 },
800 {
801 .label = "root dir",
802 .type = P_STRING,
803 .p_class = P_GLOBAL,
804 .offset = GLOBAL_VAR(szRootdir),
805 .special = NULL,
806 .enum_list = NULL,
807 .flags = FLAG_HIDE,
808 },
809 {
810 .label = "root",
811 .type = P_STRING,
812 .p_class = P_GLOBAL,
813 .offset = GLOBAL_VAR(szRootdir),
814 .special = NULL,
815 .enum_list = NULL,
816 .flags = FLAG_HIDE,
817 },
818 {
819 .label = "guest account",
820 .type = P_STRING,
821 .p_class = P_GLOBAL,
822 .offset = GLOBAL_VAR(szGuestaccount),
823 .special = NULL,
824 .enum_list = NULL,
825 .flags = FLAG_BASIC | FLAG_ADVANCED,
826 },
827 {
828 .label = "enable privileges",
829 .type = P_BOOL,
830 .p_class = P_GLOBAL,
831 .offset = GLOBAL_VAR(bEnablePrivileges),
832 .special = NULL,
833 .enum_list = NULL,
834 .flags = FLAG_ADVANCED | FLAG_DEPRECATED,
835 },
836
837 {
838 .label = "pam password change",
839 .type = P_BOOL,
840 .p_class = P_GLOBAL,
841 .offset = GLOBAL_VAR(bPamPasswordChange),
842 .special = NULL,
843 .enum_list = NULL,
844 .flags = FLAG_ADVANCED,
845 },
846 {
847 .label = "passwd program",
848 .type = P_STRING,
849 .p_class = P_GLOBAL,
850 .offset = GLOBAL_VAR(szPasswdProgram),
851 .special = NULL,
852 .enum_list = NULL,
853 .flags = FLAG_ADVANCED,
854 },
855 {
856 .label = "passwd chat",
857 .type = P_STRING,
858 .p_class = P_GLOBAL,
859 .offset = GLOBAL_VAR(szPasswdChat),
860 .special = NULL,
861 .enum_list = NULL,
862 .flags = FLAG_ADVANCED,
863 },
864 {
865 .label = "passwd chat debug",
866 .type = P_BOOL,
867 .p_class = P_GLOBAL,
868 .offset = GLOBAL_VAR(bPasswdChatDebug),
869 .special = NULL,
870 .enum_list = NULL,
871 .flags = FLAG_ADVANCED,
872 },
873 {
874 .label = "passwd chat timeout",
875 .type = P_INTEGER,
876 .p_class = P_GLOBAL,
877 .offset = GLOBAL_VAR(iPasswdChatTimeout),
878 .special = NULL,
879 .enum_list = NULL,
880 .flags = FLAG_ADVANCED,
881 },
882 {
883 .label = "check password script",
884 .type = P_STRING,
885 .p_class = P_GLOBAL,
886 .offset = GLOBAL_VAR(szCheckPasswordScript),
887 .special = NULL,
888 .enum_list = NULL,
889 .flags = FLAG_ADVANCED,
890 },
891 {
892 .label = "username map",
893 .type = P_STRING,
894 .p_class = P_GLOBAL,
895 .offset = GLOBAL_VAR(szUsernameMap),
896 .special = NULL,
897 .enum_list = NULL,
898 .flags = FLAG_ADVANCED,
899 },
900 {
901 .label = "password level",
902 .type = P_INTEGER,
903 .p_class = P_GLOBAL,
904 .offset = GLOBAL_VAR(pwordlevel),
905 .special = NULL,
906 .enum_list = NULL,
907 .flags = FLAG_ADVANCED | FLAG_DEPRECATED,
908 },
909 {
910 .label = "username level",
911 .type = P_INTEGER,
912 .p_class = P_GLOBAL,
913 .offset = GLOBAL_VAR(unamelevel),
914 .special = NULL,
915 .enum_list = NULL,
916 .flags = FLAG_ADVANCED,
917 },
918 {
919 .label = "unix password sync",
920 .type = P_BOOL,
921 .p_class = P_GLOBAL,
922 .offset = GLOBAL_VAR(bUnixPasswdSync),
923 .special = NULL,
924 .enum_list = NULL,
925 .flags = FLAG_ADVANCED,
926 },
927 {
928 .label = "restrict anonymous",
929 .type = P_INTEGER,
930 .p_class = P_GLOBAL,
931 .offset = GLOBAL_VAR(restrict_anonymous),
932 .special = NULL,
933 .enum_list = NULL,
934 .flags = FLAG_ADVANCED,
935 },
936 {
937 .label = "lanman auth",
938 .type = P_BOOL,
939 .p_class = P_GLOBAL,
940 .offset = GLOBAL_VAR(bLanmanAuth),
941 .special = NULL,
942 .enum_list = NULL,
943 .flags = FLAG_ADVANCED,
944 },
945 {
946 .label = "ntlm auth",
947 .type = P_BOOL,
948 .p_class = P_GLOBAL,
949 .offset = GLOBAL_VAR(bNTLMAuth),
950 .special = NULL,
951 .enum_list = NULL,
952 .flags = FLAG_ADVANCED,
953 },
954 {
955 .label = "client NTLMv2 auth",
956 .type = P_BOOL,
957 .p_class = P_GLOBAL,
958 .offset = GLOBAL_VAR(bClientNTLMv2Auth),
959 .special = NULL,
960 .enum_list = NULL,
961 .flags = FLAG_ADVANCED,
962 },
963 {
964 .label = "client lanman auth",
965 .type = P_BOOL,
966 .p_class = P_GLOBAL,
967 .offset = GLOBAL_VAR(bClientLanManAuth),
968 .special = NULL,
969 .enum_list = NULL,
970 .flags = FLAG_ADVANCED,
971 },
972 {
973 .label = "client plaintext auth",
974 .type = P_BOOL,
975 .p_class = P_GLOBAL,
976 .offset = GLOBAL_VAR(bClientPlaintextAuth),
977 .special = NULL,
978 .enum_list = NULL,
979 .flags = FLAG_ADVANCED,
980 },
981 {
982 .label = "client use spnego principal",
983 .type = P_BOOL,
984 .p_class = P_GLOBAL,
985 .offset = GLOBAL_VAR(client_use_spnego_principal),
986 .special = NULL,
987 .enum_list = NULL,
988 .flags = FLAG_ADVANCED,
989 },
990 {
991 .label = "send spnego principal",
992 .type = P_BOOL,
993 .p_class = P_GLOBAL,
994 .offset = GLOBAL_VAR(send_spnego_principal),
995 .special = NULL,
996 .enum_list = NULL,
997 .flags = FLAG_ADVANCED,
998 },
999 {
1000 .label = "username",
1001 .type = P_STRING,
1002 .p_class = P_LOCAL,
1003 .offset = LOCAL_VAR(szUsername),
1004 .special = NULL,
1005 .enum_list = NULL,
1006 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE | FLAG_DEPRECATED,
1007 },
1008 {
1009 .label = "user",
1010 .type = P_STRING,
1011 .p_class = P_LOCAL,
1012 .offset = LOCAL_VAR(szUsername),
1013 .special = NULL,
1014 .enum_list = NULL,
1015 .flags = FLAG_HIDE,
1016 },
1017 {
1018 .label = "users",
1019 .type = P_STRING,
1020 .p_class = P_LOCAL,
1021 .offset = LOCAL_VAR(szUsername),
1022 .special = NULL,
1023 .enum_list = NULL,
1024 .flags = FLAG_HIDE,
1025 },
1026 {
1027 .label = "invalid users",
1028 .type = P_LIST,
1029 .p_class = P_LOCAL,
1030 .offset = LOCAL_VAR(szInvalidUsers),
1031 .special = NULL,
1032 .enum_list = NULL,
1033 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1034 },
1035 {
1036 .label = "valid users",
1037 .type = P_LIST,
1038 .p_class = P_LOCAL,
1039 .offset = LOCAL_VAR(szValidUsers),
1040 .special = NULL,
1041 .enum_list = NULL,
1042 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1043 },
1044 {
1045 .label = "admin users",
1046 .type = P_LIST,
1047 .p_class = P_LOCAL,
1048 .offset = LOCAL_VAR(szAdminUsers),
1049 .special = NULL,
1050 .enum_list = NULL,
1051 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1052 },
1053 {
1054 .label = "read list",
1055 .type = P_LIST,
1056 .p_class = P_LOCAL,
1057 .offset = LOCAL_VAR(readlist),
1058 .special = NULL,
1059 .enum_list = NULL,
1060 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1061 },
1062 {
1063 .label = "write list",
1064 .type = P_LIST,
1065 .p_class = P_LOCAL,
1066 .offset = LOCAL_VAR(writelist),
1067 .special = NULL,
1068 .enum_list = NULL,
1069 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1070 },
1071 {
1072 .label = "printer admin",
1073 .type = P_LIST,
1074 .p_class = P_LOCAL,
1075 .offset = LOCAL_VAR(printer_admin),
1076 .special = NULL,
1077 .enum_list = NULL,
1078 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_PRINT | FLAG_DEPRECATED,
1079 },
1080 {
1081 .label = "force user",
1082 .type = P_STRING,
1083 .p_class = P_LOCAL,
1084 .offset = LOCAL_VAR(force_user),
1085 .special = NULL,
1086 .enum_list = NULL,
1087 .flags = FLAG_ADVANCED | FLAG_SHARE,
1088 },
1089 {
1090 .label = "force group",
1091 .type = P_STRING,
1092 .p_class = P_LOCAL,
1093 .offset = LOCAL_VAR(force_group),
1094 .special = NULL,
1095 .enum_list = NULL,
1096 .flags = FLAG_ADVANCED | FLAG_SHARE,
1097 },
1098 {
1099 .label = "group",
1100 .type = P_STRING,
1101 .p_class = P_LOCAL,
1102 .offset = LOCAL_VAR(force_group),
1103 .special = NULL,
1104 .enum_list = NULL,
1105 .flags = FLAG_ADVANCED,
1106 },
1107 {
1108 .label = "read only",
1109 .type = P_BOOL,
1110 .p_class = P_LOCAL,
1111 .offset = LOCAL_VAR(bRead_only),
1112 .special = NULL,
1113 .enum_list = NULL,
1114 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE,
1115 },
1116 {
1117 .label = "write ok",
1118 .type = P_BOOLREV,
1119 .p_class = P_LOCAL,
1120 .offset = LOCAL_VAR(bRead_only),
1121 .special = NULL,
1122 .enum_list = NULL,
1123 .flags = FLAG_HIDE,
1124 },
1125 {
1126 .label = "writeable",
1127 .type = P_BOOLREV,
1128 .p_class = P_LOCAL,
1129 .offset = LOCAL_VAR(bRead_only),
1130 .special = NULL,
1131 .enum_list = NULL,
1132 .flags = FLAG_HIDE,
1133 },
1134 {
1135 .label = "writable",
1136 .type = P_BOOLREV,
1137 .p_class = P_LOCAL,
1138 .offset = LOCAL_VAR(bRead_only),
1139 .special = NULL,
1140 .enum_list = NULL,
1141 .flags = FLAG_HIDE,
1142 },
1143 {
1144 .label = "acl check permissions",
1145 .type = P_BOOL,
1146 .p_class = P_LOCAL,
1147 .offset = LOCAL_VAR(bAclCheckPermissions),
1148 .special = NULL,
1149 .enum_list = NULL,
1150 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1151 },
1152 {
1153 .label = "acl group control",
1154 .type = P_BOOL,
1155 .p_class = P_LOCAL,
1156 .offset = LOCAL_VAR(bAclGroupControl),
1157 .special = NULL,
1158 .enum_list = NULL,
1159 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1160 },
1161 {
1162 .label = "acl map full control",
1163 .type = P_BOOL,
1164 .p_class = P_LOCAL,
1165 .offset = LOCAL_VAR(bAclMapFullControl),
1166 .special = NULL,
1167 .enum_list = NULL,
1168 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1169 },
1170 {
1171 .label = "create mask",
1172 .type = P_OCTAL,
1173 .p_class = P_LOCAL,
1174 .offset = LOCAL_VAR(iCreate_mask),
1175 .special = NULL,
1176 .enum_list = NULL,
1177 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1178 },
1179 {
1180 .label = "create mode",
1181 .type = P_OCTAL,
1182 .p_class = P_LOCAL,
1183 .offset = LOCAL_VAR(iCreate_mask),
1184 .special = NULL,
1185 .enum_list = NULL,
1186 .flags = FLAG_HIDE,
1187 },
1188 {
1189 .label = "force create mode",
1190 .type = P_OCTAL,
1191 .p_class = P_LOCAL,
1192 .offset = LOCAL_VAR(iCreate_force_mode),
1193 .special = NULL,
1194 .enum_list = NULL,
1195 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1196 },
1197 {
1198 .label = "security mask",
1199 .type = P_OCTAL,
1200 .p_class = P_LOCAL,
1201 .offset = LOCAL_VAR(iSecurity_mask),
1202 .special = NULL,
1203 .enum_list = NULL,
1204 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1205 },
1206 {
1207 .label = "force security mode",
1208 .type = P_OCTAL,
1209 .p_class = P_LOCAL,
1210 .offset = LOCAL_VAR(iSecurity_force_mode),
1211 .special = NULL,
1212 .enum_list = NULL,
1213 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1214 },
1215 {
1216 .label = "directory mask",
1217 .type = P_OCTAL,
1218 .p_class = P_LOCAL,
1219 .offset = LOCAL_VAR(iDir_mask),
1220 .special = NULL,
1221 .enum_list = NULL,
1222 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1223 },
1224 {
1225 .label = "directory mode",
1226 .type = P_OCTAL,
1227 .p_class = P_LOCAL,
1228 .offset = LOCAL_VAR(iDir_mask),
1229 .special = NULL,
1230 .enum_list = NULL,
1231 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
1232 },
1233 {
1234 .label = "force directory mode",
1235 .type = P_OCTAL,
1236 .p_class = P_LOCAL,
1237 .offset = LOCAL_VAR(iDir_force_mode),
1238 .special = NULL,
1239 .enum_list = NULL,
1240 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1241 },
1242 {
1243 .label = "directory security mask",
1244 .type = P_OCTAL,
1245 .p_class = P_LOCAL,
1246 .offset = LOCAL_VAR(iDir_Security_mask),
1247 .special = NULL,
1248 .enum_list = NULL,
1249 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1250 },
1251 {
1252 .label = "force directory security mode",
1253 .type = P_OCTAL,
1254 .p_class = P_LOCAL,
1255 .offset = LOCAL_VAR(iDir_Security_force_mode),
1256 .special = NULL,
1257 .enum_list = NULL,
1258 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1259 },
1260 {
1261 .label = "force unknown acl user",
1262 .type = P_BOOL,
1263 .p_class = P_LOCAL,
1264 .offset = LOCAL_VAR(bForceUnknownAclUser),
1265 .special = NULL,
1266 .enum_list = NULL,
1267 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1268 },
1269 {
1270 .label = "inherit permissions",
1271 .type = P_BOOL,
1272 .p_class = P_LOCAL,
1273 .offset = LOCAL_VAR(bInheritPerms),
1274 .special = NULL,
1275 .enum_list = NULL,
1276 .flags = FLAG_ADVANCED | FLAG_SHARE,
1277 },
1278 {
1279 .label = "inherit acls",
1280 .type = P_BOOL,
1281 .p_class = P_LOCAL,
1282 .offset = LOCAL_VAR(bInheritACLS),
1283 .special = NULL,
1284 .enum_list = NULL,
1285 .flags = FLAG_ADVANCED | FLAG_SHARE,
1286 },
1287 {
1288 .label = "inherit owner",
1289 .type = P_BOOL,
1290 .p_class = P_LOCAL,
1291 .offset = LOCAL_VAR(bInheritOwner),
1292 .special = NULL,
1293 .enum_list = NULL,
1294 .flags = FLAG_ADVANCED | FLAG_SHARE,
1295 },
1296 {
1297 .label = "guest only",
1298 .type = P_BOOL,
1299 .p_class = P_LOCAL,
1300 .offset = LOCAL_VAR(bGuest_only),
1301 .special = NULL,
1302 .enum_list = NULL,
1303 .flags = FLAG_ADVANCED | FLAG_SHARE,
1304 },
1305 {
1306 .label = "only guest",
1307 .type = P_BOOL,
1308 .p_class = P_LOCAL,
1309 .offset = LOCAL_VAR(bGuest_only),
1310 .special = NULL,
1311 .enum_list = NULL,
1312 .flags = FLAG_HIDE,
1313 },
1314 {
1315 .label = "administrative share",
1316 .type = P_BOOL,
1317 .p_class = P_LOCAL,
1318 .offset = LOCAL_VAR(bAdministrative_share),
1319 .special = NULL,
1320 .enum_list = NULL,
1321 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
1322 },
1323
1324 {
1325 .label = "guest ok",
1326 .type = P_BOOL,
1327 .p_class = P_LOCAL,
1328 .offset = LOCAL_VAR(bGuest_ok),
1329 .special = NULL,
1330 .enum_list = NULL,
1331 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
1332 },
1333 {
1334 .label = "public",
1335 .type = P_BOOL,
1336 .p_class = P_LOCAL,
1337 .offset = LOCAL_VAR(bGuest_ok),
1338 .special = NULL,
1339 .enum_list = NULL,
1340 .flags = FLAG_HIDE,
1341 },
1342 {
1343 .label = "only user",
1344 .type = P_BOOL,
1345 .p_class = P_LOCAL,
1346 .offset = LOCAL_VAR(bOnlyUser),
1347 .special = NULL,
1348 .enum_list = NULL,
1349 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_DEPRECATED,
1350 },
1351 {
1352 .label = "hosts allow",
1353 .type = P_LIST,
1354 .p_class = P_LOCAL,
1355 .offset = LOCAL_VAR(szHostsallow),
1356 .special = NULL,
1357 .enum_list = NULL,
1358 .flags = FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
1359 },
1360 {
1361 .label = "allow hosts",
1362 .type = P_LIST,
1363 .p_class = P_LOCAL,
1364 .offset = LOCAL_VAR(szHostsallow),
1365 .special = NULL,
1366 .enum_list = NULL,
1367 .flags = FLAG_HIDE,
1368 },
1369 {
1370 .label = "hosts deny",
1371 .type = P_LIST,
1372 .p_class = P_LOCAL,
1373 .offset = LOCAL_VAR(szHostsdeny),
1374 .special = NULL,
1375 .enum_list = NULL,
1376 .flags = FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
1377 },
1378 {
1379 .label = "deny hosts",
1380 .type = P_LIST,
1381 .p_class = P_LOCAL,
1382 .offset = LOCAL_VAR(szHostsdeny),
1383 .special = NULL,
1384 .enum_list = NULL,
1385 .flags = FLAG_HIDE,
1386 },
1387 {
1388 .label = "preload modules",
1389 .type = P_LIST,
1390 .p_class = P_GLOBAL,
1391 .offset = GLOBAL_VAR(szPreloadModules),
1392 .special = NULL,
1393 .enum_list = NULL,
1394 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
1395 },
1396 {
1397 .label = "dedicated keytab file",
1398 .type = P_STRING,
1399 .p_class = P_GLOBAL,
1400 .offset = GLOBAL_VAR(szDedicatedKeytabFile),
1401 .special = NULL,
1402 .enum_list = NULL,
1403 .flags = FLAG_ADVANCED,
1404 },
1405 {
1406 .label = "kerberos method",
1407 .type = P_ENUM,
1408 .p_class = P_GLOBAL,
1409 .offset = GLOBAL_VAR(iKerberosMethod),
1410 .special = NULL,
1411 .enum_list = enum_kerberos_method,
1412 .flags = FLAG_ADVANCED,
1413 },
1414 {
1415 .label = "map untrusted to domain",
1416 .type = P_BOOL,
1417 .p_class = P_GLOBAL,
1418 .offset = GLOBAL_VAR(bMapUntrustedToDomain),
1419 .special = NULL,
1420 .enum_list = NULL,
1421 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
1422 },
1423
1424
1425 {N_("Logging Options"), P_SEP, P_SEPARATOR},
1426
1427 {
1428 .label = "log level",
1429 .type = P_STRING,
1430 .p_class = P_GLOBAL,
1431 .offset = GLOBAL_VAR(szLogLevel),
1432 .special = handle_debug_list,
1433 .enum_list = NULL,
1434 .flags = FLAG_ADVANCED,
1435 },
1436 {
1437 .label = "debuglevel",
1438 .type = P_STRING,
1439 .p_class = P_GLOBAL,
1440 .offset = GLOBAL_VAR(szLogLevel),
1441 .special = handle_debug_list,
1442 .enum_list = NULL,
1443 .flags = FLAG_HIDE,
1444 },
1445 {
1446 .label = "syslog",
1447 .type = P_INTEGER,
1448 .p_class = P_GLOBAL,
1449 .offset = GLOBAL_VAR(syslog),
1450 .special = NULL,
1451 .enum_list = NULL,
1452 .flags = FLAG_ADVANCED,
1453 },
1454 {
1455 .label = "syslog only",
1456 .type = P_BOOL,
1457 .p_class = P_GLOBAL,
1458 .offset = GLOBAL_VAR(bSyslogOnly),
1459 .special = NULL,
1460 .enum_list = NULL,
1461 .flags = FLAG_ADVANCED,
1462 },
1463 {
1464 .label = "log file",
1465 .type = P_STRING,
1466 .p_class = P_GLOBAL,
1467 .offset = GLOBAL_VAR(szLogFile),
1468 .special = NULL,
1469 .enum_list = NULL,
1470 .flags = FLAG_ADVANCED,
1471 },
1472 {
1473 .label = "max log size",
1474 .type = P_INTEGER,
1475 .p_class = P_GLOBAL,
1476 .offset = GLOBAL_VAR(max_log_size),
1477 .special = NULL,
1478 .enum_list = NULL,
1479 .flags = FLAG_ADVANCED,
1480 },
1481 {
1482 .label = "debug timestamp",
1483 .type = P_BOOL,
1484 .p_class = P_GLOBAL,
1485 .offset = GLOBAL_VAR(bTimestampLogs),
1486 .special = NULL,
1487 .enum_list = NULL,
1488 .flags = FLAG_ADVANCED,
1489 },
1490 {
1491 .label = "timestamp logs",
1492 .type = P_BOOL,
1493 .p_class = P_GLOBAL,
1494 .offset = GLOBAL_VAR(bTimestampLogs),
1495 .special = NULL,
1496 .enum_list = NULL,
1497 .flags = FLAG_ADVANCED,
1498 },
1499 {
1500 .label = "debug prefix timestamp",
1501 .type = P_BOOL,
1502 .p_class = P_GLOBAL,
1503 .offset = GLOBAL_VAR(bDebugPrefixTimestamp),
1504 .special = NULL,
1505 .enum_list = NULL,
1506 .flags = FLAG_ADVANCED,
1507 },
1508 {
1509 .label = "debug hires timestamp",
1510 .type = P_BOOL,
1511 .p_class = P_GLOBAL,
1512 .offset = GLOBAL_VAR(bDebugHiresTimestamp),
1513 .special = NULL,
1514 .enum_list = NULL,
1515 .flags = FLAG_ADVANCED,
1516 },
1517 {
1518 .label = "debug pid",
1519 .type = P_BOOL,
1520 .p_class = P_GLOBAL,
1521 .offset = GLOBAL_VAR(bDebugPid),
1522 .special = NULL,
1523 .enum_list = NULL,
1524 .flags = FLAG_ADVANCED,
1525 },
1526 {
1527 .label = "debug uid",
1528 .type = P_BOOL,
1529 .p_class = P_GLOBAL,
1530 .offset = GLOBAL_VAR(bDebugUid),
1531 .special = NULL,
1532 .enum_list = NULL,
1533 .flags = FLAG_ADVANCED,
1534 },
1535 {
1536 .label = "debug class",
1537 .type = P_BOOL,
1538 .p_class = P_GLOBAL,
1539 .offset = GLOBAL_VAR(bDebugClass),
1540 .special = NULL,
1541 .enum_list = NULL,
1542 .flags = FLAG_ADVANCED,
1543 },
1544 {
1545 .label = "enable core files",
1546 .type = P_BOOL,
1547 .p_class = P_GLOBAL,
1548 .offset = GLOBAL_VAR(bEnableCoreFiles),
1549 .special = NULL,
1550 .enum_list = NULL,
1551 .flags = FLAG_ADVANCED,
1552 },
1553
1554 {N_("Protocol Options"), P_SEP, P_SEPARATOR},
1555
1556 {
1557 .label = "allocation roundup size",
1558 .type = P_INTEGER,
1559 .p_class = P_LOCAL,
1560 .offset = LOCAL_VAR(iallocation_roundup_size),
1561 .special = NULL,
1562 .enum_list = NULL,
1563 .flags = FLAG_ADVANCED,
1564 },
1565 {
1566 .label = "aio read size",
1567 .type = P_INTEGER,
1568 .p_class = P_LOCAL,
1569 .offset = LOCAL_VAR(iAioReadSize),
1570 .special = NULL,
1571 .enum_list = NULL,
1572 .flags = FLAG_ADVANCED,
1573 },
1574 {
1575 .label = "aio write size",
1576 .type = P_INTEGER,
1577 .p_class = P_LOCAL,
1578 .offset = LOCAL_VAR(iAioWriteSize),
1579 .special = NULL,
1580 .enum_list = NULL,
1581 .flags = FLAG_ADVANCED,
1582 },
1583 {
1584 .label = "aio write behind",
1585 .type = P_STRING,
1586 .p_class = P_LOCAL,
1587 .offset = LOCAL_VAR(szAioWriteBehind),
1588 .special = NULL,
1589 .enum_list = NULL,
1590 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
1591 },
1592 {
1593 .label = "smb ports",
1594 .type = P_STRING,
1595 .p_class = P_GLOBAL,
1596 .offset = GLOBAL_VAR(smb_ports),
1597 .special = NULL,
1598 .enum_list = NULL,
1599 .flags = FLAG_ADVANCED,
1600 },
1601 {
1602 .label = "large readwrite",
1603 .type = P_BOOL,
1604 .p_class = P_GLOBAL,
1605 .offset = GLOBAL_VAR(bLargeReadwrite),
1606 .special = NULL,
1607 .enum_list = NULL,
1608 .flags = FLAG_ADVANCED,
1609 },
1610 {
1611 .label = "max protocol",
1612 .type = P_ENUM,
1613 .p_class = P_GLOBAL,
1614 .offset = GLOBAL_VAR(maxprotocol),
1615 .special = NULL,
1616 .enum_list = enum_protocol,
1617 .flags = FLAG_ADVANCED,
1618 },
1619 {
1620 .label = "protocol",
1621 .type = P_ENUM,
1622 .p_class = P_GLOBAL,
1623 .offset = GLOBAL_VAR(maxprotocol),
1624 .special = NULL,
1625 .enum_list = enum_protocol,
1626 .flags = FLAG_ADVANCED,
1627 },
1628 {
1629 .label = "min protocol",
1630 .type = P_ENUM,
1631 .p_class = P_GLOBAL,
1632 .offset = GLOBAL_VAR(minprotocol),
1633 .special = NULL,
1634 .enum_list = enum_protocol,
1635 .flags = FLAG_ADVANCED,
1636 },
1637 {
1638 .label = "min receivefile size",
1639 .type = P_INTEGER,
1640 .p_class = P_GLOBAL,
1641 .offset = GLOBAL_VAR(iminreceivefile),
1642 .special = NULL,
1643 .enum_list = NULL,
1644 .flags = FLAG_ADVANCED,
1645 },
1646 {
1647 .label = "read raw",
1648 .type = P_BOOL,
1649 .p_class = P_GLOBAL,
1650 .offset = GLOBAL_VAR(bReadRaw),
1651 .special = NULL,
1652 .enum_list = NULL,
1653 .flags = FLAG_ADVANCED,
1654 },
1655 {
1656 .label = "write raw",
1657 .type = P_BOOL,
1658 .p_class = P_GLOBAL,
1659 .offset = GLOBAL_VAR(bWriteRaw),
1660 .special = NULL,
1661 .enum_list = NULL,
1662 .flags = FLAG_ADVANCED,
1663 },
1664 {
1665 .label = "disable netbios",
1666 .type = P_BOOL,
1667 .p_class = P_GLOBAL,
1668 .offset = GLOBAL_VAR(bDisableNetbios),
1669 .special = NULL,
1670 .enum_list = NULL,
1671 .flags = FLAG_ADVANCED,
1672 },
1673 {
1674 .label = "reset on zero vc",
1675 .type = P_BOOL,
1676 .p_class = P_GLOBAL,
1677 .offset = GLOBAL_VAR(bResetOnZeroVC),
1678 .special = NULL,
1679 .enum_list = NULL,
1680 .flags = FLAG_ADVANCED,
1681 },
1682 {
1683 .label = "log writeable files on exit",
1684 .type = P_BOOL,
1685 .p_class = P_GLOBAL,
1686 .offset = GLOBAL_VAR(bLogWriteableFilesOnExit),
1687 .special = NULL,
1688 .enum_list = NULL,
1689 .flags = FLAG_ADVANCED,
1690 },
1691 {
1692 .label = "acl compatibility",
1693 .type = P_ENUM,
1694 .p_class = P_GLOBAL,
1695 .offset = GLOBAL_VAR(iAclCompat),
1696 .special = NULL,
1697 .enum_list = enum_acl_compat_vals,
1698 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
1699 },
1700 {
1701 .label = "defer sharing violations",
1702 .type = P_BOOL,
1703 .p_class = P_GLOBAL,
1704 .offset = GLOBAL_VAR(bDeferSharingViolations),
1705 .special = NULL,
1706 .enum_list = NULL,
1707 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
1708 },
1709 {
1710 .label = "ea support",
1711 .type = P_BOOL,
1712 .p_class = P_LOCAL,
1713 .offset = LOCAL_VAR(bEASupport),
1714 .special = NULL,
1715 .enum_list = NULL,
1716 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
1717 },
1718 {
1719 .label = "nt acl support",
1720 .type = P_BOOL,
1721 .p_class = P_LOCAL,
1722 .offset = LOCAL_VAR(bNTAclSupport),
1723 .special = NULL,
1724 .enum_list = NULL,
1725 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
1726 },
1727 {
1728 .label = "nt pipe support",
1729 .type = P_BOOL,
1730 .p_class = P_GLOBAL,
1731 .offset = GLOBAL_VAR(bNTPipeSupport),
1732 .special = NULL,
1733 .enum_list = NULL,
1734 .flags = FLAG_ADVANCED,
1735 },
1736 {
1737 .label = "nt status support",
1738 .type = P_BOOL,
1739 .p_class = P_GLOBAL,
1740 .offset = GLOBAL_VAR(bNTStatusSupport),
1741 .special = NULL,
1742 .enum_list = NULL,
1743 .flags = FLAG_ADVANCED,
1744 },
1745 {
1746 .label = "profile acls",
1747 .type = P_BOOL,
1748 .p_class = P_LOCAL,
1749 .offset = LOCAL_VAR(bProfileAcls),
1750 .special = NULL,
1751 .enum_list = NULL,
1752 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
1753 },
1754 {
1755 .label = "map acl inherit",
1756 .type = P_BOOL,
1757 .p_class = P_LOCAL,
1758 .offset = LOCAL_VAR(bMap_acl_inherit),
1759 .special = NULL,
1760 .enum_list = NULL,
1761 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
1762 },
1763 {
1764 .label = "afs share",
1765 .type = P_BOOL,
1766 .p_class = P_LOCAL,
1767 .offset = LOCAL_VAR(bAfs_Share),
1768 .special = NULL,
1769 .enum_list = NULL,
1770 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
1771 },
1772 {
1773 .label = "max mux",
1774 .type = P_INTEGER,
1775 .p_class = P_GLOBAL,
1776 .offset = GLOBAL_VAR(max_mux),
1777 .special = NULL,
1778 .enum_list = NULL,
1779 .flags = FLAG_ADVANCED,
1780 },
1781 {
1782 .label = "max xmit",
1783 .type = P_INTEGER,
1784 .p_class = P_GLOBAL,
1785 .offset = GLOBAL_VAR(max_xmit),
1786 .special = NULL,
1787 .enum_list = NULL,
1788 .flags = FLAG_ADVANCED,
1789 },
1790 {
1791 .label = "name resolve order",
1792 .type = P_STRING,
1793 .p_class = P_GLOBAL,
1794 .offset = GLOBAL_VAR(szNameResolveOrder),
1795 .special = NULL,
1796 .enum_list = NULL,
1797 .flags = FLAG_ADVANCED | FLAG_WIZARD,
1798 },
1799 {
1800 .label = "max ttl",
1801 .type = P_INTEGER,
1802 .p_class = P_GLOBAL,
1803 .offset = GLOBAL_VAR(max_ttl),
1804 .special = NULL,
1805 .enum_list = NULL,
1806 .flags = FLAG_ADVANCED,
1807 },
1808 {
1809 .label = "max wins ttl",
1810 .type = P_INTEGER,
1811 .p_class = P_GLOBAL,
1812 .offset = GLOBAL_VAR(max_wins_ttl),
1813 .special = NULL,
1814 .enum_list = NULL,
1815 .flags = FLAG_ADVANCED,
1816 },
1817 {
1818 .label = "min wins ttl",
1819 .type = P_INTEGER,
1820 .p_class = P_GLOBAL,
1821 .offset = GLOBAL_VAR(min_wins_ttl),
1822 .special = NULL,
1823 .enum_list = NULL,
1824 .flags = FLAG_ADVANCED,
1825 },
1826 {
1827 .label = "time server",
1828 .type = P_BOOL,
1829 .p_class = P_GLOBAL,
1830 .offset = GLOBAL_VAR(bTimeServer),
1831 .special = NULL,
1832 .enum_list = NULL,
1833 .flags = FLAG_ADVANCED,
1834 },
1835 {
1836 .label = "unix extensions",
1837 .type = P_BOOL,
1838 .p_class = P_GLOBAL,
1839 .offset = GLOBAL_VAR(bUnixExtensions),
1840 .special = NULL,
1841 .enum_list = NULL,
1842 .flags = FLAG_ADVANCED,
1843 },
1844 {
1845 .label = "use spnego",
1846 .type = P_BOOL,
1847 .p_class = P_GLOBAL,
1848 .offset = GLOBAL_VAR(bUseSpnego),
1849 .special = NULL,
1850 .enum_list = NULL,
1851 .flags = FLAG_ADVANCED | FLAG_DEPRECATED,
1852 },
1853 {
1854 .label = "client signing",
1855 .type = P_ENUM,
1856 .p_class = P_GLOBAL,
1857 .offset = GLOBAL_VAR(client_signing),
1858 .special = NULL,
1859 .enum_list = enum_smb_signing_vals,
1860 .flags = FLAG_ADVANCED,
1861 },
1862 {
1863 .label = "server signing",
1864 .type = P_ENUM,
1865 .p_class = P_GLOBAL,
1866 .offset = GLOBAL_VAR(server_signing),
1867 .special = NULL,
1868 .enum_list = enum_smb_signing_vals,
1869 .flags = FLAG_ADVANCED,
1870 },
1871 {
1872 .label = "smb encrypt",
1873 .type = P_ENUM,
1874 .p_class = P_LOCAL,
1875 .offset = LOCAL_VAR(ismb_encrypt),
1876 .special = NULL,
1877 .enum_list = enum_smb_signing_vals,
1878 .flags = FLAG_ADVANCED,
1879 },
1880 {
1881 .label = "client use spnego",
1882 .type = P_BOOL,
1883 .p_class = P_GLOBAL,
1884 .offset = GLOBAL_VAR(bClientUseSpnego),
1885 .special = NULL,
1886 .enum_list = NULL,
1887 .flags = FLAG_ADVANCED,
1888 },
1889 {
1890 .label = "client ldap sasl wrapping",
1891 .type = P_ENUM,
1892 .p_class = P_GLOBAL,
1893 .offset = GLOBAL_VAR(client_ldap_sasl_wrapping),
1894 .special = NULL,
1895 .enum_list = enum_ldap_sasl_wrapping,
1896 .flags = FLAG_ADVANCED,
1897 },
1898 {
1899 .label = "enable asu support",
1900 .type = P_BOOL,
1901 .p_class = P_GLOBAL,
1902 .offset = GLOBAL_VAR(bASUSupport),
1903 .special = NULL,
1904 .enum_list = NULL,
1905 .flags = FLAG_ADVANCED,
1906 },
1907 {
1908 .label = "svcctl list",
1909 .type = P_LIST,
1910 .p_class = P_GLOBAL,
1911 .offset = GLOBAL_VAR(szServicesList),
1912 .special = NULL,
1913 .enum_list = NULL,
1914 .flags = FLAG_ADVANCED,
1915 },
1916
1917 {N_("Tuning Options"), P_SEP, P_SEPARATOR},
1918
1919 {
1920 .label = "block size",
1921 .type = P_INTEGER,
1922 .p_class = P_LOCAL,
1923 .offset = LOCAL_VAR(iBlock_size),
1924 .special = NULL,
1925 .enum_list = NULL,
1926 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
1927 },
1928 {
1929 .label = "deadtime",
1930 .type = P_INTEGER,
1931 .p_class = P_GLOBAL,
1932 .offset = GLOBAL_VAR(deadtime),
1933 .special = NULL,
1934 .enum_list = NULL,
1935 .flags = FLAG_ADVANCED,
1936 },
1937 {
1938 .label = "getwd cache",
1939 .type = P_BOOL,
1940 .p_class = P_GLOBAL,
1941 .offset = GLOBAL_VAR(getwd_cache),
1942 .special = NULL,
1943 .enum_list = NULL,
1944 .flags = FLAG_ADVANCED,
1945 },
1946 {
1947 .label = "keepalive",
1948 .type = P_INTEGER,
1949 .p_class = P_GLOBAL,
1950 .offset = GLOBAL_VAR(iKeepalive),
1951 .special = NULL,
1952 .enum_list = NULL,
1953 .flags = FLAG_ADVANCED,
1954 },
1955 {
1956 .label = "change notify",
1957 .type = P_BOOL,
1958 .p_class = P_LOCAL,
1959 .offset = LOCAL_VAR(bChangeNotify),
1960 .special = NULL,
1961 .enum_list = NULL,
1962 .flags = FLAG_ADVANCED | FLAG_SHARE,
1963 },
1964 {
1965 .label = "directory name cache size",
1966 .type = P_INTEGER,
1967 .p_class = P_LOCAL,
1968 .offset = LOCAL_VAR(iDirectoryNameCacheSize),
1969 .special = NULL,
1970 .enum_list = NULL,
1971 .flags = FLAG_ADVANCED | FLAG_SHARE,
1972 },
1973 {
1974 .label = "kernel change notify",
1975 .type = P_BOOL,
1976 .p_class = P_LOCAL,
1977 .offset = LOCAL_VAR(bKernelChangeNotify),
1978 .special = NULL,
1979 .enum_list = NULL,
1980 .flags = FLAG_ADVANCED | FLAG_SHARE,
1981 },
1982 {
1983 .label = "lpq cache time",
1984 .type = P_INTEGER,
1985 .p_class = P_GLOBAL,
1986 .offset = GLOBAL_VAR(lpqcachetime),
1987 .special = NULL,
1988 .enum_list = NULL,
1989 .flags = FLAG_ADVANCED,
1990 },
1991 {
1992 .label = "max smbd processes",
1993 .type = P_INTEGER,
1994 .p_class = P_GLOBAL,
1995 .offset = GLOBAL_VAR(iMaxSmbdProcesses),
1996 .special = NULL,
1997 .enum_list = NULL,
1998 .flags = FLAG_ADVANCED,
1999 },
2000 {
2001 .label = "max connections",
2002 .type = P_INTEGER,
2003 .p_class = P_LOCAL,
2004 .offset = LOCAL_VAR(iMaxConnections),
2005 .special = NULL,
2006 .enum_list = NULL,
2007 .flags = FLAG_ADVANCED | FLAG_SHARE,
2008 },
2009 {
2010 .label = "paranoid server security",
2011 .type = P_BOOL,
2012 .p_class = P_GLOBAL,
2013 .offset = GLOBAL_VAR(paranoid_server_security),
2014 .special = NULL,
2015 .enum_list = NULL,
2016 .flags = FLAG_ADVANCED,
2017 },
2018 {
2019 .label = "max disk size",
2020 .type = P_INTEGER,
2021 .p_class = P_GLOBAL,
2022 .offset = GLOBAL_VAR(maxdisksize),
2023 .special = NULL,
2024 .enum_list = NULL,
2025 .flags = FLAG_ADVANCED,
2026 },
2027 {
2028 .label = "max open files",
2029 .type = P_INTEGER,
2030 .p_class = P_GLOBAL,
2031 .offset = GLOBAL_VAR(max_open_files),
2032 .special = NULL,
2033 .enum_list = NULL,
2034 .flags = FLAG_ADVANCED,
2035 },
2036 {
2037 .label = "min print space",
2038 .type = P_INTEGER,
2039 .p_class = P_LOCAL,
2040 .offset = LOCAL_VAR(iMinPrintSpace),
2041 .special = NULL,
2042 .enum_list = NULL,
2043 .flags = FLAG_ADVANCED | FLAG_PRINT,
2044 },
2045 {
2046 .label = "socket options",
2047 .type = P_STRING,
2048 .p_class = P_GLOBAL,
2049 .offset = GLOBAL_VAR(szSocketOptions),
2050 .special = NULL,
2051 .enum_list = NULL,
2052 .flags = FLAG_ADVANCED,
2053 },
2054 {
2055 .label = "strict allocate",
2056 .type = P_BOOL,
2057 .p_class = P_LOCAL,
2058 .offset = LOCAL_VAR(bStrictAllocate),
2059 .special = NULL,
2060 .enum_list = NULL,
2061 .flags = FLAG_ADVANCED | FLAG_SHARE,
2062 },
2063 {
2064 .label = "strict sync",
2065 .type = P_BOOL,
2066 .p_class = P_LOCAL,
2067 .offset = LOCAL_VAR(bStrictSync),
2068 .special = NULL,
2069 .enum_list = NULL,
2070 .flags = FLAG_ADVANCED | FLAG_SHARE,
2071 },
2072 {
2073 .label = "sync always",
2074 .type = P_BOOL,
2075 .p_class = P_LOCAL,
2076 .offset = LOCAL_VAR(bSyncAlways),
2077 .special = NULL,
2078 .enum_list = NULL,
2079 .flags = FLAG_ADVANCED | FLAG_SHARE,
2080 },
2081 {
2082 .label = "use mmap",
2083 .type = P_BOOL,
2084 .p_class = P_GLOBAL,
2085 .offset = GLOBAL_VAR(bUseMmap),
2086 .special = NULL,
2087 .enum_list = NULL,
2088 .flags = FLAG_ADVANCED,
2089 },
2090 {
2091 .label = "use sendfile",
2092 .type = P_BOOL,
2093 .p_class = P_LOCAL,
2094 .offset = LOCAL_VAR(bUseSendfile),
2095 .special = NULL,
2096 .enum_list = NULL,
2097 .flags = FLAG_ADVANCED | FLAG_SHARE,
2098 },
2099 {
2100 .label = "hostname lookups",
2101 .type = P_BOOL,
2102 .p_class = P_GLOBAL,
2103 .offset = GLOBAL_VAR(bHostnameLookups),
2104 .special = NULL,
2105 .enum_list = NULL,
2106 .flags = FLAG_ADVANCED,
2107 },
2108 {
2109 .label = "write cache size",
2110 .type = P_INTEGER,
2111 .p_class = P_LOCAL,
2112 .offset = LOCAL_VAR(iWriteCacheSize),
2113 .special = NULL,
2114 .enum_list = NULL,
2115 .flags = FLAG_ADVANCED | FLAG_SHARE,
2116 },
2117 {
2118 .label = "name cache timeout",
2119 .type = P_INTEGER,
2120 .p_class = P_GLOBAL,
2121 .offset = GLOBAL_VAR(name_cache_timeout),
2122 .special = NULL,
2123 .enum_list = NULL,
2124 .flags = FLAG_ADVANCED,
2125 },
2126 {
2127 .label = "ctdbd socket",
2128 .type = P_STRING,
2129 .p_class = P_GLOBAL,
2130 .offset = GLOBAL_VAR(ctdbdSocket),
2131 .special = NULL,
2132 .enum_list = NULL,
2133 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
2134 },
2135 {
2136 .label = "cluster addresses",
2137 .type = P_LIST,
2138 .p_class = P_GLOBAL,
2139 .offset = GLOBAL_VAR(szClusterAddresses),
2140 .special = NULL,
2141 .enum_list = NULL,
2142 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
2143 },
2144 {
2145 .label = "clustering",
2146 .type = P_BOOL,
2147 .p_class = P_GLOBAL,
2148 .offset = GLOBAL_VAR(clustering),
2149 .special = NULL,
2150 .enum_list = NULL,
2151 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
2152 },
2153 {
2154 .label = "ctdb timeout",
2155 .type = P_INTEGER,
2156 .p_class = P_GLOBAL,
2157 .offset = GLOBAL_VAR(ctdb_timeout),
2158 .special = NULL,
2159 .enum_list = NULL,
2160 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
2161 },
2162 {
2163 .label = "ctdb locktime warn threshold",
2164 .type = P_INTEGER,
2165 .p_class = P_GLOBAL,
2166 .offset = GLOBAL_VAR(ctdb_locktime_warn_threshold),
2167 .special = NULL,
2168 .enum_list = NULL,
2169 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
2170 },
2171 {
2172 .label = "smb2 max read",
2173 .type = P_INTEGER,
2174 .p_class = P_GLOBAL,
2175 .offset = GLOBAL_VAR(ismb2_max_read),
2176 .special = NULL,
2177 .enum_list = NULL,
2178 .flags = FLAG_ADVANCED,
2179 },
2180 {
2181 .label = "smb2 max write",
2182 .type = P_INTEGER,
2183 .p_class = P_GLOBAL,
2184 .offset = GLOBAL_VAR(ismb2_max_write),
2185 .special = NULL,
2186 .enum_list = NULL,
2187 .flags = FLAG_ADVANCED,
2188 },
2189 {
2190 .label = "smb2 max trans",
2191 .type = P_INTEGER,
2192 .p_class = P_GLOBAL,
2193 .offset = GLOBAL_VAR(ismb2_max_trans),
2194 .special = NULL,
2195 .enum_list = NULL,
2196 .flags = FLAG_ADVANCED,
2197 },
2198 {
2199 .label = "smb2 max credits",
2200 .type = P_INTEGER,
2201 .p_class = P_GLOBAL,
2202 .offset = GLOBAL_VAR(ismb2_max_credits),
2203 .special = NULL,
2204 .enum_list = NULL,
2205 .flags = FLAG_ADVANCED,
2206 },
2207
2208 {N_("Printing Options"), P_SEP, P_SEPARATOR},
2209
2210 {
2211 .label = "max reported print jobs",
2212 .type = P_INTEGER,
2213 .p_class = P_LOCAL,
2214 .offset = LOCAL_VAR(iMaxReportedPrintJobs),
2215 .special = NULL,
2216 .enum_list = NULL,
2217 .flags = FLAG_ADVANCED | FLAG_PRINT,
2218 },
2219 {
2220 .label = "max print jobs",
2221 .type = P_INTEGER,
2222 .p_class = P_LOCAL,
2223 .offset = LOCAL_VAR(iMaxPrintJobs),
2224 .special = NULL,
2225 .enum_list = NULL,
2226 .flags = FLAG_ADVANCED | FLAG_PRINT,
2227 },
2228 {
2229 .label = "load printers",
2230 .type = P_BOOL,
2231 .p_class = P_GLOBAL,
2232 .offset = GLOBAL_VAR(bLoadPrinters),
2233 .special = NULL,
2234 .enum_list = NULL,
2235 .flags = FLAG_ADVANCED | FLAG_PRINT,
2236 },
2237 {
2238 .label = "printcap cache time",
2239 .type = P_INTEGER,
2240 .p_class = P_GLOBAL,
2241 .offset = GLOBAL_VAR(PrintcapCacheTime),
2242 .special = NULL,
2243 .enum_list = NULL,
2244 .flags = FLAG_ADVANCED | FLAG_PRINT,
2245 },
2246 {
2247 .label = "printcap name",
2248 .type = P_STRING,
2249 .p_class = P_GLOBAL,
2250 .offset = GLOBAL_VAR(szPrintcapname),
2251 .special = NULL,
2252 .enum_list = NULL,
2253 .flags = FLAG_ADVANCED | FLAG_PRINT,
2254 },
2255 {
2256 .label = "printcap",
2257 .type = P_STRING,
2258 .p_class = P_GLOBAL,
2259 .offset = GLOBAL_VAR(szPrintcapname),
2260 .special = NULL,
2261 .enum_list = NULL,
2262 .flags = FLAG_HIDE,
2263 },
2264 {
2265 .label = "printable",
2266 .type = P_BOOL,
2267 .p_class = P_LOCAL,
2268 .offset = LOCAL_VAR(bPrint_ok),
2269 .special = NULL,
2270 .enum_list = NULL,
2271 .flags = FLAG_ADVANCED | FLAG_PRINT,
2272 },
2273 {
2274 .label = "print notify backchannel",
2275 .type = P_BOOL,
2276 .p_class = P_LOCAL,
2277 .offset = LOCAL_VAR(bPrintNotifyBackchannel),
2278 .special = NULL,
2279 .enum_list = NULL,
2280 .flags = FLAG_ADVANCED,
2281 },
2282 {
2283 .label = "print ok",
2284 .type = P_BOOL,
2285 .p_class = P_LOCAL,
2286 .offset = LOCAL_VAR(bPrint_ok),
2287 .special = NULL,
2288 .enum_list = NULL,
2289 .flags = FLAG_HIDE,
2290 },
2291 {
2292 .label = "printing",
2293 .type = P_ENUM,
2294 .p_class = P_LOCAL,
2295 .offset = LOCAL_VAR(iPrinting),
2296 .special = handle_printing,
2297 .enum_list = enum_printing,
2298 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2299 },
2300 {
2301 .label = "cups options",
2302 .type = P_STRING,
2303 .p_class = P_LOCAL,
2304 .offset = LOCAL_VAR(szCupsOptions),
2305 .special = NULL,
2306 .enum_list = NULL,
2307 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2308 },
2309 {
2310 .label = "cups server",
2311 .type = P_STRING,
2312 .p_class = P_GLOBAL,
2313 .offset = GLOBAL_VAR(szCupsServer),
2314 .special = NULL,
2315 .enum_list = NULL,
2316 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2317 },
2318 {
2319 .label = "cups encrypt",
2320 .type = P_ENUM,
2321 .p_class = P_GLOBAL,
2322 .offset = GLOBAL_VAR(CupsEncrypt),
2323 .special = NULL,
2324 .enum_list = enum_bool_auto,
2325 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2326 },
2327 {
2328
2329 .label = "cups connection timeout",
2330 .type = P_INTEGER,
2331 .p_class = P_GLOBAL,
2332 .offset = GLOBAL_VAR(cups_connection_timeout),
2333 .special = NULL,
2334 .enum_list = NULL,
2335 .flags = FLAG_ADVANCED,
2336 },
2337 {
2338 .label = "iprint server",
2339 .type = P_STRING,
2340 .p_class = P_GLOBAL,
2341 .offset = GLOBAL_VAR(szIPrintServer),
2342 .special = NULL,
2343 .enum_list = NULL,
2344 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2345 },
2346 {
2347 .label = "print command",
2348 .type = P_STRING,
2349 .p_class = P_LOCAL,
2350 .offset = LOCAL_VAR(szPrintcommand),
2351 .special = NULL,
2352 .enum_list = NULL,
2353 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2354 },
2355 {
2356 .label = "disable spoolss",
2357 .type = P_BOOL,
2358 .p_class = P_GLOBAL,
2359 .offset = GLOBAL_VAR(bDisableSpoolss),
2360 .special = NULL,
2361 .enum_list = NULL,
2362 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2363 },
2364 {
2365 .label = "enable spoolss",
2366 .type = P_BOOLREV,
2367 .p_class = P_GLOBAL,
2368 .offset = GLOBAL_VAR(bDisableSpoolss),
2369 .special = NULL,
2370 .enum_list = NULL,
2371 .flags = FLAG_HIDE,
2372 },
2373 {
2374 .label = "lpq command",
2375 .type = P_STRING,
2376 .p_class = P_LOCAL,
2377 .offset = LOCAL_VAR(szLpqcommand),
2378 .special = NULL,
2379 .enum_list = NULL,
2380 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2381 },
2382 {
2383 .label = "lprm command",
2384 .type = P_STRING,
2385 .p_class = P_LOCAL,
2386 .offset = LOCAL_VAR(szLprmcommand),
2387 .special = NULL,
2388 .enum_list = NULL,
2389 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2390 },
2391 {
2392 .label = "lppause command",
2393 .type = P_STRING,
2394 .p_class = P_LOCAL,
2395 .offset = LOCAL_VAR(szLppausecommand),
2396 .special = NULL,
2397 .enum_list = NULL,
2398 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2399 },
2400 {
2401 .label = "lpresume command",
2402 .type = P_STRING,
2403 .p_class = P_LOCAL,
2404 .offset = LOCAL_VAR(szLpresumecommand),
2405 .special = NULL,
2406 .enum_list = NULL,
2407 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2408 },
2409 {
2410 .label = "queuepause command",
2411 .type = P_STRING,
2412 .p_class = P_LOCAL,
2413 .offset = LOCAL_VAR(szQueuepausecommand),
2414 .special = NULL,
2415 .enum_list = NULL,
2416 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2417 },
2418 {
2419 .label = "queueresume command",
2420 .type = P_STRING,
2421 .p_class = P_LOCAL,
2422 .offset = LOCAL_VAR(szQueueresumecommand),
2423 .special = NULL,
2424 .enum_list = NULL,
2425 .flags = FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL,
2426 },
2427 {
2428 .label = "addport command",
2429 .type = P_STRING,
2430 .p_class = P_GLOBAL,
2431 .offset = GLOBAL_VAR(szAddPortCommand),
2432 .special = NULL,
2433 .enum_list = NULL,
2434 .flags = FLAG_ADVANCED,
2435 },
2436 {
2437 .label = "enumports command",
2438 .type = P_STRING,
2439 .p_class = P_GLOBAL,
2440 .offset = GLOBAL_VAR(szEnumPortsCommand),
2441 .special = NULL,
2442 .enum_list = NULL,
2443 .flags = FLAG_ADVANCED,
2444 },
2445 {
2446 .label = "addprinter command",
2447 .type = P_STRING,
2448 .p_class = P_GLOBAL,
2449 .offset = GLOBAL_VAR(szAddPrinterCommand),
2450 .special = NULL,
2451 .enum_list = NULL,
2452 .flags = FLAG_ADVANCED,
2453 },
2454 {
2455 .label = "deleteprinter command",
2456 .type = P_STRING,
2457 .p_class = P_GLOBAL,
2458 .offset = GLOBAL_VAR(szDeletePrinterCommand),
2459 .special = NULL,
2460 .enum_list = NULL,
2461 .flags = FLAG_ADVANCED,
2462 },
2463 {
2464 .label = "show add printer wizard",
2465 .type = P_BOOL,
2466 .p_class = P_GLOBAL,
2467 .offset = GLOBAL_VAR(bMsAddPrinterWizard),
2468 .special = NULL,
2469 .enum_list = NULL,
2470 .flags = FLAG_ADVANCED,
2471 },
2472 {
2473 .label = "os2 driver map",
2474 .type = P_STRING,
2475 .p_class = P_GLOBAL,
2476 .offset = GLOBAL_VAR(szOs2DriverMap),
2477 .special = NULL,
2478 .enum_list = NULL,
2479 .flags = FLAG_ADVANCED,
2480 },
2481
2482 {
2483 .label = "printer name",
2484 .type = P_STRING,
2485 .p_class = P_LOCAL,
2486 .offset = LOCAL_VAR(szPrintername),
2487 .special = NULL,
2488 .enum_list = NULL,
2489 .flags = FLAG_ADVANCED | FLAG_PRINT,
2490 },
2491 {
2492 .label = "printer",
2493 .type = P_STRING,
2494 .p_class = P_LOCAL,
2495 .offset = LOCAL_VAR(szPrintername),
2496 .special = NULL,
2497 .enum_list = NULL,
2498 .flags = FLAG_HIDE,
2499 },
2500 {
2501 .label = "use client driver",
2502 .type = P_BOOL,
2503 .p_class = P_LOCAL,
2504 .offset = LOCAL_VAR(bUseClientDriver),
2505 .special = NULL,
2506 .enum_list = NULL,
2507 .flags = FLAG_ADVANCED | FLAG_PRINT,
2508 },
2509 {
2510 .label = "default devmode",
2511 .type = P_BOOL,
2512 .p_class = P_LOCAL,
2513 .offset = LOCAL_VAR(bDefaultDevmode),
2514 .special = NULL,
2515 .enum_list = NULL,
2516 .flags = FLAG_ADVANCED | FLAG_PRINT,
2517 },
2518 {
2519 .label = "force printername",
2520 .type = P_BOOL,
2521 .p_class = P_LOCAL,
2522 .offset = LOCAL_VAR(bForcePrintername),
2523 .special = NULL,
2524 .enum_list = NULL,
2525 .flags = FLAG_ADVANCED | FLAG_PRINT,
2526 },
2527 {
2528 .label = "printjob username",
2529 .type = P_STRING,
2530 .p_class = P_LOCAL,
2531 .offset = LOCAL_VAR(szPrintjobUsername),
2532 .special = NULL,
2533 .enum_list = NULL,
2534 .flags = FLAG_ADVANCED | FLAG_PRINT,
2535 },
2536
2537 {N_("Filename Handling"), P_SEP, P_SEPARATOR},
2538
2539 {
2540 .label = "mangling method",
2541 .type = P_STRING,
2542 .p_class = P_GLOBAL,
2543 .offset = GLOBAL_VAR(szManglingMethod),
2544 .special = NULL,
2545 .enum_list = NULL,
2546 .flags = FLAG_ADVANCED,
2547 },
2548 {
2549 .label = "mangle prefix",
2550 .type = P_INTEGER,
2551 .p_class = P_GLOBAL,
2552 .offset = GLOBAL_VAR(mangle_prefix),
2553 .special = NULL,
2554 .enum_list = NULL,
2555 .flags = FLAG_ADVANCED,
2556 },
2557
2558 {
2559 .label = "default case",
2560 .type = P_ENUM,
2561 .p_class = P_LOCAL,
2562 .offset = LOCAL_VAR(iDefaultCase),
2563 .special = NULL,
2564 .enum_list = enum_case,
2565 .flags = FLAG_ADVANCED | FLAG_SHARE,
2566 },
2567 {
2568 .label = "case sensitive",
2569 .type = P_ENUM,
2570 .p_class = P_LOCAL,
2571 .offset = LOCAL_VAR(iCaseSensitive),
2572 .special = NULL,
2573 .enum_list = enum_bool_auto,
2574 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2575 },
2576 {
2577 .label = "casesignames",
2578 .type = P_ENUM,
2579 .p_class = P_LOCAL,
2580 .offset = LOCAL_VAR(iCaseSensitive),
2581 .special = NULL,
2582 .enum_list = enum_bool_auto,
2583 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL | FLAG_HIDE,
2584 },
2585 {
2586 .label = "preserve case",
2587 .type = P_BOOL,
2588 .p_class = P_LOCAL,
2589 .offset = LOCAL_VAR(bCasePreserve),
2590 .special = NULL,
2591 .enum_list = NULL,
2592 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2593 },
2594 {
2595 .label = "short preserve case",
2596 .type = P_BOOL,
2597 .p_class = P_LOCAL,
2598 .offset = LOCAL_VAR(bShortCasePreserve),
2599 .special = NULL,
2600 .enum_list = NULL,
2601 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2602 },
2603 {
2604 .label = "mangling char",
2605 .type = P_CHAR,
2606 .p_class = P_LOCAL,
2607 .offset = LOCAL_VAR(magic_char),
2608 .special = NULL,
2609 .enum_list = NULL,
2610 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2611 },
2612 {
2613 .label = "hide dot files",
2614 .type = P_BOOL,
2615 .p_class = P_LOCAL,
2616 .offset = LOCAL_VAR(bHideDotFiles),
2617 .special = NULL,
2618 .enum_list = NULL,
2619 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2620 },
2621 {
2622 .label = "hide special files",
2623 .type = P_BOOL,
2624 .p_class = P_LOCAL,
2625 .offset = LOCAL_VAR(bHideSpecialFiles),
2626 .special = NULL,
2627 .enum_list = NULL,
2628 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2629 },
2630 {
2631 .label = "hide unreadable",
2632 .type = P_BOOL,
2633 .p_class = P_LOCAL,
2634 .offset = LOCAL_VAR(bHideUnReadable),
2635 .special = NULL,
2636 .enum_list = NULL,
2637 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2638 },
2639 {
2640 .label = "hide unwriteable files",
2641 .type = P_BOOL,
2642 .p_class = P_LOCAL,
2643 .offset = LOCAL_VAR(bHideUnWriteableFiles),
2644 .special = NULL,
2645 .enum_list = NULL,
2646 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2647 },
2648 {
2649 .label = "delete veto files",
2650 .type = P_BOOL,
2651 .p_class = P_LOCAL,
2652 .offset = LOCAL_VAR(bDeleteVetoFiles),
2653 .special = NULL,
2654 .enum_list = NULL,
2655 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2656 },
2657 {
2658 .label = "veto files",
2659 .type = P_STRING,
2660 .p_class = P_LOCAL,
2661 .offset = LOCAL_VAR(szVetoFiles),
2662 .special = NULL,
2663 .enum_list = NULL,
2664 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2665 },
2666 {
2667 .label = "hide files",
2668 .type = P_STRING,
2669 .p_class = P_LOCAL,
2670 .offset = LOCAL_VAR(szHideFiles),
2671 .special = NULL,
2672 .enum_list = NULL,
2673 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2674 },
2675 {
2676 .label = "veto oplock files",
2677 .type = P_STRING,
2678 .p_class = P_LOCAL,
2679 .offset = LOCAL_VAR(szVetoOplockFiles),
2680 .special = NULL,
2681 .enum_list = NULL,
2682 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2683 },
2684 {
2685 .label = "map archive",
2686 .type = P_BOOL,
2687 .p_class = P_LOCAL,
2688 .offset = LOCAL_VAR(bMap_archive),
2689 .special = NULL,
2690 .enum_list = NULL,
2691 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2692 },
2693 {
2694 .label = "map hidden",
2695 .type = P_BOOL,
2696 .p_class = P_LOCAL,
2697 .offset = LOCAL_VAR(bMap_hidden),
2698 .special = NULL,
2699 .enum_list = NULL,
2700 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2701 },
2702 {
2703 .label = "map system",
2704 .type = P_BOOL,
2705 .p_class = P_LOCAL,
2706 .offset = LOCAL_VAR(bMap_system),
2707 .special = NULL,
2708 .enum_list = NULL,
2709 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2710 },
2711 {
2712 .label = "map readonly",
2713 .type = P_ENUM,
2714 .p_class = P_LOCAL,
2715 .offset = LOCAL_VAR(iMap_readonly),
2716 .special = NULL,
2717 .enum_list = enum_map_readonly,
2718 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2719 },
2720 {
2721 .label = "mangled names",
2722 .type = P_BOOL,
2723 .p_class = P_LOCAL,
2724 .offset = LOCAL_VAR(bMangledNames),
2725 .special = NULL,
2726 .enum_list = NULL,
2727 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2728 },
2729 {
2730 .label = "max stat cache size",
2731 .type = P_INTEGER,
2732 .p_class = P_GLOBAL,
2733 .offset = GLOBAL_VAR(iMaxStatCacheSize),
2734 .special = NULL,
2735 .enum_list = NULL,
2736 .flags = FLAG_ADVANCED,
2737 },
2738 {
2739 .label = "stat cache",
2740 .type = P_BOOL,
2741 .p_class = P_GLOBAL,
2742 .offset = GLOBAL_VAR(bStatCache),
2743 .special = NULL,
2744 .enum_list = NULL,
2745 .flags = FLAG_ADVANCED,
2746 },
2747 {
2748 .label = "store dos attributes",
2749 .type = P_BOOL,
2750 .p_class = P_LOCAL,
2751 .offset = LOCAL_VAR(bStoreDosAttributes),
2752 .special = NULL,
2753 .enum_list = NULL,
2754 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2755 },
2756 {
2757 .label = "dmapi support",
2758 .type = P_BOOL,
2759 .p_class = P_LOCAL,
2760 .offset = LOCAL_VAR(bDmapiSupport),
2761 .special = NULL,
2762 .enum_list = NULL,
2763 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
2764 },
2765
2766
2767 {N_("Domain Options"), P_SEP, P_SEPARATOR},
2768
2769 {
2770 .label = "machine password timeout",
2771 .type = P_INTEGER,
2772 .p_class = P_GLOBAL,
2773 .offset = GLOBAL_VAR(machine_password_timeout),
2774 .special = NULL,
2775 .enum_list = NULL,
2776 .flags = FLAG_ADVANCED | FLAG_WIZARD,
2777 },
2778
2779 {N_("Logon Options"), P_SEP, P_SEPARATOR},
2780
2781 {
2782 .label = "add user script",
2783 .type = P_STRING,
2784 .p_class = P_GLOBAL,
2785 .offset = GLOBAL_VAR(szAddUserScript),
2786 .special = NULL,
2787 .enum_list = NULL,
2788 .flags = FLAG_ADVANCED,
2789 },
2790 {
2791 .label = "rename user script",
2792 .type = P_STRING,
2793 .p_class = P_GLOBAL,
2794 .offset = GLOBAL_VAR(szRenameUserScript),
2795 .special = NULL,
2796 .enum_list = NULL,
2797 .flags = FLAG_ADVANCED,
2798 },
2799 {
2800 .label = "delete user script",
2801 .type = P_STRING,
2802 .p_class = P_GLOBAL,
2803 .offset = GLOBAL_VAR(szDelUserScript),
2804 .special = NULL,
2805 .enum_list = NULL,
2806 .flags = FLAG_ADVANCED,
2807 },
2808 {
2809 .label = "add group script",
2810 .type = P_STRING,
2811 .p_class = P_GLOBAL,
2812 .offset = GLOBAL_VAR(szAddGroupScript),
2813 .special = NULL,
2814 .enum_list = NULL,
2815 .flags = FLAG_ADVANCED,
2816 },
2817 {
2818 .label = "delete group script",
2819 .type = P_STRING,
2820 .p_class = P_GLOBAL,
2821 .offset = GLOBAL_VAR(szDelGroupScript),
2822 .special = NULL,
2823 .enum_list = NULL,
2824 .flags = FLAG_ADVANCED,
2825 },
2826 {
2827 .label = "add user to group script",
2828 .type = P_STRING,
2829 .p_class = P_GLOBAL,
2830 .offset = GLOBAL_VAR(szAddUserToGroupScript),
2831 .special = NULL,
2832 .enum_list = NULL,
2833 .flags = FLAG_ADVANCED,
2834 },
2835 {
2836 .label = "delete user from group script",
2837 .type = P_STRING,
2838 .p_class = P_GLOBAL,
2839 .offset = GLOBAL_VAR(szDelUserFromGroupScript),
2840 .special = NULL,
2841 .enum_list = NULL,
2842 .flags = FLAG_ADVANCED,
2843 },
2844 {
2845 .label = "set primary group script",
2846 .type = P_STRING,
2847 .p_class = P_GLOBAL,
2848 .offset = GLOBAL_VAR(szSetPrimaryGroupScript),
2849 .special = NULL,
2850 .enum_list = NULL,
2851 .flags = FLAG_ADVANCED,
2852 },
2853 {
2854 .label = "add machine script",
2855 .type = P_STRING,
2856 .p_class = P_GLOBAL,
2857 .offset = GLOBAL_VAR(szAddMachineScript),
2858 .special = NULL,
2859 .enum_list = NULL,
2860 .flags = FLAG_ADVANCED,
2861 },
2862 {
2863 .label = "shutdown script",
2864 .type = P_STRING,
2865 .p_class = P_GLOBAL,
2866 .offset = GLOBAL_VAR(szShutdownScript),
2867 .special = NULL,
2868 .enum_list = NULL,
2869 .flags = FLAG_ADVANCED,
2870 },
2871 {
2872 .label = "abort shutdown script",
2873 .type = P_STRING,
2874 .p_class = P_GLOBAL,
2875 .offset = GLOBAL_VAR(szAbortShutdownScript),
2876 .special = NULL,
2877 .enum_list = NULL,
2878 .flags = FLAG_ADVANCED,
2879 },
2880 {
2881 .label = "username map script",
2882 .type = P_STRING,
2883 .p_class = P_GLOBAL,
2884 .offset = GLOBAL_VAR(szUsernameMapScript),
2885 .special = NULL,
2886 .enum_list = NULL,
2887 .flags = FLAG_ADVANCED,
2888 },
2889 {
2890 .label = "username map cache time",
2891 .type = P_INTEGER,
2892 .p_class = P_GLOBAL,
2893 .offset = GLOBAL_VAR(iUsernameMapCacheTime),
2894 .special = NULL,
2895 .enum_list = NULL,
2896 .flags = FLAG_ADVANCED,
2897 },
2898 {
2899 .label = "logon script",
2900 .type = P_STRING,
2901 .p_class = P_GLOBAL,
2902 .offset = GLOBAL_VAR(szLogonScript),
2903 .special = NULL,
2904 .enum_list = NULL,
2905 .flags = FLAG_ADVANCED,
2906 },
2907 {
2908 .label = "logon path",
2909 .type = P_STRING,
2910 .p_class = P_GLOBAL,
2911 .offset = GLOBAL_VAR(szLogonPath),
2912 .special = NULL,
2913 .enum_list = NULL,
2914 .flags = FLAG_ADVANCED,
2915 },
2916 {
2917 .label = "logon drive",
2918 .type = P_STRING,
2919 .p_class = P_GLOBAL,
2920 .offset = GLOBAL_VAR(szLogonDrive),
2921 .special = NULL,
2922 .enum_list = NULL,
2923 .flags = FLAG_ADVANCED,
2924 },
2925 {
2926 .label = "logon home",
2927 .type = P_STRING,
2928 .p_class = P_GLOBAL,
2929 .offset = GLOBAL_VAR(szLogonHome),
2930 .special = NULL,
2931 .enum_list = NULL,
2932 .flags = FLAG_ADVANCED,
2933 },
2934 {
2935 .label = "domain logons",
2936 .type = P_BOOL,
2937 .p_class = P_GLOBAL,
2938 .offset = GLOBAL_VAR(bDomainLogons),
2939 .special = NULL,
2940 .enum_list = NULL,
2941 .flags = FLAG_ADVANCED,
2942 },
2943
2944 {
2945 .label = "init logon delayed hosts",
2946 .type = P_LIST,
2947 .p_class = P_GLOBAL,
2948 .offset = GLOBAL_VAR(szInitLogonDelayedHosts),
2949 .special = NULL,
2950 .enum_list = NULL,
2951 .flags = FLAG_ADVANCED,
2952 },
2953
2954 {
2955 .label = "init logon delay",
2956 .type = P_INTEGER,
2957 .p_class = P_GLOBAL,
2958 .offset = GLOBAL_VAR(InitLogonDelay),
2959 .special = NULL,
2960 .enum_list = NULL,
2961 .flags = FLAG_ADVANCED,
2962
2963 },
2964
2965 {N_("Browse Options"), P_SEP, P_SEPARATOR},
2966
2967 {
2968 .label = "os level",
2969 .type = P_INTEGER,
2970 .p_class = P_GLOBAL,
2971 .offset = GLOBAL_VAR(os_level),
2972 .special = NULL,
2973 .enum_list = NULL,
2974 .flags = FLAG_BASIC | FLAG_ADVANCED,
2975 },
2976 {
2977 .label = "lm announce",
2978 .type = P_ENUM,
2979 .p_class = P_GLOBAL,
2980 .offset = GLOBAL_VAR(lm_announce),
2981 .special = NULL,
2982 .enum_list = enum_bool_auto,
2983 .flags = FLAG_ADVANCED,
2984 },
2985 {
2986 .label = "lm interval",
2987 .type = P_INTEGER,
2988 .p_class = P_GLOBAL,
2989 .offset = GLOBAL_VAR(lm_interval),
2990 .special = NULL,
2991 .enum_list = NULL,
2992 .flags = FLAG_ADVANCED,
2993 },
2994 {
2995 .label = "preferred master",
2996 .type = P_ENUM,
2997 .p_class = P_GLOBAL,
2998 .offset = GLOBAL_VAR(iPreferredMaster),
2999 .special = NULL,
3000 .enum_list = enum_bool_auto,
3001 .flags = FLAG_BASIC | FLAG_ADVANCED,
3002 },
3003 {
3004 .label = "prefered master",
3005 .type = P_ENUM,
3006 .p_class = P_GLOBAL,
3007 .offset = GLOBAL_VAR(iPreferredMaster),
3008 .special = NULL,
3009 .enum_list = enum_bool_auto,
3010 .flags = FLAG_HIDE,
3011 },
3012 {
3013 .label = "local master",
3014 .type = P_BOOL,
3015 .p_class = P_GLOBAL,
3016 .offset = GLOBAL_VAR(bLocalMaster),
3017 .special = NULL,
3018 .enum_list = NULL,
3019 .flags = FLAG_BASIC | FLAG_ADVANCED,
3020 },
3021 {
3022 .label = "domain master",
3023 .type = P_ENUM,
3024 .p_class = P_GLOBAL,
3025 .offset = GLOBAL_VAR(iDomainMaster),
3026 .special = NULL,
3027 .enum_list = enum_bool_auto,
3028 .flags = FLAG_BASIC | FLAG_ADVANCED,
3029 },
3030 {
3031 .label = "browse list",
3032 .type = P_BOOL,
3033 .p_class = P_GLOBAL,
3034 .offset = GLOBAL_VAR(bBrowseList),
3035 .special = NULL,
3036 .enum_list = NULL,
3037 .flags = FLAG_ADVANCED,
3038 },
3039 {
3040 .label = "browseable",
3041 .type = P_BOOL,
3042 .p_class = P_LOCAL,
3043 .offset = LOCAL_VAR(bBrowseable),
3044 .special = NULL,
3045 .enum_list = NULL,
3046 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
3047 },
3048 {
3049 .label = "browsable",
3050 .type = P_BOOL,
3051 .p_class = P_LOCAL,
3052 .offset = LOCAL_VAR(bBrowseable),
3053 .special = NULL,
3054 .enum_list = NULL,
3055 .flags = FLAG_HIDE,
3056 },
3057 {
3058 .label = "access based share enum",
3059 .type = P_BOOL,
3060 .p_class = P_LOCAL,
3061 .offset = LOCAL_VAR(bAccessBasedShareEnum),
3062 .special = NULL,
3063 .enum_list = NULL,
3064 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE
3065 },
3066 {
3067 .label = "enhanced browsing",
3068 .type = P_BOOL,
3069 .p_class = P_GLOBAL,
3070 .offset = GLOBAL_VAR(enhanced_browsing),
3071 .special = NULL,
3072 .enum_list = NULL,
3073 .flags = FLAG_ADVANCED,
3074 },
3075
3076 {N_("WINS Options"), P_SEP, P_SEPARATOR},
3077
3078 {
3079 .label = "dns proxy",
3080 .type = P_BOOL,
3081 .p_class = P_GLOBAL,
3082 .offset = GLOBAL_VAR(bDNSproxy),
3083 .special = NULL,
3084 .enum_list = NULL,
3085 .flags = FLAG_ADVANCED,
3086 },
3087 {
3088 .label = "wins proxy",
3089 .type = P_BOOL,
3090 .p_class = P_GLOBAL,
3091 .offset = GLOBAL_VAR(bWINSproxy),
3092 .special = NULL,
3093 .enum_list = NULL,
3094 .flags = FLAG_ADVANCED,
3095 },
3096 {
3097 .label = "wins server",
3098 .type = P_LIST,
3099 .p_class = P_GLOBAL,
3100 .offset = GLOBAL_VAR(szWINSservers),
3101 .special = NULL,
3102 .enum_list = NULL,
3103 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
3104 },
3105 {
3106 .label = "wins support",
3107 .type = P_BOOL,
3108 .p_class = P_GLOBAL,
3109 .offset = GLOBAL_VAR(bWINSsupport),
3110 .special = NULL,
3111 .enum_list = NULL,
3112 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD,
3113 },
3114 {
3115 .label = "wins hook",
3116 .type = P_STRING,
3117 .p_class = P_GLOBAL,
3118 .offset = GLOBAL_VAR(szWINSHook),
3119 .special = NULL,
3120 .enum_list = NULL,
3121 .flags = FLAG_ADVANCED,
3122 },
3123
3124 {N_("Locking Options"), P_SEP, P_SEPARATOR},
3125
3126 {
3127 .label = "blocking locks",
3128 .type = P_BOOL,
3129 .p_class = P_LOCAL,
3130 .offset = LOCAL_VAR(bBlockingLocks),
3131 .special = NULL,
3132 .enum_list = NULL,
3133 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3134 },
3135 {
3136 .label = "csc policy",
3137 .type = P_ENUM,
3138 .p_class = P_LOCAL,
3139 .offset = LOCAL_VAR(iCSCPolicy),
3140 .special = NULL,
3141 .enum_list = enum_csc_policy,
3142 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3143 },
3144 {
3145 .label = "fake oplocks",
3146 .type = P_BOOL,
3147 .p_class = P_LOCAL,
3148 .offset = LOCAL_VAR(bFakeOplocks),
3149 .special = NULL,
3150 .enum_list = NULL,
3151 .flags = FLAG_ADVANCED | FLAG_SHARE,
3152 },
3153 {
3154 .label = "kernel oplocks",
3155 .type = P_BOOL,
3156 .p_class = P_GLOBAL,
3157 .offset = GLOBAL_VAR(bKernelOplocks),
3158 .special = NULL,
3159 .enum_list = NULL,
3160 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
3161 },
3162 {
3163 .label = "locking",
3164 .type = P_BOOL,
3165 .p_class = P_LOCAL,
3166 .offset = LOCAL_VAR(bLocking),
3167 .special = NULL,
3168 .enum_list = NULL,
3169 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3170 },
3171 {
3172 .label = "lock spin time",
3173 .type = P_INTEGER,
3174 .p_class = P_GLOBAL,
3175 .offset = GLOBAL_VAR(iLockSpinTime),
3176 .special = NULL,
3177 .enum_list = NULL,
3178 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
3179 },
3180 {
3181 .label = "oplocks",
3182 .type = P_BOOL,
3183 .p_class = P_LOCAL,
3184 .offset = LOCAL_VAR(bOpLocks),
3185 .special = NULL,
3186 .enum_list = NULL,
3187 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3188 },
3189 {
3190 .label = "level2 oplocks",
3191 .type = P_BOOL,
3192 .p_class = P_LOCAL,
3193 .offset = LOCAL_VAR(bLevel2OpLocks),
3194 .special = NULL,
3195 .enum_list = NULL,
3196 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3197 },
3198 {
3199 .label = "oplock break wait time",
3200 .type = P_INTEGER,
3201 .p_class = P_GLOBAL,
3202 .offset = GLOBAL_VAR(oplock_break_wait_time),
3203 .special = NULL,
3204 .enum_list = NULL,
3205 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
3206 },
3207 {
3208 .label = "oplock contention limit",
3209 .type = P_INTEGER,
3210 .p_class = P_LOCAL,
3211 .offset = LOCAL_VAR(iOplockContentionLimit),
3212 .special = NULL,
3213 .enum_list = NULL,
3214 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3215 },
3216 {
3217 .label = "posix locking",
3218 .type = P_BOOL,
3219 .p_class = P_LOCAL,
3220 .offset = LOCAL_VAR(bPosixLocking),
3221 .special = NULL,
3222 .enum_list = NULL,
3223 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3224 },
3225 {
3226 .label = "strict locking",
3227 .type = P_ENUM,
3228 .p_class = P_LOCAL,
3229 .offset = LOCAL_VAR(iStrictLocking),
3230 .special = NULL,
3231 .enum_list = enum_bool_auto,
3232 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3233 },
3234 {
3235 .label = "share modes",
3236 .type = P_BOOL,
3237 .p_class = P_LOCAL,
3238 .offset = LOCAL_VAR(bShareModes),
3239 .special = NULL,
3240 .enum_list = NULL,
3241 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL | FLAG_DEPRECATED,
3242 },
3243
3244 {N_("Ldap Options"), P_SEP, P_SEPARATOR},
3245
3246 {
3247 .label = "ldap admin dn",
3248 .type = P_STRING,
3249 .p_class = P_GLOBAL,
3250 .offset = GLOBAL_VAR(szLdapAdminDn),
3251 .special = NULL,
3252 .enum_list = NULL,
3253 .flags = FLAG_ADVANCED,
3254 },
3255 {
3256 .label = "ldap delete dn",
3257 .type = P_BOOL,
3258 .p_class = P_GLOBAL,
3259 .offset = GLOBAL_VAR(ldap_delete_dn),
3260 .special = NULL,
3261 .enum_list = NULL,
3262 .flags = FLAG_ADVANCED,
3263 },
3264 {
3265 .label = "ldap group suffix",
3266 .type = P_STRING,
3267 .p_class = P_GLOBAL,
3268 .offset = GLOBAL_VAR(szLdapGroupSuffix),
3269 .special = NULL,
3270 .enum_list = NULL,
3271 .flags = FLAG_ADVANCED,
3272 },
3273 {
3274 .label = "ldap idmap suffix",
3275 .type = P_STRING,
3276 .p_class = P_GLOBAL,
3277 .offset = GLOBAL_VAR(szLdapIdmapSuffix),
3278 .special = NULL,
3279 .enum_list = NULL,
3280 .flags = FLAG_ADVANCED,
3281 },
3282 {
3283 .label = "ldap machine suffix",
3284 .type = P_STRING,
3285 .p_class = P_GLOBAL,
3286 .offset = GLOBAL_VAR(szLdapMachineSuffix),
3287 .special = NULL,
3288 .enum_list = NULL,
3289 .flags = FLAG_ADVANCED,
3290 },
3291 {
3292 .label = "ldap passwd sync",
3293 .type = P_ENUM,
3294 .p_class = P_GLOBAL,
3295 .offset = GLOBAL_VAR(ldap_passwd_sync),
3296 .special = NULL,
3297 .enum_list = enum_ldap_passwd_sync,
3298 .flags = FLAG_ADVANCED,
3299 },
3300 {
3301 .label = "ldap password sync",
3302 .type = P_ENUM,
3303 .p_class = P_GLOBAL,
3304 .offset = GLOBAL_VAR(ldap_passwd_sync),
3305 .special = NULL,
3306 .enum_list = enum_ldap_passwd_sync,
3307 .flags = FLAG_HIDE,
3308 },
3309 {
3310 .label = "ldap replication sleep",
3311 .type = P_INTEGER,
3312 .p_class = P_GLOBAL,
3313 .offset = GLOBAL_VAR(ldap_replication_sleep),
3314 .special = NULL,
3315 .enum_list = NULL,
3316 .flags = FLAG_ADVANCED,
3317 },
3318 {
3319 .label = "ldap suffix",
3320 .type = P_STRING,
3321 .p_class = P_GLOBAL,
3322 .offset = GLOBAL_VAR(szLdapSuffix),
3323 .special = NULL,
3324 .enum_list = NULL,
3325 .flags = FLAG_ADVANCED,
3326 },
3327 {
3328 .label = "ldap ssl",
3329 .type = P_ENUM,
3330 .p_class = P_GLOBAL,
3331 .offset = GLOBAL_VAR(ldap_ssl),
3332 .special = NULL,
3333 .enum_list = enum_ldap_ssl,
3334 .flags = FLAG_ADVANCED,
3335 },
3336 {
3337 .label = "ldap ssl ads",
3338 .type = P_BOOL,
3339 .p_class = P_GLOBAL,
3340 .offset = GLOBAL_VAR(ldap_ssl_ads),
3341 .special = NULL,
3342 .enum_list = NULL,
3343 .flags = FLAG_ADVANCED,
3344 },
3345 {
3346 .label = "ldap deref",
3347 .type = P_ENUM,
3348 .p_class = P_GLOBAL,
3349 .offset = GLOBAL_VAR(ldap_deref),
3350 .special = NULL,
3351 .enum_list = enum_ldap_deref,
3352 .flags = FLAG_ADVANCED,
3353 },
3354 {
3355 .label = "ldap follow referral",
3356 .type = P_ENUM,
3357 .p_class = P_GLOBAL,
3358 .offset = GLOBAL_VAR(ldap_follow_referral),
3359 .special = NULL,
3360 .enum_list = enum_bool_auto,
3361 .flags = FLAG_ADVANCED,
3362 },
3363 {
3364 .label = "ldap timeout",
3365 .type = P_INTEGER,
3366 .p_class = P_GLOBAL,
3367 .offset = GLOBAL_VAR(ldap_timeout),
3368 .special = NULL,
3369 .enum_list = NULL,
3370 .flags = FLAG_ADVANCED,
3371 },
3372 {
3373 .label = "ldap connection timeout",
3374 .type = P_INTEGER,
3375 .p_class = P_GLOBAL,
3376 .offset = GLOBAL_VAR(ldap_connection_timeout),
3377 .special = NULL,
3378 .enum_list = NULL,
3379 .flags = FLAG_ADVANCED,
3380 },
3381 {
3382 .label = "ldap page size",
3383 .type = P_INTEGER,
3384 .p_class = P_GLOBAL,
3385 .offset = GLOBAL_VAR(ldap_page_size),
3386 .special = NULL,
3387 .enum_list = NULL,
3388 .flags = FLAG_ADVANCED,
3389 },
3390 {
3391 .label = "ldap user suffix",
3392 .type = P_STRING,
3393 .p_class = P_GLOBAL,
3394 .offset = GLOBAL_VAR(szLdapUserSuffix),
3395 .special = NULL,
3396 .enum_list = NULL,
3397 .flags = FLAG_ADVANCED,
3398 },
3399 {
3400 .label = "ldap debug level",
3401 .type = P_INTEGER,
3402 .p_class = P_GLOBAL,
3403 .offset = GLOBAL_VAR(ldap_debug_level),
3404 .special = handle_ldap_debug_level,
3405 .enum_list = NULL,
3406 .flags = FLAG_ADVANCED,
3407 },
3408 {
3409 .label = "ldap debug threshold",
3410 .type = P_INTEGER,
3411 .p_class = P_GLOBAL,
3412 .offset = GLOBAL_VAR(ldap_debug_threshold),
3413 .special = NULL,
3414 .enum_list = NULL,
3415 .flags = FLAG_ADVANCED,
3416 },
3417
3418 {N_("EventLog Options"), P_SEP, P_SEPARATOR},
3419
3420 {
3421 .label = "eventlog list",
3422 .type = P_LIST,
3423 .p_class = P_GLOBAL,
3424 .offset = GLOBAL_VAR(szEventLogs),
3425 .special = NULL,
3426 .enum_list = NULL,
3427 .flags = FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE,
3428 },
3429
3430 {N_("Miscellaneous Options"), P_SEP, P_SEPARATOR},
3431
3432 {
3433 .label = "add share command",
3434 .type = P_STRING,
3435 .p_class = P_GLOBAL,
3436 .offset = GLOBAL_VAR(szAddShareCommand),
3437 .special = NULL,
3438 .enum_list = NULL,
3439 .flags = FLAG_ADVANCED,
3440 },
3441 {
3442 .label = "change share command",
3443 .type = P_STRING,
3444 .p_class = P_GLOBAL,
3445 .offset = GLOBAL_VAR(szChangeShareCommand),
3446 .special = NULL,
3447 .enum_list = NULL,
3448 .flags = FLAG_ADVANCED,
3449 },
3450 {
3451 .label = "delete share command",
3452 .type = P_STRING,
3453 .p_class = P_GLOBAL,
3454 .offset = GLOBAL_VAR(szDeleteShareCommand),
3455 .special = NULL,
3456 .enum_list = NULL,
3457 .flags = FLAG_ADVANCED,
3458 },
3459 {
3460 .label = "config file",
3461 .type = P_STRING,
3462 .p_class = P_GLOBAL,
3463 .offset = GLOBAL_VAR(szConfigFile),
3464 .special = NULL,
3465 .enum_list = NULL,
3466 .flags = FLAG_HIDE|FLAG_META,
3467 },
3468 {
3469 .label = "preload",
3470 .type = P_STRING,
3471 .p_class = P_GLOBAL,
3472 .offset = GLOBAL_VAR(szAutoServices),
3473 .special = NULL,
3474 .enum_list = NULL,
3475 .flags = FLAG_ADVANCED,
3476 },
3477 {
3478 .label = "auto services",
3479 .type = P_STRING,
3480 .p_class = P_GLOBAL,
3481 .offset = GLOBAL_VAR(szAutoServices),
3482 .special = NULL,
3483 .enum_list = NULL,
3484 .flags = FLAG_ADVANCED,
3485 },
3486 {
3487 .label = "lock directory",
3488 .type = P_STRING,
3489 .p_class = P_GLOBAL,
3490 .offset = GLOBAL_VAR(szLockDir),
3491 .special = NULL,
3492 .enum_list = NULL,
3493 .flags = FLAG_ADVANCED,
3494 },
3495 {
3496 .label = "lock dir",
3497 .type = P_STRING,
3498 .p_class = P_GLOBAL,
3499 .offset = GLOBAL_VAR(szLockDir),
3500 .special = NULL,
3501 .enum_list = NULL,
3502 .flags = FLAG_HIDE,
3503 },
3504 {
3505 .label = "state directory",
3506 .type = P_STRING,
3507 .p_class = P_GLOBAL,
3508 .offset = GLOBAL_VAR(szStateDir),
3509 .special = NULL,
3510 .enum_list = NULL,
3511 .flags = FLAG_ADVANCED,
3512 },
3513 {
3514 .label = "cache directory",
3515 .type = P_STRING,
3516 .p_class = P_GLOBAL,
3517 .offset = GLOBAL_VAR(szCacheDir),
3518 .special = NULL,
3519 .enum_list = NULL,
3520 .flags = FLAG_ADVANCED,
3521 },
3522 {
3523 .label = "pid directory",
3524 .type = P_STRING,
3525 .p_class = P_GLOBAL,
3526 .offset = GLOBAL_VAR(szPidDir),
3527 .special = NULL,
3528 .enum_list = NULL,
3529 .flags = FLAG_ADVANCED,
3530 },
3531 #ifdef WITH_UTMP
3532 {
3533 .label = "utmp directory",
3534 .type = P_STRING,
3535 .p_class = P_GLOBAL,
3536 .offset = GLOBAL_VAR(szUtmpDir),
3537 .special = NULL,
3538 .enum_list = NULL,
3539 .flags = FLAG_ADVANCED,
3540 },
3541 {
3542 .label = "wtmp directory",
3543 .type = P_STRING,
3544 .p_class = P_GLOBAL,
3545 .offset = GLOBAL_VAR(szWtmpDir),
3546 .special = NULL,
3547 .enum_list = NULL,
3548 .flags = FLAG_ADVANCED,
3549 },
3550 {
3551 .label = "utmp",
3552 .type = P_BOOL,
3553 .p_class = P_GLOBAL,
3554 .offset = GLOBAL_VAR(bUtmp),
3555 .special = NULL,
3556 .enum_list = NULL,
3557 .flags = FLAG_ADVANCED,
3558 },
3559 #endif
3560 {
3561 .label = "default service",
3562 .type = P_STRING,
3563 .p_class = P_GLOBAL,
3564 .offset = GLOBAL_VAR(szDefaultService),
3565 .special = NULL,
3566 .enum_list = NULL,
3567 .flags = FLAG_ADVANCED,
3568 },
3569 {
3570 .label = "default",
3571 .type = P_STRING,
3572 .p_class = P_GLOBAL,
3573 .offset = GLOBAL_VAR(szDefaultService),
3574 .special = NULL,
3575 .enum_list = NULL,
3576 .flags = FLAG_ADVANCED,
3577 },
3578 {
3579 .label = "message command",
3580 .type = P_STRING,
3581 .p_class = P_GLOBAL,
3582 .offset = GLOBAL_VAR(szMsgCommand),
3583 .special = NULL,
3584 .enum_list = NULL,
3585 .flags = FLAG_ADVANCED,
3586 },
3587 {
3588 .label = "dfree cache time",
3589 .type = P_INTEGER,
3590 .p_class = P_LOCAL,
3591 .offset = LOCAL_VAR(iDfreeCacheTime),
3592 .special = NULL,
3593 .enum_list = NULL,
3594 .flags = FLAG_ADVANCED,
3595 },
3596 {
3597 .label = "dfree command",
3598 .type = P_STRING,
3599 .p_class = P_LOCAL,
3600 .offset = LOCAL_VAR(szDfree),
3601 .special = NULL,
3602 .enum_list = NULL,
3603 .flags = FLAG_ADVANCED,
3604 },
3605 {
3606 .label = "get quota command",
3607 .type = P_STRING,
3608 .p_class = P_GLOBAL,
3609 .offset = GLOBAL_VAR(szGetQuota),
3610 .special = NULL,
3611 .enum_list = NULL,
3612 .flags = FLAG_ADVANCED,
3613 },
3614 {
3615 .label = "set quota command",
3616 .type = P_STRING,
3617 .p_class = P_GLOBAL,
3618 .offset = GLOBAL_VAR(szSetQuota),
3619 .special = NULL,
3620 .enum_list = NULL,
3621 .flags = FLAG_ADVANCED,
3622 },
3623 {
3624 .label = "remote announce",
3625 .type = P_STRING,
3626 .p_class = P_GLOBAL,
3627 .offset = GLOBAL_VAR(szRemoteAnnounce),
3628 .special = NULL,
3629 .enum_list = NULL,
3630 .flags = FLAG_ADVANCED,
3631 },
3632 {
3633 .label = "remote browse sync",
3634 .type = P_STRING,
3635 .p_class = P_GLOBAL,
3636 .offset = GLOBAL_VAR(szRemoteBrowseSync),
3637 .special = NULL,
3638 .enum_list = NULL,
3639 .flags = FLAG_ADVANCED,
3640 },
3641 {
3642 .label = "socket address",
3643 .type = P_STRING,
3644 .p_class = P_GLOBAL,
3645 .offset = GLOBAL_VAR(szSocketAddress),
3646 .special = NULL,
3647 .enum_list = NULL,
3648 .flags = FLAG_ADVANCED,
3649 },
3650 {
3651 .label = "nmbd bind explicit broadcast",
3652 .type = P_BOOL,
3653 .p_class = P_GLOBAL,
3654 .offset = GLOBAL_VAR(bNmbdBindExplicitBroadcast),
3655 .special = NULL,
3656 .enum_list = NULL,
3657 .flags = FLAG_ADVANCED,
3658 },
3659 {
3660 .label = "homedir map",
3661 .type = P_STRING,
3662 .p_class = P_GLOBAL,
3663 .offset = GLOBAL_VAR(szNISHomeMapName),
3664 .special = NULL,
3665 .enum_list = NULL,
3666 .flags = FLAG_ADVANCED,
3667 },
3668 {
3669 .label = "afs username map",
3670 .type = P_STRING,
3671 .p_class = P_GLOBAL,
3672 .offset = GLOBAL_VAR(szAfsUsernameMap),
3673 .special = NULL,
3674 .enum_list = NULL,
3675 .flags = FLAG_ADVANCED,
3676 },
3677 {
3678 .label = "afs token lifetime",
3679 .type = P_INTEGER,
3680 .p_class = P_GLOBAL,
3681 .offset = GLOBAL_VAR(iAfsTokenLifetime),
3682 .special = NULL,
3683 .enum_list = NULL,
3684 .flags = FLAG_ADVANCED,
3685 },
3686 {
3687 .label = "log nt token command",
3688 .type = P_STRING,
3689 .p_class = P_GLOBAL,
3690 .offset = GLOBAL_VAR(szLogNtTokenCommand),
3691 .special = NULL,
3692 .enum_list = NULL,
3693 .flags = FLAG_ADVANCED,
3694 },
3695 {
3696 .label = "NIS homedir",
3697 .type = P_BOOL,
3698 .p_class = P_GLOBAL,
3699 .offset = GLOBAL_VAR(bNISHomeMap),
3700 .special = NULL,
3701 .enum_list = NULL,
3702 .flags = FLAG_ADVANCED,
3703 },
3704 {
3705 .label = "-valid",
3706 .type = P_BOOL,
3707 .p_class = P_LOCAL,
3708 .offset = LOCAL_VAR(valid),
3709 .special = NULL,
3710 .enum_list = NULL,
3711 .flags = FLAG_HIDE,
3712 },
3713 {
3714 .label = "copy",
3715 .type = P_STRING,
3716 .p_class = P_LOCAL,
3717 .offset = LOCAL_VAR(szCopy),
3718 .special = handle_copy,
3719 .enum_list = NULL,
3720 .flags = FLAG_HIDE,
3721 },
3722 {
3723 .label = "include",
3724 .type = P_STRING,
3725 .p_class = P_LOCAL,
3726 .offset = LOCAL_VAR(szInclude),
3727 .special = handle_include,
3728 .enum_list = NULL,
3729 .flags = FLAG_HIDE|FLAG_META,
3730 },
3731 {
3732 .label = "preexec",
3733 .type = P_STRING,
3734 .p_class = P_LOCAL,
3735 .offset = LOCAL_VAR(szPreExec),
3736 .special = NULL,
3737 .enum_list = NULL,
3738 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
3739 },
3740 {
3741 .label = "exec",
3742 .type = P_STRING,
3743 .p_class = P_LOCAL,
3744 .offset = LOCAL_VAR(szPreExec),
3745 .special = NULL,
3746 .enum_list = NULL,
3747 .flags = FLAG_ADVANCED,
3748 },
3749 {
3750 .label = "preexec close",
3751 .type = P_BOOL,
3752 .p_class = P_LOCAL,
3753 .offset = LOCAL_VAR(bPreexecClose),
3754 .special = NULL,
3755 .enum_list = NULL,
3756 .flags = FLAG_ADVANCED | FLAG_SHARE,
3757 },
3758 {
3759 .label = "postexec",
3760 .type = P_STRING,
3761 .p_class = P_LOCAL,
3762 .offset = LOCAL_VAR(szPostExec),
3763 .special = NULL,
3764 .enum_list = NULL,
3765 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
3766 },
3767 {
3768 .label = "root preexec",
3769 .type = P_STRING,
3770 .p_class = P_LOCAL,
3771 .offset = LOCAL_VAR(szRootPreExec),
3772 .special = NULL,
3773 .enum_list = NULL,
3774 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
3775 },
3776 {
3777 .label = "root preexec close",
3778 .type = P_BOOL,
3779 .p_class = P_LOCAL,
3780 .offset = LOCAL_VAR(bRootpreexecClose),
3781 .special = NULL,
3782 .enum_list = NULL,
3783 .flags = FLAG_ADVANCED | FLAG_SHARE,
3784 },
3785 {
3786 .label = "root postexec",
3787 .type = P_STRING,
3788 .p_class = P_LOCAL,
3789 .offset = LOCAL_VAR(szRootPostExec),
3790 .special = NULL,
3791 .enum_list = NULL,
3792 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
3793 },
3794 {
3795 .label = "available",
3796 .type = P_BOOL,
3797 .p_class = P_LOCAL,
3798 .offset = LOCAL_VAR(bAvailable),
3799 .special = NULL,
3800 .enum_list = NULL,
3801 .flags = FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT,
3802 },
3803 {
3804 .label = "registry shares",
3805 .type = P_BOOL,
3806 .p_class = P_GLOBAL,
3807 .offset = GLOBAL_VAR(bRegistryShares),
3808 .special = NULL,
3809 .enum_list = NULL,
3810 .flags = FLAG_ADVANCED,
3811 },
3812 {
3813 .label = "usershare allow guests",
3814 .type = P_BOOL,
3815 .p_class = P_GLOBAL,
3816 .offset = GLOBAL_VAR(bUsershareAllowGuests),
3817 .special = NULL,
3818 .enum_list = NULL,
3819 .flags = FLAG_ADVANCED,
3820 },
3821 {
3822 .label = "usershare max shares",
3823 .type = P_INTEGER,
3824 .p_class = P_GLOBAL,
3825 .offset = GLOBAL_VAR(iUsershareMaxShares),
3826 .special = NULL,
3827 .enum_list = NULL,
3828 .flags = FLAG_ADVANCED,
3829 },
3830 {
3831 .label = "usershare owner only",
3832 .type = P_BOOL,
3833 .p_class = P_GLOBAL,
3834 .offset = GLOBAL_VAR(bUsershareOwnerOnly),
3835 .special = NULL,
3836 .enum_list = NULL,
3837 .flags = FLAG_ADVANCED,
3838 },
3839 {
3840 .label = "usershare path",
3841 .type = P_STRING,
3842 .p_class = P_GLOBAL,
3843 .offset = GLOBAL_VAR(szUsersharePath),
3844 .special = NULL,
3845 .enum_list = NULL,
3846 .flags = FLAG_ADVANCED,
3847 },
3848 {
3849 .label = "usershare prefix allow list",
3850 .type = P_LIST,
3851 .p_class = P_GLOBAL,
3852 .offset = GLOBAL_VAR(szUsersharePrefixAllowList),
3853 .special = NULL,
3854 .enum_list = NULL,
3855 .flags = FLAG_ADVANCED,
3856 },
3857 {
3858 .label = "usershare prefix deny list",
3859 .type = P_LIST,
3860 .p_class = P_GLOBAL,
3861 .offset = GLOBAL_VAR(szUsersharePrefixDenyList),
3862 .special = NULL,
3863 .enum_list = NULL,
3864 .flags = FLAG_ADVANCED,
3865 },
3866 {
3867 .label = "usershare template share",
3868 .type = P_STRING,
3869 .p_class = P_GLOBAL,
3870 .offset = GLOBAL_VAR(szUsershareTemplateShare),
3871 .special = NULL,
3872 .enum_list = NULL,
3873 .flags = FLAG_ADVANCED,
3874 },
3875 {
3876 .label = "volume",
3877 .type = P_STRING,
3878 .p_class = P_LOCAL,
3879 .offset = LOCAL_VAR(volume),
3880 .special = NULL,
3881 .enum_list = NULL,
3882 .flags = FLAG_ADVANCED | FLAG_SHARE,
3883 },
3884 {
3885 .label = "fstype",
3886 .type = P_STRING,
3887 .p_class = P_LOCAL,
3888 .offset = LOCAL_VAR(fstype),
3889 .special = NULL,
3890 .enum_list = NULL,
3891 .flags = FLAG_ADVANCED | FLAG_SHARE,
3892 },
3893 {
3894 .label = "set directory",
3895 .type = P_BOOLREV,
3896 .p_class = P_LOCAL,
3897 .offset = LOCAL_VAR(bNo_set_dir),
3898 .special = NULL,
3899 .enum_list = NULL,
3900 .flags = FLAG_ADVANCED | FLAG_SHARE,
3901 },
3902 {
3903 .label = "allow insecure wide links",
3904 .type = P_BOOL,
3905 .p_class = P_GLOBAL,
3906 .offset = GLOBAL_VAR(bAllowInsecureWidelinks),
3907 .special = NULL,
3908 .enum_list = NULL,
3909 .flags = FLAG_ADVANCED,
3910 },
3911 {
3912 .label = "wide links",
3913 .type = P_BOOL,
3914 .p_class = P_LOCAL,
3915 .offset = LOCAL_VAR(bWidelinks),
3916 .special = NULL,
3917 .enum_list = NULL,
3918 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3919 },
3920 {
3921 .label = "follow symlinks",
3922 .type = P_BOOL,
3923 .p_class = P_LOCAL,
3924 .offset = LOCAL_VAR(bSymlinks),
3925 .special = NULL,
3926 .enum_list = NULL,
3927 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3928 },
3929 {
3930 .label = "dont descend",
3931 .type = P_STRING,
3932 .p_class = P_LOCAL,
3933 .offset = LOCAL_VAR(szDontdescend),
3934 .special = NULL,
3935 .enum_list = NULL,
3936 .flags = FLAG_ADVANCED | FLAG_SHARE,
3937 },
3938 {
3939 .label = "magic script",
3940 .type = P_STRING,
3941 .p_class = P_LOCAL,
3942 .offset = LOCAL_VAR(szMagicScript),
3943 .special = NULL,
3944 .enum_list = NULL,
3945 .flags = FLAG_ADVANCED | FLAG_SHARE,
3946 },
3947 {
3948 .label = "magic output",
3949 .type = P_STRING,
3950 .p_class = P_LOCAL,
3951 .offset = LOCAL_VAR(szMagicOutput),
3952 .special = NULL,
3953 .enum_list = NULL,
3954 .flags = FLAG_ADVANCED | FLAG_SHARE,
3955 },
3956 {
3957 .label = "delete readonly",
3958 .type = P_BOOL,
3959 .p_class = P_LOCAL,
3960 .offset = LOCAL_VAR(bDeleteReadonly),
3961 .special = NULL,
3962 .enum_list = NULL,
3963 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3964 },
3965 {
3966 .label = "dos filemode",
3967 .type = P_BOOL,
3968 .p_class = P_LOCAL,
3969 .offset = LOCAL_VAR(bDosFilemode),
3970 .special = NULL,
3971 .enum_list = NULL,
3972 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3973 },
3974 {
3975 .label = "dos filetimes",
3976 .type = P_BOOL,
3977 .p_class = P_LOCAL,
3978 .offset = LOCAL_VAR(bDosFiletimes),
3979 .special = NULL,
3980 .enum_list = NULL,
3981 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3982 },
3983 {
3984 .label = "dos filetime resolution",
3985 .type = P_BOOL,
3986 .p_class = P_LOCAL,
3987 .offset = LOCAL_VAR(bDosFiletimeResolution),
3988 .special = NULL,
3989 .enum_list = NULL,
3990 .flags = FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL,
3991 },
3992 {
3993 .label = "fake directory create times",
3994 .type = P_BOOL,
3995 .p_class = P_LOCAL,
3996 .offset = LOCAL_VAR(bFakeDirCreateTimes),
3997 .special = NULL,
3998 .enum_list = NULL,
3999 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
4000 },
4001 {
4002 .label = "async smb echo handler",
4003 .type = P_BOOL,
4004 .p_class = P_GLOBAL,
4005 .offset = GLOBAL_VAR(bAsyncSMBEchoHandler),
4006 .special = NULL,
4007 .enum_list = NULL,
4008 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
4009 },
4010 {
4011 .label = "multicast dns register",
4012 .type = P_BOOL,
4013 .p_class = P_GLOBAL,
4014 .offset = GLOBAL_VAR(bMulticastDnsRegister),
4015 .special = NULL,
4016 .enum_list = NULL,
4017 .flags = FLAG_ADVANCED | FLAG_GLOBAL,
4018 },
4019 {
4020 .label = "panic action",
4021 .type = P_STRING,
4022 .p_class = P_GLOBAL,
4023 .offset = GLOBAL_VAR(szPanicAction),
4024 .special = NULL,
4025 .enum_list = NULL,
4026 .flags = FLAG_ADVANCED,
4027 },
4028 {
4029 .label = "perfcount module",
4030 .type = P_STRING,
4031 .p_class = P_GLOBAL,
4032 .offset = GLOBAL_VAR(szSMBPerfcountModule),
4033 .special = NULL,
4034 .enum_list = NULL,
4035 .flags = FLAG_ADVANCED,
4036 },
4037
4038 {N_("VFS module options"), P_SEP, P_SEPARATOR},
4039
4040 {
4041 .label = "vfs objects",
4042 .type = P_LIST,
4043 .p_class = P_LOCAL,
4044 .offset = LOCAL_VAR(szVfsObjects),
4045 .special = NULL,
4046 .enum_list = NULL,
4047 .flags = FLAG_ADVANCED | FLAG_SHARE,
4048 },
4049 {
4050 .label = "vfs object",
4051 .type = P_LIST,
4052 .p_class = P_LOCAL,
4053 .offset = LOCAL_VAR(szVfsObjects),
4054 .special = NULL,
4055 .enum_list = NULL,
4056 .flags = FLAG_HIDE,
4057 },
4058
4059
4060 {N_("MSDFS options"), P_SEP, P_SEPARATOR},
4061
4062 {
4063 .label = "msdfs root",
4064 .type = P_BOOL,
4065 .p_class = P_LOCAL,
4066 .offset = LOCAL_VAR(bMSDfsRoot),
4067 .special = NULL,
4068 .enum_list = NULL,
4069 .flags = FLAG_ADVANCED | FLAG_SHARE,
4070 },
4071 {
4072 .label = "msdfs proxy",
4073 .type = P_STRING,
4074 .p_class = P_LOCAL,
4075 .offset = LOCAL_VAR(szMSDfsProxy),
4076 .special = NULL,
4077 .enum_list = NULL,
4078 .flags = FLAG_ADVANCED | FLAG_SHARE,
4079 },
4080 {
4081 .label = "host msdfs",
4082 .type = P_BOOL,
4083 .p_class = P_GLOBAL,
4084 .offset = GLOBAL_VAR(bHostMSDfs),
4085 .special = NULL,
4086 .enum_list = NULL,
4087 .flags = FLAG_ADVANCED,
4088 },
4089
4090 {N_("Winbind options"), P_SEP, P_SEPARATOR},
4091
4092 {
4093 .label = "passdb expand explicit",
4094 .type = P_BOOL,
4095 .p_class = P_GLOBAL,
4096 .offset = GLOBAL_VAR(bPassdbExpandExplicit),
4097 .special = NULL,
4098 .enum_list = NULL,
4099 .flags = FLAG_ADVANCED,
4100 },
4101 {
4102 .label = "idmap backend",
4103 .type = P_STRING,
4104 .p_class = P_GLOBAL,
4105 .offset = GLOBAL_VAR(szIdmapBackend),
4106 .special = handle_idmap_backend,
4107 .enum_list = NULL,
4108 .flags = FLAG_ADVANCED | FLAG_DEPRECATED,
4109 },
4110 {
4111 .label = "idmap cache time",
4112 .type = P_INTEGER,
4113 .p_class = P_GLOBAL,
4114 .offset = GLOBAL_VAR(iIdmapCacheTime),
4115 .special = NULL,
4116 .enum_list = NULL,
4117 .flags = FLAG_ADVANCED,
4118 },
4119 {
4120 .label = "idmap negative cache time",
4121 .type = P_INTEGER,
4122 .p_class = P_GLOBAL,
4123 .offset = GLOBAL_VAR(iIdmapNegativeCacheTime),
4124 .special = NULL,
4125 .enum_list = NULL,
4126 .flags = FLAG_ADVANCED,
4127 },
4128 {
4129 .label = "idmap uid",
4130 .type = P_STRING,
4131 .p_class = P_GLOBAL,
4132 .offset = GLOBAL_VAR(szIdmapUID),
4133 .special = handle_idmap_uid,
4134 .enum_list = NULL,
4135 .flags = FLAG_ADVANCED | FLAG_DEPRECATED,
4136 },
4137 {
4138 .label = "winbind uid",
4139 .type = P_STRING,
4140 .p_class = P_GLOBAL,
4141 .offset = GLOBAL_VAR(szIdmapUID),
4142 .special = handle_idmap_uid,
4143 .enum_list = NULL,
4144 .flags = FLAG_HIDE,
4145 },
4146 {
4147 .label = "idmap gid",
4148 .type = P_STRING,
4149 .p_class = P_GLOBAL,
4150 .offset = GLOBAL_VAR(szIdmapGID),
4151 .special = handle_idmap_gid,
4152 .enum_list = NULL,
4153 .flags = FLAG_ADVANCED | FLAG_DEPRECATED,
4154 },
4155 {
4156 .label = "winbind gid",
4157 .type = P_STRING,
4158 .p_class = P_GLOBAL,
4159 .offset = GLOBAL_VAR(szIdmapGID),
4160 .special = handle_idmap_gid,
4161 .enum_list = NULL,
4162 .flags = FLAG_HIDE,
4163 },
4164 {
4165 .label = "template homedir",
4166 .type = P_STRING,
4167 .p_class = P_GLOBAL,
4168 .offset = GLOBAL_VAR(szTemplateHomedir),
4169 .special = NULL,
4170 .enum_list = NULL,
4171 .flags = FLAG_ADVANCED,
4172 },
4173 {
4174 .label = "template shell",
4175 .type = P_STRING,
4176 .p_class = P_GLOBAL,
4177 .offset = GLOBAL_VAR(szTemplateShell),
4178 .special = NULL,
4179 .enum_list = NULL,
4180 .flags = FLAG_ADVANCED,
4181 },
4182 {
4183 .label = "winbind separator",
4184 .type = P_STRING,
4185 .p_class = P_GLOBAL,
4186 .offset = GLOBAL_VAR(szWinbindSeparator),
4187 .special = NULL,
4188 .enum_list = NULL,
4189 .flags = FLAG_ADVANCED,
4190 },
4191 {
4192 .label = "winbind cache time",
4193 .type = P_INTEGER,
4194 .p_class = P_GLOBAL,
4195 .offset = GLOBAL_VAR(winbind_cache_time),
4196 .special = NULL,
4197 .enum_list = NULL,
4198 .flags = FLAG_ADVANCED,
4199 },
4200 {
4201 .label = "winbind reconnect delay",
4202 .type = P_INTEGER,
4203 .p_class = P_GLOBAL,
4204 .offset = GLOBAL_VAR(winbind_reconnect_delay),
4205 .special = NULL,
4206 .enum_list = NULL,
4207 .flags = FLAG_ADVANCED,
4208 },
4209 {
4210 .label = "winbind max clients",
4211 .type = P_INTEGER,
4212 .p_class = P_GLOBAL,
4213 .offset = GLOBAL_VAR(winbind_max_clients),
4214 .special = NULL,
4215 .enum_list = NULL,
4216 .flags = FLAG_ADVANCED,
4217 },
4218 {
4219 .label = "winbind enum users",
4220 .type = P_BOOL,
4221 .p_class = P_GLOBAL,
4222 .offset = GLOBAL_VAR(bWinbindEnumUsers),
4223 .special = NULL,
4224 .enum_list = NULL,
4225 .flags = FLAG_ADVANCED,
4226 },
4227 {
4228 .label = "winbind enum groups",
4229 .type = P_BOOL,
4230 .p_class = P_GLOBAL,
4231 .offset = GLOBAL_VAR(bWinbindEnumGroups),
4232 .special = NULL,
4233 .enum_list = NULL,
4234 .flags = FLAG_ADVANCED,
4235 },
4236 {
4237 .label = "winbind use default domain",
4238 .type = P_BOOL,
4239 .p_class = P_GLOBAL,
4240 .offset = GLOBAL_VAR(bWinbindUseDefaultDomain),
4241 .special = NULL,
4242 .enum_list = NULL,
4243 .flags = FLAG_ADVANCED,
4244 },
4245 {
4246 .label = "winbind trusted domains only",
4247 .type = P_BOOL,
4248 .p_class = P_GLOBAL,
4249 .offset = GLOBAL_VAR(bWinbindTrustedDomainsOnly),
4250 .special = NULL,
4251 .enum_list = NULL,
4252 .flags = FLAG_ADVANCED,
4253 },
4254 {
4255 .label = "winbind nested groups",
4256 .type = P_BOOL,
4257 .p_class = P_GLOBAL,
4258 .offset = GLOBAL_VAR(bWinbindNestedGroups),
4259 .special = NULL,
4260 .enum_list = NULL,
4261 .flags = FLAG_ADVANCED,
4262 },
4263 {
4264 .label = "winbind expand groups",
4265 .type = P_INTEGER,
4266 .p_class = P_GLOBAL,
4267 .offset = GLOBAL_VAR(winbind_expand_groups),
4268 .special = NULL,
4269 .enum_list = NULL,
4270 .flags = FLAG_ADVANCED,
4271 },
4272 {
4273 .label = "winbind nss info",
4274 .type = P_LIST,
4275 .p_class = P_GLOBAL,
4276 .offset = GLOBAL_VAR(szWinbindNssInfo),
4277 .special = NULL,
4278 .enum_list = NULL,
4279 .flags = FLAG_ADVANCED,
4280 },
4281 {
4282 .label = "winbind refresh tickets",
4283 .type = P_BOOL,
4284 .p_class = P_GLOBAL,
4285 .offset = GLOBAL_VAR(bWinbindRefreshTickets),
4286 .special = NULL,
4287 .enum_list = NULL,
4288 .flags = FLAG_ADVANCED,
4289 },
4290 {
4291 .label = "winbind offline logon",
4292 .type = P_BOOL,
4293 .p_class = P_GLOBAL,
4294 .offset = GLOBAL_VAR(bWinbindOfflineLogon),
4295 .special = NULL,
4296 .enum_list = NULL,
4297 .flags = FLAG_ADVANCED,
4298 },
4299 {
4300 .label = "winbind normalize names",
4301 .type = P_BOOL,
4302 .p_class = P_GLOBAL,
4303 .offset = GLOBAL_VAR(bWinbindNormalizeNames),
4304 .special = NULL,
4305 .enum_list = NULL,
4306 .flags = FLAG_ADVANCED,
4307 },
4308 {
4309 .label = "winbind rpc only",
4310 .type = P_BOOL,
4311 .p_class = P_GLOBAL,
4312 .offset = GLOBAL_VAR(bWinbindRpcOnly),
4313 .special = NULL,
4314 .enum_list = NULL,
4315 .flags = FLAG_ADVANCED,
4316 },
4317 {
4318 .label = "create krb5 conf",
4319 .type = P_BOOL,
4320 .p_class = P_GLOBAL,
4321 .offset = GLOBAL_VAR(bCreateKrb5Conf),
4322 .special = NULL,
4323 .enum_list = NULL,
4324 .flags = FLAG_ADVANCED,
4325 },
4326 {
4327 .label = "ncalrpc dir",
4328 .type = P_STRING,
4329 .p_class = P_GLOBAL,
4330 .offset = GLOBAL_VAR(ncalrpc_dir),
4331 .special = NULL,
4332 .enum_list = NULL,
4333 .flags = FLAG_ADVANCED,
4334 },
4335 {
4336 .label = "winbind max domain connections",
4337 .type = P_INTEGER,
4338 .p_class = P_GLOBAL,
4339 .offset = GLOBAL_VAR(winbindMaxDomainConnections),
4340 .special = NULL,
4341 .enum_list = NULL,
4342 .flags = FLAG_ADVANCED,
4343 },
4344
4345 {NULL, P_BOOL, P_NONE, 0, NULL, NULL, 0}
4346 };
4347
4348 /***************************************************************************
4349 Initialise the sDefault parameter structure for the printer values.
4350 ***************************************************************************/
4351
4352 static void init_printer_values(struct loadparm_service *pService)
4353 {
4354 /* choose defaults depending on the type of printing */
4355 switch (pService->iPrinting) {
4356 case PRINT_BSD:
4357 case PRINT_AIX:
4358 case PRINT_LPRNT:
4359 case PRINT_LPROS2:
4360 string_set(&pService->szLpqcommand, "lpq -P'%p'");
4361 string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
4362 string_set(&pService->szPrintcommand, "lpr -r -P'%p' %s");
4363 break;
4364
4365 case PRINT_LPRNG:
4366 case PRINT_PLP:
4367 string_set(&pService->szLpqcommand, "lpq -P'%p'");
4368 string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
4369 string_set(&pService->szPrintcommand, "lpr -r -P'%p' %s");
4370 string_set(&pService->szQueuepausecommand, "lpc stop '%p'");
4371 string_set(&pService->szQueueresumecommand, "lpc start '%p'");
4372 string_set(&pService->szLppausecommand, "lpc hold '%p' %j");
4373 string_set(&pService->szLpresumecommand, "lpc release '%p' %j");
4374 break;
4375
4376 case PRINT_CUPS:
4377 case PRINT_IPRINT:
4378 #ifdef HAVE_CUPS
4379 /* set the lpq command to contain the destination printer
4380 name only. This is used by cups_queue_get() */
4381 string_set(&pService->szLpqcommand, "%p");
4382 string_set(&pService->szLprmcommand, "");
4383 string_set(&pService->szPrintcommand, "");
4384 string_set(&pService->szLppausecommand, "");
4385 string_set(&pService->szLpresumecommand, "");
4386 string_set(&pService->szQueuepausecommand, "");
4387 string_set(&pService->szQueueresumecommand, "");
4388 #else
4389 string_set(&pService->szLpqcommand, "lpq -P'%p'");
4390 string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
4391 string_set(&pService->szPrintcommand, "lpr -P'%p' %s; rm %s");
4392 string_set(&pService->szLppausecommand, "lp -i '%p-%j' -H hold");
4393 string_set(&pService->szLpresumecommand, "lp -i '%p-%j' -H resume");
4394 string_set(&pService->szQueuepausecommand, "disable '%p'");
4395 string_set(&pService->szQueueresumecommand, "enable '%p'");
4396 #endif /* HAVE_CUPS */
4397 break;
4398
4399 case PRINT_SYSV:
4400 case PRINT_HPUX:
4401 string_set(&pService->szLpqcommand, "lpstat -o%p");
4402 string_set(&pService->szLprmcommand, "cancel %p-%j");
4403 string_set(&pService->szPrintcommand, "lp -c -d%p %s; rm %s");
4404 string_set(&pService->szQueuepausecommand, "disable %p");
4405 string_set(&pService->szQueueresumecommand, "enable %p");
4406 #ifndef HPUX
4407 string_set(&pService->szLppausecommand, "lp -i %p-%j -H hold");
4408 string_set(&pService->szLpresumecommand, "lp -i %p-%j -H resume");
4409 #endif /* HPUX */
4410 break;
4411
4412 case PRINT_QNX:
4413 string_set(&pService->szLpqcommand, "lpq -P%p");
4414 string_set(&pService->szLprmcommand, "lprm -P%p %j");
4415 string_set(&pService->szPrintcommand, "lp -r -P%p %s");
4416 break;
4417
4418 #if defined(DEVELOPER) || defined(ENABLE_BUILD_FARM_HACKS)
4419
4420 case PRINT_TEST:
4421 case PRINT_VLP: {
4422 const char *tdbfile;
4423 char *tmp;
4424
4425 tdbfile = talloc_asprintf(
4426 talloc_tos(), "tdbfile=%s",
4427 lp_parm_const_string(-1, "vlp", "tdbfile",
4428 "/tmp/vlp.tdb"));
4429 if (tdbfile == NULL) {
4430 tdbfile="tdbfile=/tmp/vlp.tdb";
4431 }
4432
4433 tmp = talloc_asprintf(talloc_tos(), "vlp %s print %%p %%s",
4434 tdbfile);
4435 string_set(&pService->szPrintcommand,
4436 tmp ? tmp : "vlp print %p %s");
4437 TALLOC_FREE(tmp);
4438
4439 tmp = talloc_asprintf(talloc_tos(), "vlp %s lpq %%p",
4440 tdbfile);
4441 string_set(&pService->szLpqcommand,
4442 tmp ? tmp : "vlp lpq %p");
4443 TALLOC_FREE(tmp);
4444
4445 tmp = talloc_asprintf(talloc_tos(), "vlp %s lprm %%p %%j",
4446 tdbfile);
4447 string_set(&pService->szLprmcommand,
4448 tmp ? tmp : "vlp lprm %p %j");
4449 TALLOC_FREE(tmp);
4450
4451 tmp = talloc_asprintf(talloc_tos(), "vlp %s lppause %%p %%j",
4452 tdbfile);
4453 string_set(&pService->szLppausecommand,
4454 tmp ? tmp : "vlp lppause %p %j");
4455 TALLOC_FREE(tmp);
4456
4457 tmp = talloc_asprintf(talloc_tos(), "vlp %s lpresume %%p %%j",
4458 tdbfile);
4459 string_set(&pService->szLpresumecommand,
4460 tmp ? tmp : "vlp lpresume %p %j");
4461 TALLOC_FREE(tmp);
4462
4463 tmp = talloc_asprintf(talloc_tos(), "vlp %s queuepause %%p",
4464 tdbfile);
4465 string_set(&pService->szQueuepausecommand,
4466 tmp ? tmp : "vlp queuepause %p");
4467 TALLOC_FREE(tmp);
4468
4469 tmp = talloc_asprintf(talloc_tos(), "vlp %s queueresume %%p",
4470 tdbfile);
4471 string_set(&pService->szQueueresumecommand,
4472 tmp ? tmp : "vlp queueresume %p");
4473 TALLOC_FREE(tmp);
4474
4475 break;
4476 }
4477 #endif /* DEVELOPER */
4478
4479 }
4480 }
4481 /**
4482 * Function to return the default value for the maximum number of open
4483 * file descriptors permitted. This function tries to consult the
4484 * kernel-level (sysctl) and ulimit (getrlimit()) values and goes
4485 * the smaller of those.
4486 */
4487 static int max_open_files(void)
4488 {
4489 int sysctl_max = MAX_OPEN_FILES;
4490 int rlimit_max = MAX_OPEN_FILES;
4491
4492 #ifdef HAVE_SYSCTLBYNAME
4493 {
4494 size_t size = sizeof(sysctl_max);
4495 sysctlbyname("kern.maxfilesperproc", &sysctl_max, &size, NULL,
4496 0);
4497 }
4498 #endif
4499
4500 #if (defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE))
4501 {
4502 struct rlimit rl;
4503
4504 ZERO_STRUCT(rl);
4505
4506 if (getrlimit(RLIMIT_NOFILE, &rl) == 0)
4507 rlimit_max = rl.rlim_cur;
4508
4509 #if defined(RLIM_INFINITY)
4510 if(rl.rlim_cur == RLIM_INFINITY)
4511 rlimit_max = MAX_OPEN_FILES;
4512 #endif
4513 }
4514 #endif
4515
4516 if (sysctl_max < MIN_OPEN_FILES_WINDOWS) {
4517 DEBUG(2,("max_open_files: increasing sysctl_max (%d) to "
4518 "minimum Windows limit (%d)\n",
4519 sysctl_max,
4520 MIN_OPEN_FILES_WINDOWS));
4521 sysctl_max = MIN_OPEN_FILES_WINDOWS;
4522 }
4523
4524 if (rlimit_max < MIN_OPEN_FILES_WINDOWS) {
4525 DEBUG(2,("rlimit_max: increasing rlimit_max (%d) to "
4526 "minimum Windows limit (%d)\n",
4527 rlimit_max,
4528 MIN_OPEN_FILES_WINDOWS));
4529 rlimit_max = MIN_OPEN_FILES_WINDOWS;
4530 }
4531
4532 return MIN(sysctl_max, rlimit_max);
4533 }
4534
4535 /**
4536 * Common part of freeing allocated data for one parameter.
4537 */
4538 static void free_one_parameter_common(void *parm_ptr,
4539 struct parm_struct parm)
4540 {
4541 if ((parm.type == P_STRING) ||
4542 (parm.type == P_USTRING))
4543 {
4544 string_free((char**)parm_ptr);
4545 } else if (parm.type == P_LIST) {
4546 TALLOC_FREE(*((char***)parm_ptr));
4547 }
4548 }
4549
4550 /**
4551 * Free the allocated data for one parameter for a share
4552 * given as a service struct.
4553 */
4554 static void free_one_parameter(struct loadparm_service *service,
4555 struct parm_struct parm)
4556 {
4557 void *parm_ptr;
4558
4559 if (parm.p_class != P_LOCAL) {
4560 return;
4561 }
4562
4563 parm_ptr = lp_parm_ptr(service, &parm);
4564
4565 free_one_parameter_common(parm_ptr, parm);
4566 }
4567
4568 /**
4569 * Free the allocated parameter data of a share given
4570 * as a service struct.
4571 */
4572 static void free_parameters(struct loadparm_service *service)
4573 {
4574 uint32_t i;
4575
4576 for (i=0; parm_table[i].label; i++) {
4577 free_one_parameter(service, parm_table[i]);
4578 }
4579 }
4580
4581 /**
4582 * Free the allocated data for one parameter for a given share
4583 * specified by an snum.
4584 */
4585 static void free_one_parameter_by_snum(int snum, struct parm_struct parm)
4586 {
4587 void *parm_ptr;
4588
4589 if (snum < 0) {
4590 parm_ptr = lp_parm_ptr(NULL, &parm);
4591 } else if (parm.p_class != P_LOCAL) {
4592 return;
4593 } else {
4594 parm_ptr = lp_local_ptr_by_snum(snum, &parm);
4595 }
4596
4597 free_one_parameter_common(parm_ptr, parm);
4598 }
4599
4600 /**
4601 * Free the allocated parameter data for a share specified
4602 * by an snum.
4603 */
4604 static void free_parameters_by_snum(int snum)
4605 {
4606 uint32_t i;
4607
4608 for (i=0; parm_table[i].label; i++) {
4609 free_one_parameter_by_snum(snum, parm_table[i]);
4610 }
4611 }
4612
4613 /**
4614 * Free the allocated global parameters.
4615 */
4616 static void free_global_parameters(void)
4617 {
4618 free_param_opts(&Globals.param_opt);
4619 free_parameters_by_snum(GLOBAL_SECTION_SNUM);
4620 }
4621
4622 static int map_parameter(const char *pszParmName);
4623
4624 struct lp_stored_option {
4625 struct lp_stored_option *prev, *next;
4626 const char *label;
4627 const char *value;
4628 };
4629
4630 static struct lp_stored_option *stored_options;
4631
4632 /*
4633 save options set by lp_set_cmdline() into a list. This list is
4634 re-applied when we do a globals reset, so that cmdline set options
4635 are sticky across reloads of smb.conf
4636 */
4637 static bool store_lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
4638 {
4639 struct lp_stored_option *entry, *entry_next;
4640 for (entry = stored_options; entry != NULL; entry = entry_next) {
4641 entry_next = entry->next;
4642 if (strcmp(pszParmName, entry->label) == 0) {
4643 DLIST_REMOVE(stored_options, entry);
4644 talloc_free(entry);
4645 break;
4646 }
4647 }
4648
4649 entry = talloc(NULL, struct lp_stored_option);
4650 if (!entry) {
4651 return false;
4652 }
4653
4654 entry->label = talloc_strdup(entry, pszParmName);
4655 if (!entry->label) {
4656 talloc_free(entry);
4657 return false;
4658 }
4659
4660 entry->value = talloc_strdup(entry, pszParmValue);
4661 if (!entry->value) {
4662 talloc_free(entry);
4663 return false;
4664 }
4665
4666 DLIST_ADD_END(stored_options, entry, struct lp_stored_option);
4667
4668 return true;
4669 }
4670
4671 static bool apply_lp_set_cmdline(void)
4672 {
4673 struct lp_stored_option *entry = NULL;
4674 for (entry = stored_options; entry != NULL; entry = entry->next) {
4675 if (!lp_set_cmdline_helper(entry->label, entry->value, false)) {
4676 DEBUG(0, ("Failed to re-apply cmdline parameter %s = %s\n",
4677 entry->label, entry->value));
4678 return false;
4679 }
4680 }
4681 return true;
4682 }
4683
4684 /***************************************************************************
4685 Initialise the global parameter structure.
4686 ***************************************************************************/
4687
4688 static void init_globals(bool reinit_globals)
4689 {
4690 static bool done_init = false;
4691 char *s = NULL;
4692 int i;
4693
4694 /* If requested to initialize only once and we've already done it... */
4695 if (!reinit_globals && done_init) {
4696 /* ... then we have nothing more to do */
4697 return;
4698 }
4699
4700 if (!done_init) {
4701 /* The logfile can be set before this is invoked. Free it if so. */
4702 if (Globals.szLogFile != NULL) {
4703 string_free(&Globals.szLogFile);
4704 Globals.szLogFile = NULL;
4705 }
4706 done_init = true;
4707 } else {
4708 free_global_parameters();
4709 }
4710
4711 /* This memset and the free_global_parameters() above will
4712 * wipe out smb.conf options set with lp_set_cmdline(). The
4713 * apply_lp_set_cmdline() call puts these values back in the
4714 * table once the defaults are set */
4715 ZERO_STRUCT(Globals);
4716
4717 for (i = 0; parm_table[i].label; i++) {
4718 if ((parm_table[i].type == P_STRING ||
4719 parm_table[i].type == P_USTRING))
4720 {
4721 string_set((char **)lp_parm_ptr(NULL, &parm_table[i]), "");
4722 }
4723 }
4724
4725
4726 string_set(&sDefault.fstype, FSTYPE_STRING);
4727 string_set(&sDefault.szPrintjobUsername, "%U");
4728
4729 init_printer_values(&sDefault);
4730
4731
4732 DEBUG(3, ("Initialising global parameters\n"));
4733
4734 /* Must manually force to upper case here, as this does not go via the handler */
4735 string_set(&Globals.szNetbiosName, myhostname_upper());
4736
4737 string_set(&Globals.szSMBPasswdFile, get_dyn_SMB_PASSWD_FILE());
4738 string_set(&Globals.szPrivateDir, get_dyn_PRIVATE_DIR());
4739
4740 /* use the new 'hash2' method by default, with a prefix of 1 */
4741 string_set(&Globals.szManglingMethod, "hash2");
4742 Globals.mangle_prefix = 1;
4743
4744 string_set(&Globals.szGuestaccount, GUEST_ACCOUNT);
4745
4746 /* using UTF8 by default allows us to support all chars */
4747 string_set(&Globals.unix_charset, DEFAULT_UNIX_CHARSET);
4748
4749 /* Use codepage 850 as a default for the dos character set */
4750 string_set(&Globals.dos_charset, DEFAULT_DOS_CHARSET);
4751
4752 /*
4753 * Allow the default PASSWD_CHAT to be overridden in local.h.
4754 */
4755 string_set(&Globals.szPasswdChat, DEFAULT_PASSWD_CHAT);
4756
4757 string_set(&Globals.szWorkgroup, DEFAULT_WORKGROUP);
4758
4759 string_set(&Globals.szPasswdProgram, "");
4760 string_set(&Globals.szLockDir, get_dyn_LOCKDIR());
4761 string_set(&Globals.szStateDir, get_dyn_STATEDIR());
4762 string_set(&Globals.szCacheDir, get_dyn_CACHEDIR());
4763 string_set(&Globals.szPidDir, get_dyn_PIDDIR());
4764 string_set(&Globals.szSocketAddress, "0.0.0.0");
4765 /*
4766 * By default support explicit binding to broadcast
4767 * addresses.
4768 */
4769 Globals.bNmbdBindExplicitBroadcast = true;
4770
4771 if (asprintf(&s, "Samba %s", samba_version_string()) < 0) {
4772 smb_panic("init_globals: ENOMEM");
4773 }
4774 string_set(&Globals.szServerString, s);
4775 SAFE_FREE(s);
4776 #ifdef DEVELOPER
4777 string_set(&Globals.szPanicAction, "/bin/sleep 999999999");
4778 #endif
4779
4780 string_set(&Globals.szSocketOptions, DEFAULT_SOCKET_OPTIONS);
4781
4782 string_set(&Globals.szLogonDrive, "");
4783 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
4784 string_set(&Globals.szLogonHome, "\\\\%N\\%U");
4785 string_set(&Globals.szLogonPath, "\\\\%N\\%U\\profile");
4786
4787 string_set(&Globals.szNameResolveOrder, "lmhosts wins host bcast");
4788 string_set(&Globals.szPasswordServer, "*");
4789
4790 Globals.AlgorithmicRidBase = BASE_RID;
4791
4792 Globals.bLoadPrinters = true;
4793 Globals.PrintcapCacheTime = 750; /* 12.5 minutes */
4794
4795 Globals.ConfigBackend = config_backend;
4796
4797 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
4798 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
4799 Globals.max_xmit = 0x4104;
4800 Globals.max_mux = 50; /* This is *needed* for profile support. */
4801 Globals.lpqcachetime = 30; /* changed to handle large print servers better -- jerry */
4802 Globals.bDisableSpoolss = false;
4803 Globals.iMaxSmbdProcesses = 0;/* no limit specified */
4804 Globals.pwordlevel = 0;
4805 Globals.unamelevel = 0;
4806 Globals.deadtime = 0;
4807 Globals.getwd_cache = true;
4808 Globals.bLargeReadwrite = true;
4809 Globals.max_log_size = 5000;
4810 Globals.max_open_files = max_open_files();
4811 Globals.open_files_db_hash_size = SMB_OPEN_DATABASE_TDB_HASH_SIZE;
4812 Globals.maxprotocol = PROTOCOL_NT1;
4813 Globals.minprotocol = PROTOCOL_CORE;
4814 Globals.security = SEC_USER;
4815 Globals.paranoid_server_security = true;
4816 Globals.bEncryptPasswords = true;
4817 Globals.clientSchannel = Auto;
4818 Globals.serverSchannel = Auto;
4819 Globals.bReadRaw = true;
4820 Globals.bWriteRaw = true;
4821 Globals.bNullPasswords = false;
4822 Globals.bObeyPamRestrictions = false;
4823 Globals.syslog = 1;
4824 Globals.bSyslogOnly = false;
4825 Globals.bTimestampLogs = true;
4826 string_set(&Globals.szLogLevel, "0");
4827 Globals.bDebugPrefixTimestamp = false;
4828 Globals.bDebugHiresTimestamp = true;
4829 Globals.bDebugPid = false;
4830 Globals.bDebugUid = false;
4831 Globals.bDebugClass = false;
4832 Globals.bEnableCoreFiles = true;
4833 Globals.max_ttl = 60 * 60 * 24 * 3; /* 3 days default. */
4834 Globals.max_wins_ttl = 60 * 60 * 24 * 6; /* 6 days default. */
4835 Globals.min_wins_ttl = 60 * 60 * 6; /* 6 hours default. */
4836 Globals.machine_password_timeout = 60 * 60 * 24 * 7; /* 7 days default. */
4837 Globals.lm_announce = Auto; /* = Auto: send only if LM clients found */
4838 Globals.lm_interval = 60;
4839 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
4840 Globals.bNISHomeMap = false;
4841 #ifdef WITH_NISPLUS_HOME
4842 string_set(&Globals.szNISHomeMapName, "auto_home.org_dir");
4843 #else
4844 string_set(&Globals.szNISHomeMapName, "auto.home");
4845 #endif
4846 #endif
4847 Globals.bTimeServer = false;
4848 Globals.bBindInterfacesOnly = false;
4849 Globals.bUnixPasswdSync = false;
4850 Globals.bPamPasswordChange = false;
4851 Globals.bPasswdChatDebug = false;
4852 Globals.iPasswdChatTimeout = 2; /* 2 second default. */
4853 Globals.bNTPipeSupport = true; /* Do NT pipes by default. */
4854 Globals.bNTStatusSupport = true; /* Use NT status by default. */
4855 Globals.bStatCache = true; /* use stat cache by default */
4856 Globals.iMaxStatCacheSize = 256; /* 256k by default */
4857 Globals.restrict_anonymous = 0;
4858 Globals.bClientLanManAuth = false; /* Do NOT use the LanMan hash if it is available */
4859 Globals.bClientPlaintextAuth = false; /* Do NOT use a plaintext password even if is requested by the server */
4860 Globals.bLanmanAuth = false; /* Do NOT use the LanMan hash, even if it is supplied */
4861 Globals.bNTLMAuth = true; /* Do use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
4862 Globals.bClientNTLMv2Auth = true; /* Client should always use use NTLMv2, as we can't tell that the server supports it, but most modern servers do */
4863 /* Note, that we will also use NTLM2 session security (which is different), if it is available */
4864
4865 Globals.map_to_guest = 0; /* By Default, "Never" */
4866 Globals.oplock_break_wait_time = 0; /* By Default, 0 msecs. */
4867 Globals.enhanced_browsing = true;
4868 Globals.iLockSpinTime = WINDOWS_MINIMUM_LOCK_TIMEOUT_MS; /* msec. */
4869 #ifdef MMAP_BLACKLIST
4870 Globals.bUseMmap = false;
4871 #else
4872 Globals.bUseMmap = true;
4873 #endif
4874 Globals.bUnixExtensions = true;
4875 Globals.bResetOnZeroVC = false;
4876 Globals.bLogWriteableFilesOnExit = false;
4877 Globals.bCreateKrb5Conf = true;
4878 Globals.winbindMaxDomainConnections = 1;
4879
4880 /* hostname lookups can be very expensive and are broken on
4881 a large number of sites (tridge) */
4882 Globals.bHostnameLookups = false;
4883
4884 string_set(&Globals.szPassdbBackend, "tdbsam");
4885 string_set(&Globals.szLdapSuffix, "");
4886 string_set(&Globals.szLdapMachineSuffix, "");
4887 string_set(&Globals.szLdapUserSuffix, "");
4888 string_set(&Globals.szLdapGroupSuffix, "");
4889 string_set(&Globals.szLdapIdmapSuffix, "");
4890
4891 string_set(&Globals.szLdapAdminDn, "");
4892 Globals.ldap_ssl = LDAP_SSL_START_TLS;
4893 Globals.ldap_ssl_ads = false;
4894 Globals.ldap_deref = -1;
4895 Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
4896 Globals.ldap_delete_dn = false;
4897 Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
4898 Globals.ldap_follow_referral = Auto;
4899 Globals.ldap_timeout = LDAP_DEFAULT_TIMEOUT;
4900 Globals.ldap_connection_timeout = LDAP_CONNECTION_DEFAULT_TIMEOUT;
4901 Globals.ldap_page_size = LDAP_PAGE_SIZE;
4902
4903 Globals.ldap_debug_level = 0;
4904 Globals.ldap_debug_threshold = 10;
4905
4906 /* This is what we tell the afs client. in reality we set the token
4907 * to never expire, though, when this runs out the afs client will
4908 * forget the token. Set to 0 to get NEVERDATE.*/
4909 Globals.iAfsTokenLifetime = 604800;
4910 Globals.cups_connection_timeout = CUPS_DEFAULT_CONNECTION_TIMEOUT;
4911
4912 /* these parameters are set to defaults that are more appropriate
4913 for the increasing samba install base:
4914
4915 as a member of the workgroup, that will possibly become a
4916 _local_ master browser (lm = true). this is opposed to a forced
4917 local master browser startup (pm = true).
4918
4919 doesn't provide WINS server service by default (wsupp = false),
4920 and doesn't provide domain master browser services by default, either.
4921
4922 */
4923
4924 Globals.bMsAddPrinterWizard = true;
4925 Globals.os_level = 20;
4926 Globals.bLocalMaster = true;
4927 Globals.iDomainMaster = Auto; /* depending on bDomainLogons */
4928 Globals.bDomainLogons = false;
4929 Globals.bBrowseList = true;
4930 Globals.bWINSsupport = false;
4931 Globals.bWINSproxy = false;
4932
4933 TALLOC_FREE(Globals.szInitLogonDelayedHosts);
4934 Globals.InitLogonDelay = 100; /* 100 ms default delay */
4935
4936 Globals.bDNSproxy = true;
4937
4938 /* this just means to use them if they exist */
4939 Globals.bKernelOplocks = true;
4940
4941 Globals.bAllowTrustedDomains = true;
4942 string_set(&Globals.szIdmapBackend, "tdb");
4943
4944 string_set(&Globals.szTemplateShell, "/bin/false");
4945 string_set(&Globals.szTemplateHomedir, "/home/%D/%U");
4946 string_set(&Globals.szWinbindSeparator, "\\");
4947
4948 string_set(&Globals.szCupsServer, "");
4949 string_set(&Globals.szIPrintServer, "");
4950
4951 string_set(&Globals.ctdbdSocket, "");
4952 Globals.szClusterAddresses = NULL;
4953 Globals.clustering = false;
4954 Globals.ctdb_timeout = 0;
4955 Globals.ctdb_locktime_warn_threshold = 0;
4956
4957 Globals.winbind_cache_time = 300; /* 5 minutes */
4958 Globals.winbind_reconnect_delay = 30; /* 30 seconds */
4959 Globals.winbind_max_clients = 200;
4960 Globals.bWinbindEnumUsers = false;
4961 Globals.bWinbindEnumGroups = false;
4962 Globals.bWinbindUseDefaultDomain = false;
4963 Globals.bWinbindTrustedDomainsOnly = false;
4964 Globals.bWinbindNestedGroups = true;
4965 Globals.winbind_expand_groups = 1;
4966 Globals.szWinbindNssInfo = (const char **)str_list_make_v3(NULL, "template", NULL);
4967 Globals.bWinbindRefreshTickets = false;
4968 Globals.bWinbindOfflineLogon = false;
4969
4970 Globals.iIdmapCacheTime = 86400 * 7; /* a week by default */
4971 Globals.iIdmapNegativeCacheTime = 120; /* 2 minutes by default */
4972
4973 Globals.bPassdbExpandExplicit = false;
4974
4975 Globals.name_cache_timeout = 660; /* In seconds */
4976
4977 Globals.bUseSpnego = true;
4978 Globals.bClientUseSpnego = true;
4979
4980 Globals.client_signing = Auto;
4981 Globals.server_signing = false;
4982
4983 Globals.bDeferSharingViolations = true;
4984 string_set(&Globals.smb_ports, SMB_PORTS);
4985
4986 Globals.bEnablePrivileges = true;
4987 Globals.bHostMSDfs = true;
4988 Globals.bASUSupport = false;
4989
4990 /* User defined shares. */
4991 if (asprintf(&s, "%s/usershares", get_dyn_STATEDIR()) < 0) {
4992 smb_panic("init_globals: ENOMEM");
4993 }
4994 string_set(&Globals.szUsersharePath, s);
4995 SAFE_FREE(s);
4996 string_set(&Globals.szUsershareTemplateShare, "");
4997 Globals.iUsershareMaxShares = 0;
4998 /* By default disallow sharing of directories not owned by the sharer. */
4999 Globals.bUsershareOwnerOnly = true;
5000 /* By default disallow guest access to usershares. */
5001 Globals.bUsershareAllowGuests = false;
5002
5003 Globals.iKeepalive = DEFAULT_KEEPALIVE;
5004
5005 /* By default no shares out of the registry */
5006 Globals.bRegistryShares = false;
5007
5008 Globals.iminreceivefile = 0;
5009
5010 Globals.bMapUntrustedToDomain = false;
5011 Globals.bMulticastDnsRegister = true;
5012
5013 Globals.ismb2_max_read = DEFAULT_SMB2_MAX_READ;
5014 Globals.ismb2_max_write = DEFAULT_SMB2_MAX_WRITE;
5015 Globals.ismb2_max_trans = DEFAULT_SMB2_MAX_TRANSACT;
5016 Globals.ismb2_max_credits = DEFAULT_SMB2_MAX_CREDITS;
5017
5018 string_set(&Globals.ncalrpc_dir, get_dyn_NCALRPCDIR());
5019
5020 /* Now put back the settings that were set with lp_set_cmdline() */
5021 apply_lp_set_cmdline();
5022 }
5023
5024 /*******************************************************************
5025 Convenience routine to grab string parameters into temporary memory
5026 and run standard_sub_basic on them. The buffers can be written to by
5027 callers without affecting the source string.
5028 ********************************************************************/
5029
5030 static char *lp_string(const char *s)
5031 {
5032 char *ret;
5033 TALLOC_CTX *ctx = talloc_tos();
5034
5035 /* The follow debug is useful for tracking down memory problems
5036 especially if you have an inner loop that is calling a lp_*()
5037 function that returns a string. Perhaps this debug should be
5038 present all the time? */
5039
5040 #if 0
5041 DEBUG(10, ("lp_string(%s)\n", s));
5042 #endif
5043 if (!s) {
5044 return NULL;
5045 }
5046
5047 ret = talloc_sub_basic(ctx,
5048 get_current_username(),
5049 current_user_info.domain,
5050 s);
5051 if (trim_char(ret, '\"', '\"')) {
5052 if (strchr(ret,'\"') != NULL) {
5053 TALLOC_FREE(ret);
5054 ret = talloc_sub_basic(ctx,
5055 get_current_username(),
5056 current_user_info.domain,
5057 s);
5058 }
5059 }
5060 return ret;
5061 }
5062
5063 /*
5064 In this section all the functions that are used to access the
5065 parameters from the rest of the program are defined
5066 */
5067
5068 #define FN_GLOBAL_STRING(fn_name,ptr) \
5069 char *fn_name(void) {return(lp_string(*(char **)(&Globals.ptr) ? *(char **)(&Globals.ptr) : ""));}
5070 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
5071 const char *fn_name(void) {return(*(const char **)(&Globals.ptr) ? *(const char **)(&Globals.ptr) : "");}
5072 #define FN_GLOBAL_LIST(fn_name,ptr) \
5073 const char **fn_name(void) {return(*(const char ***)(&Globals.ptr));}
5074 #define FN_GLOBAL_BOOL(fn_name,ptr) \
5075 bool fn_name(void) {return(*(bool *)(&Globals.ptr));}
5076 #define FN_GLOBAL_CHAR(fn_name,ptr) \
5077 char fn_name(void) {return(*(char *)(&Globals.ptr));}
5078 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
5079 int fn_name(void) {return(*(int *)(&Globals.ptr));}
5080
5081 #define FN_LOCAL_STRING(fn_name,val) \
5082 char *lp_ ## fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
5083 #define FN_LOCAL_CONST_STRING(fn_name,val) \
5084 const char *lp_ ## fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
5085 #define FN_LOCAL_LIST(fn_name,val) \
5086 const char **lp_ ## fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
5087 #define FN_LOCAL_BOOL(fn_name,val) \
5088 bool lp_ ## fn_name(int i) {return(bool)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
5089 #define FN_LOCAL_INTEGER(fn_name,val) \
5090 int lp_ ## fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
5091
5092 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
5093 bool lp_ ## fn_name(const struct share_params *p) {return(bool)(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
5094 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
5095 int lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
5096 #define FN_LOCAL_CHAR(fn_name,val) \
5097 char lp_ ## fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
5098
5099 FN_GLOBAL_CONST_STRING(lp_smb_ports, smb_ports)
5100 FN_GLOBAL_CONST_STRING(lp_dos_charset, dos_charset)
5101 FN_GLOBAL_CONST_STRING(lp_unix_charset, unix_charset)
5102 FN_GLOBAL_STRING(lp_logfile, szLogFile)
5103 FN_GLOBAL_STRING(lp_configfile, szConfigFile)
5104 FN_GLOBAL_CONST_STRING(lp_smb_passwd_file, szSMBPasswdFile)
5105 FN_GLOBAL_CONST_STRING(lp_private_dir, szPrivateDir)
5106 FN_GLOBAL_STRING(lp_serverstring, szServerString)
5107 FN_GLOBAL_INTEGER(lp_printcap_cache_time, PrintcapCacheTime)
5108 FN_GLOBAL_STRING(lp_addport_cmd, szAddPortCommand)
5109 FN_GLOBAL_STRING(lp_enumports_cmd, szEnumPortsCommand)
5110 FN_GLOBAL_STRING(lp_addprinter_cmd, szAddPrinterCommand)
5111 FN_GLOBAL_STRING(lp_deleteprinter_cmd, szDeletePrinterCommand)
5112 FN_GLOBAL_STRING(lp_os2_driver_map, szOs2DriverMap)
5113 FN_GLOBAL_CONST_STRING(lp_lockdir, szLockDir)
5114 /* If lp_statedir() and lp_cachedir() are explicitely set during the
5115 * build process or in smb.conf, we use that value. Otherwise they
5116 * default to the value of lp_lockdir(). */
5117 const char *lp_statedir(void) {
5118 if ((strcmp(get_dyn_STATEDIR(), get_dyn_LOCKDIR()) != 0) ||
5119 (strcmp(get_dyn_STATEDIR(), Globals.szStateDir) != 0))
5120 return(*(char **)(&Globals.szStateDir) ?
5121 *(char **)(&Globals.szStateDir) : "");
5122 else
5123 return(*(char **)(&Globals.szLockDir) ?
5124 *(char **)(&Globals.szLockDir) : "");
5125 }
5126 const char *lp_cachedir(void) {
5127 if ((strcmp(get_dyn_CACHEDIR(), get_dyn_LOCKDIR()) != 0) ||
5128 (strcmp(get_dyn_CACHEDIR(), Globals.szCacheDir) != 0))
5129 return(*(char **)(&Globals.szCacheDir) ?
5130 *(char **)(&Globals.szCacheDir) : "");
5131 else
5132 return(*(char **)(&Globals.szLockDir) ?
5133 *(char **)(&Globals.szLockDir) : "");
5134 }
5135 FN_GLOBAL_CONST_STRING(lp_piddir, szPidDir)
5136 FN_GLOBAL_STRING(lp_mangling_method, szManglingMethod)
5137 FN_GLOBAL_INTEGER(lp_mangle_prefix, mangle_prefix)
5138 FN_GLOBAL_CONST_STRING(lp_utmpdir, szUtmpDir)
5139 FN_GLOBAL_CONST_STRING(lp_wtmpdir, szWtmpDir)
5140 FN_GLOBAL_BOOL(lp_utmp, bUtmp)
5141 FN_GLOBAL_STRING(lp_rootdir, szRootdir)
5142 FN_GLOBAL_STRING(lp_perfcount_module, szSMBPerfcountModule)
5143 FN_GLOBAL_STRING(lp_defaultservice, szDefaultService)
5144 FN_GLOBAL_STRING(lp_msg_command, szMsgCommand)
5145 FN_GLOBAL_STRING(lp_get_quota_command, szGetQuota)
5146 FN_GLOBAL_STRING(lp_set_quota_command, szSetQuota)
5147 FN_GLOBAL_STRING(lp_auto_services, szAutoServices)
5148 FN_GLOBAL_STRING(lp_passwd_program, szPasswdProgram)
5149 FN_GLOBAL_STRING(lp_passwd_chat, szPasswdChat)
5150 FN_GLOBAL_CONST_STRING(lp_passwordserver, szPasswordServer)
5151 FN_GLOBAL_CONST_STRING(lp_name_resolve_order, szNameResolveOrder)
5152 FN_GLOBAL_CONST_STRING(lp_workgroup, szWorkgroup)
5153 FN_GLOBAL_CONST_STRING(lp_netbios_name, szNetbiosName)
5154 FN_GLOBAL_CONST_STRING(lp_netbios_scope, szNetbiosScope)
5155 FN_GLOBAL_CONST_STRING(lp_realm, szRealmUpper)
5156 FN_GLOBAL_CONST_STRING(lp_dnsdomain, szDnsDomain)
5157 FN_GLOBAL_CONST_STRING(lp_afs_username_map, szAfsUsernameMap)
5158 FN_GLOBAL_INTEGER(lp_afs_token_lifetime, iAfsTokenLifetime)
5159 FN_GLOBAL_STRING(lp_log_nt_token_command, szLogNtTokenCommand)
5160 FN_GLOBAL_STRING(lp_username_map, szUsernameMap)
5161 FN_GLOBAL_CONST_STRING(lp_logon_script, szLogonScript)
5162 FN_GLOBAL_CONST_STRING(lp_logon_path, szLogonPath)
5163 FN_GLOBAL_CONST_STRING(lp_logon_drive, szLogonDrive)
5164 FN_GLOBAL_CONST_STRING(lp_logon_home, szLogonHome)
5165 FN_GLOBAL_STRING(lp_remote_announce, szRemoteAnnounce)
5166 FN_GLOBAL_STRING(lp_remote_browse_sync, szRemoteBrowseSync)
5167 FN_GLOBAL_BOOL(lp_nmbd_bind_explicit_broadcast, bNmbdBindExplicitBroadcast)
5168 FN_GLOBAL_LIST(lp_wins_server_list, szWINSservers)
5169 FN_GLOBAL_LIST(lp_interfaces, szInterfaces)
5170 FN_GLOBAL_STRING(lp_nis_home_map_name, szNISHomeMapName)
5171 FN_GLOBAL_LIST(lp_netbios_aliases, szNetbiosAliases)
5172 FN_GLOBAL_CONST_STRING(lp_passdb_backend, szPassdbBackend)
5173 FN_GLOBAL_LIST(lp_preload_modules, szPreloadModules)
5174 FN_GLOBAL_STRING(lp_panic_action, szPanicAction)
5175 FN_GLOBAL_STRING(lp_adduser_script, szAddUserScript)
5176 FN_GLOBAL_STRING(lp_renameuser_script, szRenameUserScript)
5177 FN_GLOBAL_STRING(lp_deluser_script, szDelUserScript)
5178
5179 FN_GLOBAL_CONST_STRING(lp_guestaccount, szGuestaccount)
5180 FN_GLOBAL_STRING(lp_addgroup_script, szAddGroupScript)
5181 FN_GLOBAL_STRING(lp_delgroup_script, szDelGroupScript)
5182 FN_GLOBAL_STRING(lp_addusertogroup_script, szAddUserToGroupScript)
5183 FN_GLOBAL_STRING(lp_deluserfromgroup_script, szDelUserFromGroupScript)
5184 FN_GLOBAL_STRING(lp_setprimarygroup_script, szSetPrimaryGroupScript)
5185
5186 FN_GLOBAL_STRING(lp_addmachine_script, szAddMachineScript)
5187
5188 FN_GLOBAL_STRING(lp_shutdown_script, szShutdownScript)
5189 FN_GLOBAL_STRING(lp_abort_shutdown_script, szAbortShutdownScript)
5190 FN_GLOBAL_STRING(lp_username_map_script, szUsernameMapScript)
5191 FN_GLOBAL_INTEGER(lp_username_map_cache_time, iUsernameMapCacheTime)
5192
5193 FN_GLOBAL_STRING(lp_check_password_script, szCheckPasswordScript)
5194
5195 FN_GLOBAL_STRING(lp_wins_hook, szWINSHook)
5196 FN_GLOBAL_CONST_STRING(lp_template_homedir, szTemplateHomedir)
5197 FN_GLOBAL_CONST_STRING(lp_template_shell, szTemplateShell)
5198 FN_GLOBAL_CONST_STRING(lp_winbind_separator, szWinbindSeparator)
5199 FN_GLOBAL_INTEGER(lp_acl_compatibility, iAclCompat)
5200 FN_GLOBAL_BOOL(lp_winbind_enum_users, bWinbindEnumUsers)
5201 FN_GLOBAL_BOOL(lp_winbind_enum_groups, bWinbindEnumGroups)
5202 FN_GLOBAL_BOOL(lp_winbind_use_default_domain, bWinbindUseDefaultDomain)
5203 FN_GLOBAL_BOOL(lp_winbind_trusted_domains_only, bWinbindTrustedDomainsOnly)
5204 FN_GLOBAL_BOOL(lp_winbind_nested_groups, bWinbindNestedGroups)
5205 FN_GLOBAL_INTEGER(lp_winbind_expand_groups, winbind_expand_groups)
5206 FN_GLOBAL_BOOL(lp_winbind_refresh_tickets, bWinbindRefreshTickets)
5207 FN_GLOBAL_BOOL(lp_winbind_offline_logon, bWinbindOfflineLogon)
5208 FN_GLOBAL_BOOL(lp_winbind_normalize_names, bWinbindNormalizeNames)
5209 FN_GLOBAL_BOOL(lp_winbind_rpc_only, bWinbindRpcOnly)
5210 FN_GLOBAL_BOOL(lp_create_krb5_conf, bCreateKrb5Conf)
5211 static FN_GLOBAL_INTEGER(lp_winbind_max_domain_connections_int,
5212 winbindMaxDomainConnections)
5213
5214 int lp_winbind_max_domain_connections(void)
5215 {
5216 if (lp_winbind_offline_logon() &&
5217 lp_winbind_max_domain_connections_int() > 1) {
5218 DEBUG(1, ("offline logons active, restricting max domain "
5219 "connections to 1\n"));
5220 return 1;
5221 }
5222 return MAX(1, lp_winbind_max_domain_connections_int());
5223 }
5224
5225 FN_GLOBAL_CONST_STRING(lp_idmap_backend, szIdmapBackend)
5226 FN_GLOBAL_INTEGER(lp_idmap_cache_time, iIdmapCacheTime)
5227 FN_GLOBAL_INTEGER(lp_idmap_negative_cache_time, iIdmapNegativeCacheTime)
5228 FN_GLOBAL_INTEGER(lp_keepalive, iKeepalive)
5229 FN_GLOBAL_BOOL(lp_passdb_expand_explicit, bPassdbExpandExplicit)
5230
5231 FN_GLOBAL_STRING(lp_ldap_suffix, szLdapSuffix)
5232 FN_GLOBAL_STRING(lp_ldap_admin_dn, szLdapAdminDn)
5233 FN_GLOBAL_INTEGER(lp_ldap_ssl, ldap_ssl)
5234 FN_GLOBAL_BOOL(lp_ldap_ssl_ads, ldap_ssl_ads)
5235 FN_GLOBAL_INTEGER(lp_ldap_deref, ldap_deref)
5236 FN_GLOBAL_INTEGER(lp_ldap_follow_referral, ldap_follow_referral)
5237 FN_GLOBAL_INTEGER(lp_ldap_passwd_sync, ldap_passwd_sync)
5238 FN_GLOBAL_BOOL(lp_ldap_delete_dn, ldap_delete_dn)
5239 FN_GLOBAL_INTEGER(lp_ldap_replication_sleep, ldap_replication_sleep)
5240 FN_GLOBAL_INTEGER(lp_ldap_timeout, ldap_timeout)
5241 FN_GLOBAL_INTEGER(lp_ldap_connection_timeout, ldap_connection_timeout)
5242 FN_GLOBAL_INTEGER(lp_ldap_page_size, ldap_page_size)
5243 FN_GLOBAL_INTEGER(lp_ldap_debug_level, ldap_debug_level)
5244 FN_GLOBAL_INTEGER(lp_ldap_debug_threshold, ldap_debug_threshold)
5245 FN_GLOBAL_STRING(lp_add_share_cmd, szAddShareCommand)
5246 FN_GLOBAL_STRING(lp_change_share_cmd, szChangeShareCommand)
5247 FN_GLOBAL_STRING(lp_delete_share_cmd, szDeleteShareCommand)
5248 FN_GLOBAL_STRING(lp_usershare_path, szUsersharePath)
5249 FN_GLOBAL_LIST(lp_usershare_prefix_allow_list, szUsersharePrefixAllowList)
5250 FN_GLOBAL_LIST(lp_usershare_prefix_deny_list, szUsersharePrefixDenyList)
5251
5252 FN_GLOBAL_LIST(lp_eventlog_list, szEventLogs)
5253
5254 FN_GLOBAL_BOOL(lp_registry_shares, bRegistryShares)
5255 FN_GLOBAL_BOOL(lp_usershare_allow_guests, bUsershareAllowGuests)
5256 FN_GLOBAL_BOOL(lp_usershare_owner_only, bUsershareOwnerOnly)
5257 FN_GLOBAL_BOOL(lp_disable_netbios, bDisableNetbios)
5258 FN_GLOBAL_BOOL(lp_reset_on_zero_vc, bResetOnZeroVC)
5259 FN_GLOBAL_BOOL(lp_log_writeable_files_on_exit, bLogWriteableFilesOnExit)
5260 FN_GLOBAL_BOOL(lp_ms_add_printer_wizard, bMsAddPrinterWizard)
5261 FN_GLOBAL_BOOL(lp_dns_proxy, bDNSproxy)
5262 FN_GLOBAL_BOOL(lp_we_are_a_wins_server, bWINSsupport)
5263 FN_GLOBAL_BOOL(lp_wins_proxy, bWINSproxy)
5264 FN_GLOBAL_BOOL(lp_local_master, bLocalMaster)
5265 FN_GLOBAL_BOOL(lp_domain_logons, bDomainLogons)
5266 FN_GLOBAL_LIST(lp_init_logon_delayed_hosts, szInitLogonDelayedHosts)
5267 FN_GLOBAL_INTEGER(lp_init_logon_delay, InitLogonDelay)
5268 FN_GLOBAL_BOOL(lp_load_printers, bLoadPrinters)
5269 FN_GLOBAL_BOOL(_lp_readraw, bReadRaw)
5270 FN_GLOBAL_BOOL(lp_large_readwrite, bLargeReadwrite)
5271 FN_GLOBAL_BOOL(_lp_writeraw, bWriteRaw)
5272 FN_GLOBAL_BOOL(lp_null_passwords, bNullPasswords)
5273 FN_GLOBAL_BOOL(lp_obey_pam_restrictions, bObeyPamRestrictions)
5274 FN_GLOBAL_BOOL(lp_encrypted_passwords, bEncryptPasswords)
5275 FN_GLOBAL_INTEGER(lp_client_schannel, clientSchannel)
5276 FN_GLOBAL_INTEGER(lp_server_schannel, serverSchannel)
5277 FN_GLOBAL_BOOL(lp_syslog_only, bSyslogOnly)
5278 FN_GLOBAL_BOOL(lp_timestamp_logs, bTimestampLogs)
5279 FN_GLOBAL_BOOL(lp_debug_prefix_timestamp, bDebugPrefixTimestamp)
5280 FN_GLOBAL_BOOL(lp_debug_hires_timestamp, bDebugHiresTimestamp)
5281 FN_GLOBAL_BOOL(lp_debug_pid, bDebugPid)
5282 FN_GLOBAL_BOOL(lp_debug_uid, bDebugUid)
5283 FN_GLOBAL_BOOL(lp_debug_class, bDebugClass)
5284 FN_GLOBAL_BOOL(lp_enable_core_files, bEnableCoreFiles)
5285 FN_GLOBAL_BOOL(lp_browse_list, bBrowseList)
5286 FN_GLOBAL_BOOL(lp_nis_home_map, bNISHomeMap)
5287 static FN_GLOBAL_BOOL(lp_time_server, bTimeServer)
5288 FN_GLOBAL_BOOL(lp_bind_interfaces_only, bBindInterfacesOnly)
5289 FN_GLOBAL_BOOL(lp_pam_password_change, bPamPasswordChange)
5290 FN_GLOBAL_BOOL(lp_unix_password_sync, bUnixPasswdSync)
5291 FN_GLOBAL_BOOL(lp_passwd_chat_debug, bPasswdChatDebug)
5292 FN_GLOBAL_INTEGER(lp_passwd_chat_timeout, iPasswdChatTimeout)
5293 FN_GLOBAL_BOOL(lp_nt_pipe_support, bNTPipeSupport)
5294 FN_GLOBAL_BOOL(lp_nt_status_support, bNTStatusSupport)
5295 FN_GLOBAL_BOOL(lp_stat_cache, bStatCache)
5296 FN_GLOBAL_INTEGER(lp_max_stat_cache_size, iMaxStatCacheSize)
5297 FN_GLOBAL_BOOL(lp_allow_trusted_domains, bAllowTrustedDomains)
5298 FN_GLOBAL_BOOL(lp_map_untrusted_to_domain, bMapUntrustedToDomain)
5299 FN_GLOBAL_INTEGER(lp_restrict_anonymous, restrict_anonymous)
5300 FN_GLOBAL_BOOL(lp_lanman_auth, bLanmanAuth)
5301 FN_GLOBAL_BOOL(lp_ntlm_auth, bNTLMAuth)
5302 FN_GLOBAL_BOOL(lp_client_plaintext_auth, bClientPlaintextAuth)
5303 FN_GLOBAL_BOOL(lp_client_lanman_auth, bClientLanManAuth)
5304 FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, bClientNTLMv2Auth)
5305 FN_GLOBAL_BOOL(lp_host_msdfs, bHostMSDfs)
5306 FN_GLOBAL_BOOL(lp_kernel_oplocks, bKernelOplocks)
5307 FN_GLOBAL_BOOL(lp_enhanced_browsing, enhanced_browsing)
5308 FN_GLOBAL_BOOL(lp_use_mmap, bUseMmap)
5309 FN_GLOBAL_BOOL(lp_unix_extensions, bUnixExtensions)
5310 FN_GLOBAL_BOOL(lp_use_spnego, bUseSpnego)
5311 FN_GLOBAL_BOOL(lp_client_use_spnego, bClientUseSpnego)
5312 FN_GLOBAL_BOOL(lp_client_use_spnego_principal, client_use_spnego_principal)
5313 FN_GLOBAL_BOOL(lp_send_spnego_principal, send_spnego_principal)
5314 FN_GLOBAL_BOOL(lp_hostname_lookups, bHostnameLookups)
5315 FN_GLOBAL_CONST_STRING(lp_dedicated_keytab_file, szDedicatedKeytabFile)
5316 FN_GLOBAL_INTEGER(lp_kerberos_method, iKerberosMethod)
5317 FN_GLOBAL_BOOL(lp_defer_sharing_violations, bDeferSharingViolations)
5318 FN_GLOBAL_BOOL(lp_enable_privileges, bEnablePrivileges)
5319 FN_GLOBAL_BOOL(lp_enable_asu_support, bASUSupport)
5320 FN_GLOBAL_INTEGER(lp_os_level, os_level)
5321 FN_GLOBAL_INTEGER(lp_max_ttl, max_ttl)
5322 FN_GLOBAL_INTEGER(lp_max_wins_ttl, max_wins_ttl)
5323 FN_GLOBAL_INTEGER(lp_min_wins_ttl, min_wins_ttl)
5324 FN_GLOBAL_INTEGER(lp_max_log_size, max_log_size)
5325 FN_GLOBAL_INTEGER(lp_max_open_files, max_open_files)
5326 FN_GLOBAL_INTEGER(lp_open_files_db_hash_size, open_files_db_hash_size)
5327 FN_GLOBAL_INTEGER(lp_maxxmit, max_xmit)
5328 FN_GLOBAL_INTEGER(lp_maxmux, max_mux)
5329 FN_GLOBAL_INTEGER(lp_passwordlevel, pwordlevel)
5330 FN_GLOBAL_INTEGER(lp_usernamelevel, unamelevel)
5331 FN_GLOBAL_INTEGER(lp_deadtime, deadtime)
5332 FN_GLOBAL_BOOL(lp_getwd_cache, getwd_cache)
5333 static FN_GLOBAL_INTEGER(_lp_maxprotocol, maxprotocol)
5334 int lp_maxprotocol(void)
5335 {
5336 int ret = _lp_maxprotocol();
5337 if ((ret >= PROTOCOL_SMB2_02) && (lp_security() == SEC_SHARE)) {
5338 DEBUG(2,("WARNING!!: \"security = share\" is incompatible "
5339 "with the SMB2 protocol. Resetting to SMB1.\n" ));
5340 lp_do_parameter(-1, "max protocol", "NT1");
5341 return PROTOCOL_NT1;
5342 }
5343 return ret;
5344 }
5345 FN_GLOBAL_INTEGER(lp_minprotocol, minprotocol)
5346 FN_GLOBAL_INTEGER(lp_security, security)
5347 FN_GLOBAL_LIST(lp_auth_methods, AuthMethods)
5348 FN_GLOBAL_BOOL(lp_paranoid_server_security, paranoid_server_security)
5349 FN_GLOBAL_INTEGER(lp_maxdisksize, maxdisksize)
5350 FN_GLOBAL_INTEGER(lp_lpqcachetime, lpqcachetime)
5351 FN_GLOBAL_INTEGER(lp_max_smbd_processes, iMaxSmbdProcesses)
5352 FN_GLOBAL_BOOL(_lp_disable_spoolss, bDisableSpoolss)
5353 FN_GLOBAL_INTEGER(lp_syslog, syslog)
5354 FN_GLOBAL_INTEGER(lp_lm_announce, lm_announce)
5355 FN_GLOBAL_INTEGER(lp_lm_interval, lm_interval)
5356 FN_GLOBAL_INTEGER(lp_machine_password_timeout, machine_password_timeout)
5357 FN_GLOBAL_INTEGER(lp_map_to_guest, map_to_guest)
5358 FN_GLOBAL_INTEGER(lp_oplock_break_wait_time, oplock_break_wait_time)
5359 FN_GLOBAL_INTEGER(lp_lock_spin_time, iLockSpinTime)
5360 FN_GLOBAL_INTEGER(lp_usershare_max_shares, iUsershareMaxShares)
5361 FN_GLOBAL_CONST_STRING(lp_socket_options, szSocketOptions)
5362 FN_GLOBAL_INTEGER(lp_config_backend, ConfigBackend)
5363 FN_GLOBAL_INTEGER(lp_smb2_max_read, ismb2_max_read)
5364 FN_GLOBAL_INTEGER(lp_smb2_max_write, ismb2_max_write)
5365 FN_GLOBAL_INTEGER(lp_smb2_max_trans, ismb2_max_trans)
5366 int lp_smb2_max_credits(void)
5367 {
5368 if (Globals.ismb2_max_credits == 0) {
5369 Globals.ismb2_max_credits = DEFAULT_SMB2_MAX_CREDITS;
5370 }
5371 return Globals.ismb2_max_credits;
5372 }
5373 FN_GLOBAL_LIST(lp_svcctl_list, szServicesList)
5374 FN_GLOBAL_STRING(lp_cups_server, szCupsServer)
5375 int lp_cups_encrypt(void)
5376 {
5377 int result = 0;
5378 #ifdef HAVE_HTTPCONNECTENCRYPT
5379 switch (Globals.CupsEncrypt) {
5380 case Auto:
5381 result = HTTP_ENCRYPT_REQUIRED;
5382 break;
5383 case true:
5384 result = HTTP_ENCRYPT_ALWAYS;
5385 break;
5386 case false:
5387 result = HTTP_ENCRYPT_NEVER;
5388 break;
5389 }
5390 #endif
5391 return result;
5392 }
5393 FN_GLOBAL_STRING(lp_iprint_server, szIPrintServer)
5394 FN_GLOBAL_INTEGER(lp_cups_connection_timeout, cups_connection_timeout)
5395 FN_GLOBAL_CONST_STRING(lp_ctdbd_socket, ctdbdSocket)
5396 FN_GLOBAL_LIST(lp_cluster_addresses, szClusterAddresses)
5397 FN_GLOBAL_BOOL(lp_clustering, clustering)
5398 FN_GLOBAL_INTEGER(lp_ctdb_timeout, ctdb_timeout)
5399 FN_GLOBAL_INTEGER(lp_ctdb_locktime_warn_threshold, ctdb_locktime_warn_threshold)
5400 FN_GLOBAL_BOOL(lp_async_smb_echo_handler, bAsyncSMBEchoHandler)
5401 FN_GLOBAL_BOOL(lp_multicast_dns_register, bMulticastDnsRegister)
5402 FN_GLOBAL_BOOL(lp_allow_insecure_widelinks, bAllowInsecureWidelinks)
5403 FN_GLOBAL_INTEGER(lp_winbind_cache_time, winbind_cache_time)
5404 FN_GLOBAL_INTEGER(lp_winbind_reconnect_delay, winbind_reconnect_delay)
5405 FN_GLOBAL_INTEGER(lp_winbind_max_clients, winbind_max_clients)
5406 FN_GLOBAL_LIST(lp_winbind_nss_info, szWinbindNssInfo)
5407 FN_GLOBAL_INTEGER(lp_algorithmic_rid_base, AlgorithmicRidBase)
5408 FN_GLOBAL_INTEGER(lp_name_cache_timeout, name_cache_timeout)
5409 FN_GLOBAL_INTEGER(lp_client_signing, client_signing)
5410 FN_GLOBAL_INTEGER(lp_server_signing, server_signing)
5411 FN_GLOBAL_INTEGER(lp_client_ldap_sasl_wrapping, client_ldap_sasl_wrapping)
5412
5413 FN_GLOBAL_CONST_STRING(lp_ncalrpc_dir, ncalrpc_dir)
5414
5415 #include "lib/param/param_functions.c"
5416
5417 FN_LOCAL_STRING(servicename, szService)
5418 FN_LOCAL_CONST_STRING(const_servicename, szService)
5419
5420 /* local prototypes */
5421
5422 static int map_parameter_canonical(const char *pszParmName, bool *inverse);
5423 static const char *get_boolean(bool bool_value);
5424 static int getservicebyname(const char *pszServiceName,
5425 struct loadparm_service *pserviceDest);
5426 static void copy_service(struct loadparm_service *pserviceDest,
5427 struct loadparm_service *pserviceSource,
5428 struct bitmap *pcopymapDest);
5429 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
5430 void *userdata);
5431 static bool do_section(const char *pszSectionName, void *userdata);
5432 static void init_copymap(struct loadparm_service *pservice);
5433 static bool hash_a_service(const char *name, int number);
5434 static void free_service_byindex(int iService);
5435 static void show_parameter(int parmIndex);
5436 static bool is_synonym_of(int parm1, int parm2, bool *inverse);
5437
5438 /*
5439 * This is a helper function for parametrical options support. It returns a
5440 * pointer to parametrical option value if it exists or NULL otherwise. Actual
5441 * parametrical functions are quite simple
5442 */
5443 static struct parmlist_entry *get_parametrics_by_service(struct loadparm_service *service, const char *type,
5444 const char *option)
5445 {
5446 bool global_section = false;
5447 char* param_key;
5448 struct parmlist_entry *data;
5449
5450 if (service == NULL) {
5451 data = Globals.param_opt;
5452 global_section = true;
5453 } else {
5454 data = service->param_opt;
5455 }
5456
5457 if (asprintf(&param_key, "%s:%s", type, option) == -1) {
5458 DEBUG(0,("asprintf failed!\n"));
5459 return NULL;
5460 }
5461
5462 while (data) {
5463 if (strwicmp(data->key, param_key) == 0) {
5464 string_free(&param_key);
5465 return data;
5466 }
5467 data = data->next;
5468 }
5469
5470 if (!global_section) {
5471 /* Try to fetch the same option but from globals */
5472 /* but only if we are not already working with Globals */
5473 data = Globals.param_opt;
5474 while (data) {
5475 if (strwicmp(data->key, param_key) == 0) {
5476 string_free(&param_key);
5477 return data;
5478 }
5479 data = data->next;
5480 }
5481 }
5482
5483 string_free(&param_key);
5484
5485 return NULL;
5486 }
5487
5488 /*
5489 * This is a helper function for parametrical options support. It returns a
5490 * pointer to parametrical option value if it exists or NULL otherwise. Actual
5491 * parametrical functions are quite simple
5492 */
5493 static struct parmlist_entry *get_parametrics(int snum, const char *type,
5494 const char *option)
5495 {
5496 if (snum >= iNumServices) return NULL;
5497
5498 if (snum < 0) {
5499 return get_parametrics_by_service(NULL, type, option);
5500 } else {
5501 return get_parametrics_by_service(ServicePtrs[snum], type, option);
5502 }
5503 }
5504
5505
5506 #define MISSING_PARAMETER(name) \
5507 DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
5508
5509 /*******************************************************************
5510 convenience routine to return int parameters.
5511 ********************************************************************/
5512 static int lp_int(const char *s)
5513 {
5514
5515 if (!s || !*s) {
5516 MISSING_PARAMETER(lp_int);
5517 return (-1);
5518 }
5519
5520 return (int)strtol(s, NULL, 0);
5521 }
5522
5523 /*******************************************************************
5524 convenience routine to return unsigned long parameters.
5525 ********************************************************************/
5526 static unsigned long lp_ulong(const char *s)
5527 {
5528
5529 if (!s || !*s) {
5530 MISSING_PARAMETER(lp_ulong);
5531 return (0);
5532 }
5533
5534 return strtoul(s, NULL, 0);
5535 }
5536
5537 /*******************************************************************
5538 convenience routine to return boolean parameters.
5539 ********************************************************************/
5540 static bool lp_bool(const char *s)
5541 {
5542 bool ret = false;
5543
5544 if (!s || !*s) {
5545 MISSING_PARAMETER(lp_bool);
5546 return false;
5547 }
5548
5549 if (!set_boolean(s, &ret)) {
5550 DEBUG(0,("lp_bool(%s): value is not boolean!\n",s));
5551 return false;
5552 }
5553
5554 return ret;
5555 }
5556
5557 /*******************************************************************
5558 convenience routine to return enum parameters.
5559 ********************************************************************/
5560 static int lp_enum(const char *s,const struct enum_list *_enum)
5561 {
5562 int i;
5563
5564 if (!s || !*s || !_enum) {
5565 MISSING_PARAMETER(lp_enum);
5566 return (-1);
5567 }
5568
5569 for (i=0; _enum[i].name; i++) {
5570 if (strequal(_enum[i].name,s))
5571 return _enum[i].value;
5572 }
5573
5574 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
5575 return (-1);
5576 }
5577
5578 #undef MISSING_PARAMETER
5579
5580 /* Return parametric option from a given service. Type is a part of option before ':' */
5581 /* Parametric option has following syntax: 'Type: option = value' */
5582 /* the returned value is talloced on the talloc_tos() */
5583 char *lp_parm_talloc_string(int snum, const char *type, const char *option, const char *def)
5584 {
5585 struct parmlist_entry *data = get_parametrics(snum, type, option);
5586
5587 if (data == NULL||data->value==NULL) {
5588 if (def) {
5589 return lp_string(def);
5590 } else {
5591 return NULL;
5592 }
5593 }
5594
5595 return lp_string(data->value);
5596 }
5597
5598 /* Return parametric option from a given service. Type is a part of option before ':' */
5599 /* Parametric option has following syntax: 'Type: option = value' */
5600 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
5601 {
5602 struct parmlist_entry *data = get_parametrics(snum, type, option);
5603
5604 if (data == NULL||data->value==NULL)
5605 return def;
5606
5607 return data->value;
5608 }
5609
5610 const char *lp_parm_const_string_service(struct loadparm_service *service, const char *type, const char *option)
5611 {
5612 struct parmlist_entry *data = get_parametrics_by_service(service, type, option);
5613
5614 if (data == NULL||data->value==NULL)
5615 return NULL;
5616
5617 return data->value;
5618 }
5619
5620
5621 /* Return parametric option from a given service. Type is a part of option before ':' */
5622 /* Parametric option has following syntax: 'Type: option = value' */
5623
5624 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
5625 {
5626 struct parmlist_entry *data = get_parametrics(snum, type, option);
5627
5628 if (data == NULL||data->value==NULL)
5629 return (const char **)def;
5630
5631 if (data->list==NULL) {
5632 data->list = str_list_make_v3(NULL, data->value, NULL);
5633 }
5634
5635 return (const char **)data->list;
5636 }
5637
5638 /* Return parametric option from a given service. Type is a part of option before ':' */
5639 /* Parametric option has following syntax: 'Type: option = value' */
5640
5641 int lp_parm_int(int snum, const char *type, const char *option, int def)
5642 {
5643 struct parmlist_entry *data = get_parametrics(snum, type, option);
5644
5645 if (data && data->value && *data->value)
5646 return lp_int(data->value);
5647
5648 return def;
5649 }
5650
5651 /* Return parametric option from a given service. Type is a part of option before ':' */
5652 /* Parametric option has following syntax: 'Type: option = value' */
5653
5654 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
5655 {
5656 struct parmlist_entry *data = get_parametrics(snum, type, option);
5657
5658 if (data && data->value && *data->value)
5659 return lp_ulong(data->value);
5660
5661 return def;
5662 }
5663
5664 /* Return parametric option from a given service. Type is a part of option before ':' */
5665 /* Parametric option has following syntax: 'Type: option = value' */
5666
5667 bool lp_parm_bool(int snum, const char *type, const char *option, bool def)
5668 {
5669 struct parmlist_entry *data = get_parametrics(snum, type, option);
5670
5671 if (data && data->value && *data->value)
5672 return lp_bool(data->value);
5673
5674 return def;
5675 }
5676
5677 /* Return parametric option from a given service. Type is a part of option before ':' */
5678 /* Parametric option has following syntax: 'Type: option = value' */
5679
5680 int lp_parm_enum(int snum, const char *type, const char *option,
5681 const struct enum_list *_enum, int def)
5682 {
5683 struct parmlist_entry *data = get_parametrics(snum, type, option);
5684
5685 if (data && data->value && *data->value && _enum)
5686 return lp_enum(data->value, _enum);
5687
5688 return def;
5689 }
5690
5691
5692 /***************************************************************************
5693 Initialise a service to the defaults.
5694 ***************************************************************************/
5695
5696 static void init_service(struct loadparm_service *pservice)
5697 {
5698 memset((char *)pservice, '\0', sizeof(struct loadparm_service));
5699 copy_service(pservice, &sDefault, NULL);
5700 }
5701
5702
5703 /**
5704 * free a param_opts structure.
5705 * param_opts handling should be moved to talloc;
5706 * then this whole functions reduces to a TALLOC_FREE().
5707 */
5708
5709 static void free_param_opts(struct parmlist_entry **popts)
5710 {
5711 struct parmlist_entry *opt, *next_opt;
5712
5713 if (popts == NULL) {
5714 return;
5715 }
5716
5717 if (*popts != NULL) {
5718 DEBUG(5, ("Freeing parametrics:\n"));
5719 }
5720 opt = *popts;
5721 while (opt != NULL) {
5722 string_free(&opt->key);
5723 string_free(&opt->value);
5724 TALLOC_FREE(opt->list);
5725 next_opt = opt->next;
5726 SAFE_FREE(opt);
5727 opt = next_opt;
5728 }
5729 *popts = NULL;
5730 }
5731
5732 /***************************************************************************
5733 Free the dynamically allocated parts of a service struct.
5734 ***************************************************************************/
5735
5736 static void free_service(struct loadparm_service *pservice)
5737 {
5738 if (!pservice)
5739 return;
5740
5741 if (pservice->szService)
5742 DEBUG(5, ("free_service: Freeing service %s\n",
5743 pservice->szService));
5744
5745 free_parameters(pservice);
5746
5747 string_free(&pservice->szService);
5748 TALLOC_FREE(pservice->copymap);
5749
5750 free_param_opts(&pservice->param_opt);
5751
5752 ZERO_STRUCTP(pservice);
5753 }
5754
5755
5756 /***************************************************************************
5757 remove a service indexed in the ServicePtrs array from the ServiceHash
5758 and free the dynamically allocated parts
5759 ***************************************************************************/
5760
5761 static void free_service_byindex(int idx)
5762 {
5763 if ( !LP_SNUM_OK(idx) )
5764 return;
5765
5766 ServicePtrs[idx]->valid = false;
5767 invalid_services[num_invalid_services++] = idx;
5768
5769 /* we have to cleanup the hash record */
5770
5771 if (ServicePtrs[idx]->szService) {
5772 char *canon_name = canonicalize_servicename(
5773 talloc_tos(),
5774 ServicePtrs[idx]->szService );
5775
5776 dbwrap_delete_bystring(ServiceHash, canon_name );
5777 TALLOC_FREE(canon_name);
5778 }
5779
5780 free_service(ServicePtrs[idx]);
5781 }
5782
5783 /***************************************************************************
5784 Add a new service to the services array initialising it with the given
5785 service.
5786 ***************************************************************************/
5787
5788 static int add_a_service(const struct loadparm_service *pservice, const char *name)
5789 {
5790 int i;
5791 struct loadparm_service tservice;
5792 int num_to_alloc = iNumServices + 1;
5793
5794 tservice = *pservice;
5795
5796 /* it might already exist */
5797 if (name) {
5798 i = getservicebyname(name, NULL);
5799 if (i >= 0) {
5800 return (i);
5801 }
5802 }
5803
5804 /* find an invalid one */
5805 i = iNumServices;
5806 if (num_invalid_services > 0) {
5807 i = invalid_services[--num_invalid_services];
5808 }
5809
5810 /* if not, then create one */
5811 if (i == iNumServices) {
5812 struct loadparm_service **tsp;
5813 int *tinvalid;
5814
5815 tsp = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(ServicePtrs, struct loadparm_service *, num_to_alloc);
5816 if (tsp == NULL) {
5817 DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
5818 return (-1);
5819 }
5820 ServicePtrs = tsp;
5821 ServicePtrs[iNumServices] = SMB_MALLOC_P(struct loadparm_service);
5822 if (!ServicePtrs[iNumServices]) {
5823 DEBUG(0,("add_a_service: out of memory!\n"));
5824 return (-1);
5825 }
5826 iNumServices++;
5827
5828 /* enlarge invalid_services here for now... */
5829 tinvalid = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(invalid_services, int,
5830 num_to_alloc);
5831 if (tinvalid == NULL) {
5832 DEBUG(0,("add_a_service: failed to enlarge "
5833 "invalid_services!\n"));
5834 return (-1);
5835 }
5836 invalid_services = tinvalid;
5837 } else {
5838 free_service_byindex(i);
5839 }
5840
5841 ServicePtrs[i]->valid = true;
5842
5843 init_service(ServicePtrs[i]);
5844 copy_service(ServicePtrs[i], &tservice, NULL);
5845 if (name)
5846 string_set(&ServicePtrs[i]->szService, name);
5847
5848 DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
5849 i, ServicePtrs[i]->szService));
5850
5851 if (!hash_a_service(ServicePtrs[i]->szService, i)) {
5852 return (-1);
5853 }
5854
5855 return (i);
5856 }
5857
5858 /***************************************************************************
5859 Convert a string to uppercase and remove whitespaces.
5860 ***************************************************************************/
5861
5862 char *canonicalize_servicename(TALLOC_CTX *ctx, const char *src)
5863 {
5864 char *result;
5865
5866 if ( !src ) {
5867 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
5868 return NULL;
5869 }
5870
5871 result = talloc_strdup(ctx, src);
5872 SMB_ASSERT(result != NULL);
5873
5874 strlower_m(result);
5875 return result;
5876 }
5877
5878 /***************************************************************************
5879 Add a name/index pair for the services array to the hash table.
5880 ***************************************************************************/
5881
5882 static bool hash_a_service(const char *name, int idx)
5883 {
5884 char *canon_name;
5885
5886 if ( !ServiceHash ) {
5887 DEBUG(10,("hash_a_service: creating servicehash\n"));
5888 ServiceHash = db_open_rbt(NULL);
5889 if ( !ServiceHash ) {
5890 DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
5891 return false;
5892 }
5893 }
5894
5895 DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
5896 idx, name));
5897
5898 canon_name = canonicalize_servicename(talloc_tos(), name );
5899
5900 dbwrap_store_bystring(ServiceHash, canon_name,
5901 make_tdb_data((uint8 *)&idx, sizeof(idx)),
5902 TDB_REPLACE);
5903
5904 TALLOC_FREE(canon_name);
5905
5906 return true;
5907 }
5908
5909 /***************************************************************************
5910 Add a new home service, with the specified home directory, defaults coming
5911 from service ifrom.
5912 ***************************************************************************/
5913
5914 bool lp_add_home(const char *pszHomename, int iDefaultService,
5915 const char *user, const char *pszHomedir)
5916 {
5917 int i;
5918
5919 if (pszHomename == NULL || user == NULL || pszHomedir == NULL ||
5920 pszHomedir[0] == '\0') {
5921 return false;
5922 }
5923
5924 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
5925
5926 if (i < 0)
5927 return (false);
5928
5929 if (!(*(ServicePtrs[iDefaultService]->szPath))
5930 || strequal(ServicePtrs[iDefaultService]->szPath, lp_pathname(GLOBAL_SECTION_SNUM))) {
5931 string_set(&ServicePtrs[i]->szPath, pszHomedir);
5932 }
5933
5934 if (!(*(ServicePtrs[i]->comment))) {
5935 char *comment = NULL;
5936 if (asprintf(&comment, "Home directory of %s", user) < 0) {
5937 return false;
5938 }
5939 string_set(&ServicePtrs[i]->comment, comment);
5940 SAFE_FREE(comment);
5941 }
5942
5943 /* set the browseable flag from the global default */
5944
5945 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
5946 ServicePtrs[i]->bAccessBasedShareEnum = sDefault.bAccessBasedShareEnum;
5947
5948 ServicePtrs[i]->autoloaded = true;
5949
5950 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
5951 user, ServicePtrs[i]->szPath ));
5952
5953 return (true);
5954 }
5955
5956 /***************************************************************************
5957 Add a new service, based on an old one.
5958 ***************************************************************************/
5959
5960 int lp_add_service(const char *pszService, int iDefaultService)
5961 {
5962 if (iDefaultService < 0) {
5963 return add_a_service(&sDefault, pszService);
5964 }
5965
5966 return (add_a_service(ServicePtrs[iDefaultService], pszService));
5967 }
5968
5969 /***************************************************************************
5970 Add the IPC service.
5971 ***************************************************************************/
5972
5973 static bool lp_add_ipc(const char *ipc_name, bool guest_ok)
5974 {
5975 char *comment = NULL;
5976 int i = add_a_service(&sDefault, ipc_name);
5977
5978 if (i < 0)
5979 return (false);
5980
5981 if (asprintf(&comment, "IPC Service (%s)",
5982 Globals.szServerString) < 0) {
5983 return (false);
5984 }
5985
5986 string_set(&ServicePtrs[i]->szPath, tmpdir());
5987 string_set(&ServicePtrs[i]->szUsername, "");
5988 string_set(&ServicePtrs[i]->comment, comment);
5989 string_set(&ServicePtrs[i]->fstype, "IPC");
5990 ServicePtrs[i]->iMaxConnections = 0;
5991 ServicePtrs[i]->bAvailable = true;
5992 ServicePtrs[i]->bRead_only = true;
5993 ServicePtrs[i]->bGuest_only = false;
5994 ServicePtrs[i]->bAdministrative_share = true;
5995 ServicePtrs[i]->bGuest_ok = guest_ok;
5996 ServicePtrs[i]->bPrint_ok = false;
5997 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
5998
5999 DEBUG(3, ("adding IPC service\n"));
6000
6001 SAFE_FREE(comment);
6002 return (true);
6003 }
6004
6005 /***************************************************************************
6006 Add a new printer service, with defaults coming from service iFrom.
6007 ***************************************************************************/
6008
6009 bool lp_add_printer(const char *pszPrintername, int iDefaultService)
6010 {
6011 const char *comment = "From Printcap";
6012 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
6013
6014 if (i < 0)
6015 return (false);
6016
6017 /* note that we do NOT default the availability flag to true - */
6018 /* we take it from the default service passed. This allows all */
6019 /* dynamic printers to be disabled by disabling the [printers] */
6020 /* entry (if/when the 'available' keyword is implemented!). */
6021
6022 /* the printer name is set to the service name. */
6023 string_set(&ServicePtrs[i]->szPrintername, pszPrintername);
6024 string_set(&ServicePtrs[i]->comment, comment);
6025
6026 /* set the browseable flag from the gloabl default */
6027 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
6028
6029 /* Printers cannot be read_only. */
6030 ServicePtrs[i]->bRead_only = false;
6031 /* No share modes on printer services. */
6032 ServicePtrs[i]->bShareModes = false;
6033 /* No oplocks on printer services. */
6034 ServicePtrs[i]->bOpLocks = false;
6035 /* Printer services must be printable. */
6036 ServicePtrs[i]->bPrint_ok = true;
6037
6038 DEBUG(3, ("adding printer service %s\n", pszPrintername));
6039
6040 return (true);
6041 }
6042
6043
6044 /***************************************************************************
6045 Check whether the given parameter name is valid.
6046 Parametric options (names containing a colon) are considered valid.
6047 ***************************************************************************/
6048
6049 bool lp_parameter_is_valid(const char *pszParmName)
6050 {
6051 return ((map_parameter(pszParmName) != -1) ||
6052 (strchr(pszParmName, ':') != NULL));
6053 }
6054
6055 /***************************************************************************
6056 Check whether the given name is the name of a global parameter.
6057 Returns true for strings belonging to parameters of class
6058 P_GLOBAL, false for all other strings, also for parametric options
6059 and strings not belonging to any option.
6060 ***************************************************************************/
6061
6062 bool lp_parameter_is_global(const char *pszParmName)
6063 {
6064 int num = map_parameter(pszParmName);
6065
6066 if (num >= 0) {
6067 return (parm_table[num].p_class == P_GLOBAL);
6068 }
6069
6070 return false;
6071 }
6072
6073 /**************************************************************************
6074 Check whether the given name is the canonical name of a parameter.
6075 Returns false if it is not a valid parameter Name.
6076 For parametric options, true is returned.
6077 **************************************************************************/
6078
6079 bool lp_parameter_is_canonical(const char *parm_name)
6080 {
6081 if (!lp_parameter_is_valid(parm_name)) {
6082 return false;
6083 }
6084
6085 return (map_parameter(parm_name) ==
6086 map_parameter_canonical(parm_name, NULL));
6087 }
6088
6089 /**************************************************************************
6090 Determine the canonical name for a parameter.
6091 Indicate when it is an inverse (boolean) synonym instead of a
6092 "usual" synonym.
6093 **************************************************************************/
6094
6095 bool lp_canonicalize_parameter(const char *parm_name, const char **canon_parm,
6096 bool *inverse)
6097 {
6098 int num;
6099
6100 if (!lp_parameter_is_valid(parm_name)) {
6101 *canon_parm = NULL;
6102 return false;
6103 }
6104
6105 num = map_parameter_canonical(parm_name, inverse);
6106 if (num < 0) {
6107 /* parametric option */
6108 *canon_parm = parm_name;
6109 } else {
6110 *canon_parm = parm_table[num].label;
6111 }
6112
6113 return true;
6114
6115 }
6116
6117 /**************************************************************************
6118 Determine the canonical name for a parameter.
6119 Turn the value given into the inverse boolean expression when
6120 the synonym is an invers boolean synonym.
6121
6122 Return true if parm_name is a valid parameter name and
6123 in case it is an invers boolean synonym, if the val string could
6124 successfully be converted to the reverse bool.
6125 Return false in all other cases.
6126 **************************************************************************/
6127
6128 bool lp_canonicalize_parameter_with_value(const char *parm_name,
6129 const char *val,
6130 const char **canon_parm,
6131 const char **canon_val)
6132 {
6133 int num;
6134 bool inverse;
6135
6136 if (!lp_parameter_is_valid(parm_name)) {
6137 *canon_parm = NULL;
6138 *canon_val = NULL;
6139 return false;
6140 }
6141
6142 num = map_parameter_canonical(parm_name, &inverse);
6143 if (num < 0) {
6144 /* parametric option */
6145 *canon_parm = parm_name;
6146 *canon_val = val;
6147 } else {
6148 *canon_parm = parm_table[num].label;
6149 if (inverse) {
6150 if (!lp_invert_boolean(val, canon_val)) {
6151 *canon_val = NULL;
6152 return false;
6153 }
6154 } else {
6155 *canon_val = val;
6156 }
6157 }
6158
6159 return true;
6160 }
6161
6162 /***************************************************************************
6163 Map a parameter's string representation to something we can use.
6164 Returns false if the parameter string is not recognised, else TRUE.
6165 ***************************************************************************/
6166
6167 static int map_parameter(const char *pszParmName)
6168 {
6169 int iIndex;
6170
6171 if (*pszParmName == '-' && !strequal(pszParmName, "-valid"))
6172 return (-1);
6173
6174 for (iIndex = 0; parm_table[iIndex].label; iIndex++)
6175 if (strwicmp(parm_table[iIndex].label, pszParmName) == 0)
6176 return (iIndex);
6177
6178 /* Warn only if it isn't parametric option */
6179 if (strchr(pszParmName, ':') == NULL)
6180 DEBUG(1, ("Unknown parameter encountered: \"%s\"\n", pszParmName));
6181 /* We do return 'fail' for parametric options as well because they are
6182 stored in different storage
6183 */
6184 return (-1);
6185 }
6186
6187 /***************************************************************************
6188 Map a parameter's string representation to the index of the canonical
6189 form of the parameter (it might be a synonym).
6190 Returns -1 if the parameter string is not recognised.
6191 ***************************************************************************/
6192
6193 static int map_parameter_canonical(const char *pszParmName, bool *inverse)
6194 {
6195 int parm_num, canon_num;
6196 bool loc_inverse = false;
6197
6198 parm_num = map_parameter(pszParmName);
6199 if ((parm_num < 0) || !(parm_table[parm_num].flags & FLAG_HIDE)) {
6200 /* invalid, parametric or no canidate for synonyms ... */
6201 goto done;
6202 }
6203
6204 for (canon_num = 0; parm_table[canon_num].label; canon_num++) {
6205 if (is_synonym_of(parm_num, canon_num, &loc_inverse)) {
6206 parm_num = canon_num;
6207 goto done;
6208 }
6209 }
6210
6211 done:
6212 if (inverse != NULL) {
6213 *inverse = loc_inverse;
6214 }
6215 return parm_num;
6216 }
6217
6218 /***************************************************************************
6219 return true if parameter number parm1 is a synonym of parameter
6220 number parm2 (parm2 being the principal name).
6221 set inverse to true if parm1 is P_BOOLREV and parm2 is P_BOOL,
6222 false otherwise.
6223 ***************************************************************************/
6224
6225 static bool is_synonym_of(int parm1, int parm2, bool *inverse)
6226 {
6227 if ((parm_table[parm1].offset == parm_table[parm2].offset) &&
6228 (parm_table[parm1].p_class == parm_table[parm2].p_class) &&
6229 (parm_table[parm1].flags & FLAG_HIDE) &&
6230 !(parm_table[parm2].flags & FLAG_HIDE))
6231 {
6232 if (inverse != NULL) {
6233 if ((parm_table[parm1].type == P_BOOLREV) &&
6234 (parm_table[parm2].type == P_BOOL))
6235 {
6236 *inverse = true;
6237 } else {
6238 *inverse = false;
6239 }
6240 }
6241 return true;
6242 }
6243 return false;
6244 }
6245
6246 /***************************************************************************
6247 Show one parameter's name, type, [values,] and flags.
6248 (helper functions for show_parameter_list)
6249 ***************************************************************************/
6250
6251 static void show_parameter(int parmIndex)
6252 {
6253 int enumIndex, flagIndex;
6254 int parmIndex2;
6255 bool hadFlag;
6256 bool hadSyn;
6257 bool inverse;
6258 const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
6259 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING",
6260 "P_ENUM", "P_SEP"};
6261 unsigned flags[] = { FLAG_BASIC, FLAG_SHARE, FLAG_PRINT, FLAG_GLOBAL,
6262 FLAG_WIZARD, FLAG_ADVANCED, FLAG_DEVELOPER, FLAG_DEPRECATED,
6263 FLAG_HIDE};
6264 const char *flag_names[] = { "FLAG_BASIC", "FLAG_SHARE", "FLAG_PRINT",
6265 "FLAG_GLOBAL", "FLAG_WIZARD", "FLAG_ADVANCED", "FLAG_DEVELOPER",
6266 "FLAG_DEPRECATED", "FLAG_HIDE", NULL};
6267
6268 printf("%s=%s", parm_table[parmIndex].label,
6269 type[parm_table[parmIndex].type]);
6270 if (parm_table[parmIndex].type == P_ENUM) {
6271 printf(",");
6272 for (enumIndex=0;
6273 parm_table[parmIndex].enum_list[enumIndex].name;
6274 enumIndex++)
6275 {
6276 printf("%s%s",
6277 enumIndex ? "|" : "",
6278 parm_table[parmIndex].enum_list[enumIndex].name);
6279 }
6280 }
6281 printf(",");
6282 hadFlag = false;
6283 for (flagIndex=0; flag_names[flagIndex]; flagIndex++) {
6284 if (parm_table[parmIndex].flags & flags[flagIndex]) {
6285 printf("%s%s",
6286 hadFlag ? "|" : "",
6287 flag_names[flagIndex]);
6288 hadFlag = true;
6289 }
6290 }
6291
6292 /* output synonyms */
6293 hadSyn = false;
6294 for (parmIndex2=0; parm_table[parmIndex2].label; parmIndex2++) {
6295 if (is_synonym_of(parmIndex, parmIndex2, &inverse)) {
6296 printf(" (%ssynonym of %s)", inverse ? "inverse " : "",
6297 parm_table[parmIndex2].label);
6298 } else if (is_synonym_of(parmIndex2, parmIndex, &inverse)) {
6299 if (!hadSyn) {
6300 printf(" (synonyms: ");
6301 hadSyn = true;
6302 } else {
6303 printf(", ");
6304 }
6305 printf("%s%s", parm_table[parmIndex2].label,
6306 inverse ? "[i]" : "");
6307 }
6308 }
6309 if (hadSyn) {
6310 printf(")");
6311 }
6312
6313 printf("\n");
6314 }
6315
6316 /***************************************************************************
6317 Show all parameter's name, type, [values,] and flags.
6318 ***************************************************************************/
6319
6320 void show_parameter_list(void)
6321 {
6322 int classIndex, parmIndex;
6323 const char *section_names[] = { "local", "global", NULL};
6324
6325 for (classIndex=0; section_names[classIndex]; classIndex++) {
6326 printf("[%s]\n", section_names[classIndex]);
6327 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
6328 if (parm_table[parmIndex].p_class == classIndex) {
6329 show_parameter(parmIndex);
6330 }
6331 }
6332 }
6333 }
6334
6335 /***************************************************************************
6336 Check if a given string correctly represents a boolean value.
6337 ***************************************************************************/
6338
6339 bool lp_string_is_valid_boolean(const char *parm_value)
6340 {
6341 return set_boolean(parm_value, NULL);
6342 }
6343
6344 /***************************************************************************
6345 Get the standard string representation of a boolean value ("yes" or "no")
6346 ***************************************************************************/
6347
6348 static const char *get_boolean(bool bool_value)
6349 {
6350 static const char *yes_str = "yes";
6351 static const char *no_str = "no";
6352
6353 return (bool_value ? yes_str : no_str);
6354 }
6355
6356 /***************************************************************************
6357 Provide the string of the negated boolean value associated to the boolean
6358 given as a string. Returns false if the passed string does not correctly
6359 represent a boolean.
6360 ***************************************************************************/
6361
6362 bool lp_invert_boolean(const char *str, const char **inverse_str)
6363 {
6364 bool val;
6365
6366 if (!set_boolean(str, &val)) {
6367 return false;
6368 }
6369
6370 *inverse_str = get_boolean(!val);
6371 return true;
6372 }
6373
6374 /***************************************************************************
6375 Provide the canonical string representation of a boolean value given
6376 as a string. Return true on success, false if the string given does
6377 not correctly represent a boolean.
6378 ***************************************************************************/
6379
6380 bool lp_canonicalize_boolean(const char *str, const char**canon_str)
6381 {
6382 bool val;
6383
6384 if (!set_boolean(str, &val)) {
6385 return false;
6386 }
6387
6388 *canon_str = get_boolean(val);
6389 return true;
6390 }
6391
6392 /***************************************************************************
6393 Find a service by name. Otherwise works like get_service.
6394 ***************************************************************************/
6395
6396 static int getservicebyname(const char *pszServiceName, struct loadparm_service *pserviceDest)
6397 {
6398 int iService = -1;
6399 char *canon_name;
6400 TDB_DATA data;
6401
6402 if (ServiceHash == NULL) {
6403 return -1;
6404 }
6405
6406 canon_name = canonicalize_servicename(talloc_tos(), pszServiceName);
6407
6408 data = dbwrap_fetch_bystring(ServiceHash, canon_name, canon_name);
6409
6410 if ((data.dptr != NULL) && (data.dsize == sizeof(iService))) {
6411 iService = *(int *)data.dptr;
6412 }
6413
6414 TALLOC_FREE(canon_name);
6415
6416 if ((iService != -1) && (LP_SNUM_OK(iService))
6417 && (pserviceDest != NULL)) {
6418 copy_service(pserviceDest, ServicePtrs[iService], NULL);
6419 }
6420
6421 return (iService);
6422 }
6423
6424 /* Return a pointer to a service by name. Unlike getservicebyname, it does not copy the service */
6425 struct loadparm_service *lp_service(const char *pszServiceName)
6426 {
6427 int iService = getservicebyname(pszServiceName, NULL);
6428 if (iService == -1 || !LP_SNUM_OK(iService)) {
6429 return NULL;
6430 }
6431 return ServicePtrs[iService];
6432 }
6433
6434 struct loadparm_service *lp_servicebynum(int snum)
6435 {
6436 if ((snum == -1) || !LP_SNUM_OK(snum)) {
6437 return NULL;
6438 }
6439 return ServicePtrs[snum];
6440 }
6441
6442 struct loadparm_service *lp_default_loadparm_service()
6443 {
6444 return &sDefault;
6445 }
6446
6447
6448 /***************************************************************************
6449 Copy a service structure to another.
6450 If pcopymapDest is NULL then copy all fields
6451 ***************************************************************************/
6452
6453 /**
6454 * Add a parametric option to a parmlist_entry,
6455 * replacing old value, if already present.
6456 */
6457 static void set_param_opt(struct parmlist_entry **opt_list,
6458 const char *opt_name,
6459 const char *opt_value,
6460 unsigned priority)
6461 {
6462 struct parmlist_entry *new_opt, *opt;
6463 bool not_added;
6464
6465 if (opt_list == NULL) {
6466 return;
6467 }
6468
6469 opt = *opt_list;
6470 not_added = true;
6471
6472 /* Traverse destination */
6473 while (opt) {
6474 /* If we already have same option, override it */
6475 if (strwicmp(opt->key, opt_name) == 0) {
6476 if ((opt->priority & FLAG_CMDLINE) &&
6477 !(priority & FLAG_CMDLINE)) {
6478 /* it's been marked as not to be
6479 overridden */
6480 return;
6481 }
6482 string_free(&opt->value);
6483 TALLOC_FREE(opt->list);
6484 opt->value = SMB_STRDUP(opt_value);
6485 opt->priority = priority;
6486 not_added = false;
6487 break;
6488 }
6489 opt = opt->next;
6490 }
6491 if (not_added) {
6492 new_opt = SMB_XMALLOC_P(struct parmlist_entry);
6493 new_opt->key = SMB_STRDUP(opt_name);
6494 new_opt->value = SMB_STRDUP(opt_value);
6495 new_opt->list = NULL;
6496 new_opt->priority = priority;
6497 DLIST_ADD(*opt_list, new_opt);
6498 }
6499 }
6500
6501 static void copy_service(struct loadparm_service *pserviceDest, struct loadparm_service *pserviceSource,
6502 struct bitmap *pcopymapDest)
6503 {
6504 int i;
6505 bool bcopyall = (pcopymapDest == NULL);
6506 struct parmlist_entry *data;
6507
6508 for (i = 0; parm_table[i].label; i++)
6509 if (parm_table[i].p_class == P_LOCAL &&
6510 (bcopyall || bitmap_query(pcopymapDest,i))) {
6511 void *src_ptr = lp_parm_ptr(pserviceSource, &parm_table[i]);
6512 void *dest_ptr = lp_parm_ptr(pserviceDest, &parm_table[i]);
6513
6514 switch (parm_table[i].type) {
6515 case P_BOOL:
6516 case P_BOOLREV:
6517 *(bool *)dest_ptr = *(bool *)src_ptr;
6518 break;
6519
6520 case P_INTEGER:
6521 case P_ENUM:
6522 case P_OCTAL:
6523 *(int *)dest_ptr = *(int *)src_ptr;
6524 break;
6525
6526 case P_CHAR:
6527 *(char *)dest_ptr = *(char *)src_ptr;
6528 break;
6529
6530 case P_STRING:
6531 string_set((char **)dest_ptr,
6532 *(char **)src_ptr);
6533 break;
6534
6535 case P_USTRING:
6536 {
6537 char *upper_string = strupper_talloc(talloc_tos(),
6538 *(char **)src_ptr);
6539 string_set((char **)dest_ptr,
6540 upper_string);
6541 TALLOC_FREE(upper_string);
6542 break;
6543 }
6544 case P_LIST:
6545 TALLOC_FREE(*((char ***)dest_ptr));
6546 *((char ***)dest_ptr) = str_list_copy(NULL,
6547 *(const char ***)src_ptr);
6548 break;
6549 default:
6550 break;
6551 }
6552 }
6553
6554 if (bcopyall) {
6555 init_copymap(pserviceDest);
6556 if (pserviceSource->copymap)
6557 bitmap_copy(pserviceDest->copymap,
6558 pserviceSource->copymap);
6559 }
6560
6561 data = pserviceSource->param_opt;
6562 while (data) {
6563 set_param_opt(&pserviceDest->param_opt, data->key, data->value, data->priority);
6564 data = data->next;
6565 }
6566 }
6567
6568 /***************************************************************************
6569 Check a service for consistency. Return false if the service is in any way
6570 incomplete or faulty, else true.
6571 ***************************************************************************/
6572
6573 bool service_ok(int iService)
6574 {
6575 bool bRetval;
6576
6577 bRetval = true;
6578 if (ServicePtrs[iService]->szService[0] == '\0') {
6579 DEBUG(0, ("The following message indicates an internal error:\n"));
6580 DEBUG(0, ("No service name in service entry.\n"));
6581 bRetval = false;
6582 }
6583
6584 /* The [printers] entry MUST be printable. I'm all for flexibility, but */
6585 /* I can't see why you'd want a non-printable printer service... */
6586 if (strwicmp(ServicePtrs[iService]->szService, PRINTERS_NAME) == 0) {
6587 if (!ServicePtrs[iService]->bPrint_ok) {
6588 DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
6589 ServicePtrs[iService]->szService));
6590 ServicePtrs[iService]->bPrint_ok = true;
6591 }
6592 /* [printers] service must also be non-browsable. */
6593 if (ServicePtrs[iService]->bBrowseable)
6594 ServicePtrs[iService]->bBrowseable = false;
6595 }
6596
6597 if (ServicePtrs[iService]->szPath[0] == '\0' &&
6598 strwicmp(ServicePtrs[iService]->szService, HOMES_NAME) != 0 &&
6599 ServicePtrs[iService]->szMSDfsProxy[0] == '\0'
6600 ) {
6601 DEBUG(0, ("WARNING: No path in service %s - making it unavailable!\n",
6602 ServicePtrs[iService]->szService));
6603 ServicePtrs[iService]->bAvailable = false;
6604 }
6605
6606 /* If a service is flagged unavailable, log the fact at level 1. */
6607 if (!ServicePtrs[iService]->bAvailable)
6608 DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
6609 ServicePtrs[iService]->szService));
6610
6611 return (bRetval);
6612 }
6613
6614 static struct smbconf_ctx *lp_smbconf_ctx(void)
6615 {
6616 sbcErr err;
6617 static struct smbconf_ctx *conf_ctx = NULL;
6618
6619 if (conf_ctx == NULL) {
6620 err = smbconf_init(NULL, &conf_ctx, "registry:");
6621 if (!SBC_ERROR_IS_OK(err)) {
6622 DEBUG(1, ("error initializing registry configuration: "
6623 "%s\n", sbcErrorString(err)));
6624 conf_ctx = NULL;
6625 }
6626 }
6627
6628 return conf_ctx;
6629 }
6630
6631 static bool process_smbconf_service(struct smbconf_service *service)
6632 {
6633 uint32_t count;
6634 bool ret;
6635
6636 if (service == NULL) {
6637 return false;
6638 }
6639
6640 ret = do_section(service->name, NULL);
6641 if (ret != true) {
6642 return false;
6643 }
6644 for (count = 0; count < service->num_params; count++) {
6645 ret = do_parameter(service->param_names[count],
6646 service->param_values[count],
6647 NULL);
6648 if (ret != true) {
6649 return false;
6650 }
6651 }
6652 if (iServiceIndex >= 0) {
6653 return service_ok(iServiceIndex);
6654 }
6655 return true;
6656 }
6657
6658 /**
6659 * load a service from registry and activate it
6660 */
6661 bool process_registry_service(const char *service_name)
6662 {
6663 sbcErr err;
6664 struct smbconf_service *service = NULL;
6665 TALLOC_CTX *mem_ctx = talloc_stackframe();
6666 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
6667 bool ret = false;
6668
6669 if (conf_ctx == NULL) {
6670 goto done;
6671 }
6672
6673 DEBUG(5, ("process_registry_service: service name %s\n", service_name));
6674
6675 if (!smbconf_share_exists(conf_ctx, service_name)) {
6676 /*
6677 * Registry does not contain data for this service (yet),
6678 * but make sure lp_load doesn't return false.
6679 */
6680 ret = true;
6681 goto done;
6682 }
6683
6684 err = smbconf_get_share(conf_ctx, mem_ctx, service_name, &service);
6685 if (!SBC_ERROR_IS_OK(err)) {
6686 goto done;
6687 }
6688
6689 ret = process_smbconf_service(service);
6690 if (!ret) {
6691 goto done;
6692 }
6693
6694 /* store the csn */
6695 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
6696
6697 done:
6698 TALLOC_FREE(mem_ctx);
6699 return ret;
6700 }
6701
6702 /*
6703 * process_registry_globals
6704 */
6705 static bool process_registry_globals(void)
6706 {
6707 bool ret;
6708
6709 add_to_file_list(INCLUDE_REGISTRY_NAME, INCLUDE_REGISTRY_NAME);
6710
6711 ret = do_parameter("registry shares", "yes", NULL);
6712 if (!ret) {
6713 return ret;
6714 }
6715
6716 return process_registry_service(GLOBAL_NAME);
6717 }
6718
6719 bool process_registry_shares(void)
6720 {
6721 sbcErr err;
6722 uint32_t count;
6723 struct smbconf_service **service = NULL;
6724 uint32_t num_shares = 0;
6725 TALLOC_CTX *mem_ctx = talloc_stackframe();
6726 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
6727 bool ret = false;
6728
6729 if (conf_ctx == NULL) {
6730 goto done;
6731 }
6732
6733 err = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &service);
6734 if (!SBC_ERROR_IS_OK(err)) {
6735 goto done;
6736 }
6737
6738 ret = true;
6739
6740 for (count = 0; count < num_shares; count++) {
6741 if (strequal(service[count]->name, GLOBAL_NAME)) {
6742 continue;
6743 }
6744 ret = process_smbconf_service(service[count]);
6745 if (!ret) {
6746 goto done;
6747 }
6748 }
6749
6750 /* store the csn */
6751 smbconf_changed(conf_ctx, &conf_last_csn, NULL, NULL);
6752
6753 done:
6754 TALLOC_FREE(mem_ctx);
6755 return ret;
6756 }
6757
6758 /**
6759 * reload those shares from registry that are already
6760 * activated in the services array.
6761 */
6762 static bool reload_registry_shares(void)
6763 {
6764 int i;
6765 bool ret = true;
6766
6767 for (i = 0; i < iNumServices; i++) {
6768 if (!VALID(i)) {
6769 continue;
6770 }
6771
6772 if (ServicePtrs[i]->usershare == USERSHARE_VALID) {
6773 continue;
6774 }
6775
6776 ret = process_registry_service(ServicePtrs[i]->szService);
6777 if (!ret) {
6778 goto done;
6779 }
6780 }
6781
6782 done:
6783 return ret;
6784 }
6785
6786
6787 #define MAX_INCLUDE_DEPTH 100
6788
6789 static uint8_t include_depth;
6790
6791 static struct file_lists {
6792 struct file_lists *next;
6793 char *name;
6794 char *subfname;
6795 time_t modtime;
6796 } *file_lists = NULL;
6797
6798 /*******************************************************************
6799 Keep a linked list of all config files so we know when one has changed
6800 it's date and needs to be reloaded.
6801 ********************************************************************/
6802
6803 static void add_to_file_list(const char *fname, const char *subfname)
6804 {
6805 struct file_lists *f = file_lists;
6806
6807 while (f) {
6808 if (f->name && !strcmp(f->name, fname))
6809 break;
6810 f = f->next;
6811 }
6812
6813 if (!f) {
6814 f = SMB_MALLOC_P(struct file_lists);
6815 if (!f)
6816 return;
6817 f->next = file_lists;
6818 f->name = SMB_STRDUP(fname);
6819 if (!f->name) {
6820 SAFE_FREE(f);
6821 return;
6822 }
6823 f->subfname = SMB_STRDUP(subfname);
6824 if (!f->subfname) {
6825 SAFE_FREE(f->name);
6826 SAFE_FREE(f);
6827 return;
6828 }
6829 file_lists = f;
6830 f->modtime = file_modtime(subfname);
6831 } else {
6832 time_t t = file_modtime(subfname);
6833 if (t)
6834 f->modtime = t;
6835 }
6836 return;
6837 }
6838
6839 /**
6840 * Free the file lists
6841 */
6842 static void free_file_list(void)
6843 {
6844 struct file_lists *f;
6845 struct file_lists *next;
6846
6847 f = file_lists;
6848 while( f ) {
6849 next = f->next;
6850 SAFE_FREE( f->name );
6851 SAFE_FREE( f->subfname );
6852 SAFE_FREE( f );
6853 f = next;
6854 }
6855 file_lists = NULL;
6856 }
6857
6858
6859 /**
6860 * Utility function for outsiders to check if we're running on registry.
6861 */
6862 bool lp_config_backend_is_registry(void)
6863 {
6864 return (lp_config_backend() == CONFIG_BACKEND_REGISTRY);
6865 }
6866
6867 /**
6868 * Utility function to check if the config backend is FILE.
6869 */
6870 bool lp_config_backend_is_file(void)
6871 {
6872 return (lp_config_backend() == CONFIG_BACKEND_FILE);
6873 }
6874
6875 /*******************************************************************
6876 Check if a config file has changed date.
6877 ********************************************************************/
6878
6879 bool lp_file_list_changed(void)
6880 {
6881 struct file_lists *f = file_lists;
6882
6883 DEBUG(6, ("lp_file_list_changed()\n"));
6884
6885 while (f) {
6886 time_t mod_time;
6887
6888 if (strequal(f->name, INCLUDE_REGISTRY_NAME)) {
6889 struct smbconf_ctx *conf_ctx = lp_smbconf_ctx();
6890
6891 if (conf_ctx == NULL) {
6892 return false;
6893 }
6894 if (smbconf_changed(conf_ctx, &conf_last_csn, NULL,
6895 NULL))
6896 {
6897 DEBUGADD(6, ("registry config changed\n"));
6898 return true;
6899 }
6900 } else {
6901 char *n2 = NULL;
6902 n2 = talloc_sub_basic(talloc_tos(),
6903 get_current_username(),
6904 current_user_info.domain,
6905 f->name);
6906 if (!n2) {
6907 return false;
6908 }
6909 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
6910 f->name, n2, ctime(&f->modtime)));
6911
6912 mod_time = file_modtime(n2);
6913
6914 if (mod_time &&
6915 ((f->modtime != mod_time) ||
6916 (f->subfname == NULL) ||
6917 (strcmp(n2, f->subfname) != 0)))
6918 {
6919 DEBUGADD(6,
6920 ("file %s modified: %s\n", n2,
6921 ctime(&mod_time)));
6922 f->modtime = mod_time;
6923 SAFE_FREE(f->subfname);
6924 f->subfname = SMB_STRDUP(n2);
6925 TALLOC_FREE(n2);
6926 return true;
6927 }
6928 TALLOC_FREE(n2);
6929 }
6930 f = f->next;
6931 }
6932 return (false);
6933 }
6934
6935
6936 /**
6937 * Initialize iconv conversion descriptors.
6938 *
6939 * This is called the first time it is needed, and also called again
6940 * every time the configuration is reloaded, because the charset or
6941 * codepage might have changed.
6942 **/
6943 static void init_iconv(void)
6944 {
6945 global_iconv_handle = smb_iconv_handle_reinit(NULL, lp_dos_charset(),
6946 lp_unix_charset(),
6947 true, global_iconv_handle);
6948 }
6949
6950 static bool handle_charset(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
6951 {
6952 if (strcmp(*ptr, pszParmValue) != 0) {
6953 string_set(ptr, pszParmValue);
6954 init_iconv();
6955 }
6956 return true;
6957 }
6958
6959 static bool handle_dos_charset(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
6960 {
6961 bool is_utf8 = false;
6962 size_t len = strlen(pszParmValue);
6963
6964 if (len == 4 || len == 5) {
6965 /* Don't use StrCaseCmp here as we don't want to
6966 initialize iconv. */
6967 if ((toupper_m(pszParmValue[0]) == 'U') &&
6968 (toupper_m(pszParmValue[1]) == 'T') &&
6969 (toupper_m(pszParmValue[2]) == 'F')) {
6970 if (len == 4) {
6971 if (pszParmValue[3] == '8') {
6972 is_utf8 = true;
6973 }
6974 } else {
6975 if (pszParmValue[3] == '-' &&
6976 pszParmValue[4] == '8') {
6977 is_utf8 = true;
6978 }
6979 }
6980 }
6981 }
6982
6983 if (strcmp(*ptr, pszParmValue) != 0) {
6984 if (is_utf8) {
6985 DEBUG(0,("ERROR: invalid DOS charset: 'dos charset' must not "
6986 "be UTF8, using (default value) %s instead.\n",
6987 DEFAULT_DOS_CHARSET));
6988 pszParmValue = DEFAULT_DOS_CHARSET;
6989 }
6990 string_set(ptr, pszParmValue);
6991 init_iconv();
6992 }
6993 return true;
6994 }
6995
6996 static bool handle_realm(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
6997 {
6998 bool ret = true;
6999 char *realm = strupper_talloc(talloc_tos(), pszParmValue);
7000 char *dnsdomain = strlower_talloc(talloc_tos(), pszParmValue);
7001
7002 ret &= string_set(&Globals.szRealm, pszParmValue);
7003 ret &= string_set(&Globals.szRealmUpper, realm);
7004 ret &= string_set(&Globals.szDnsDomain, dnsdomain);
7005 TALLOC_FREE(realm);
7006 TALLOC_FREE(dnsdomain);
7007
7008 return ret;
7009 }
7010
7011 static bool handle_netbios_aliases(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
7012 {
7013 TALLOC_FREE(Globals.szNetbiosAliases);
7014 Globals.szNetbiosAliases = (const char **)str_list_make_v3(NULL, pszParmValue, NULL);
7015 return set_netbios_aliases(Globals.szNetbiosAliases);
7016 }
7017
7018 /***************************************************************************
7019 Handle the include operation.
7020 ***************************************************************************/
7021 static bool bAllowIncludeRegistry = true;
7022
7023 static bool handle_include(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
7024 {
7025 char *fname;
7026
7027 if (include_depth >= MAX_INCLUDE_DEPTH) {
7028 DEBUG(0, ("Error: Maximum include depth (%u) exceeded!\n",
7029 include_depth));
7030 return false;
7031 }
7032
7033 if (strequal(pszParmValue, INCLUDE_REGISTRY_NAME)) {
7034 if (!bAllowIncludeRegistry) {
7035 return true;
7036 }
7037 if (bInGlobalSection) {
7038 bool ret;
7039 include_depth++;
7040 ret = process_registry_globals();
7041 include_depth--;
7042 return ret;
7043 } else {
7044 DEBUG(1, ("\"include = registry\" only effective "
7045 "in %s section\n", GLOBAL_NAME));
7046 return false;
7047 }
7048 }
7049
7050 fname = talloc_sub_basic(talloc_tos(), get_current_username(),
7051 current_user_info.domain,
7052 pszParmValue);
7053
7054 add_to_file_list(pszParmValue, fname);
7055
7056 string_set(ptr, fname);
7057
7058 if (file_exist(fname)) {
7059 bool ret;
7060 include_depth++;
7061 ret = pm_process(fname, do_section, do_parameter, NULL);
7062 include_depth--;
7063 TALLOC_FREE(fname);
7064 return ret;
7065 }
7066
7067 DEBUG(2, ("Can't find include file %s\n", fname));
7068 TALLOC_FREE(fname);
7069 return true;
7070 }
7071
7072 /***************************************************************************
7073 Handle the interpretation of the copy parameter.
7074 ***************************************************************************/
7075
7076 static bool handle_copy(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
7077 {
7078 bool bRetval;
7079 int iTemp;
7080 struct loadparm_service serviceTemp;
7081
7082 string_set(ptr, pszParmValue);
7083
7084 init_service(&serviceTemp);
7085
7086 bRetval = false;
7087
7088 DEBUG(3, ("Copying service from service %s\n", pszParmValue));
7089
7090 if ((iTemp = getservicebyname(pszParmValue, &serviceTemp)) >= 0) {
7091 if (iTemp == iServiceIndex) {
7092 DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
7093 } else {
7094 copy_service(ServicePtrs[iServiceIndex],
7095 &serviceTemp,
7096 ServicePtrs[iServiceIndex]->copymap);
7097 bRetval = true;
7098 }
7099 } else {
7100 DEBUG(0, ("Unable to copy service - source not found: %s\n", pszParmValue));
7101 bRetval = false;
7102 }
7103
7104 free_service(&serviceTemp);
7105 return (bRetval);
7106 }
7107
7108 static bool handle_ldap_debug_level(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
7109 {
7110 Globals.ldap_debug_level = lp_int(pszParmValue);
7111 init_ldap_debugging();
7112 return true;
7113 }
7114
7115 /***************************************************************************
7116 Handle idmap/non unix account uid and gid allocation parameters. The format of these
7117 parameters is:
7118
7119 [global]
7120
7121 idmap uid = 1000-1999
7122 idmap gid = 700-899
7123
7124 We only do simple parsing checks here. The strings are parsed into useful
7125 structures in the idmap daemon code.
7126
7127 ***************************************************************************/
7128
7129 /* Some lp_ routines to return idmap [ug]id information */
7130
7131 static uid_t idmap_uid_low, idmap_uid_high;
7132 static gid_t idmap_gid_low, idmap_gid_high;
7133
7134 bool lp_idmap_uid(uid_t *low, uid_t *high)
7135 {
7136 if (idmap_uid_low == 0 || idmap_uid_high == 0)
7137 return false;
7138
7139 if (low)
7140 *low = idmap_uid_low;
7141
7142 if (high)
7143 *high = idmap_uid_high;
7144
7145 return true;
7146 }
7147
7148 bool lp_idmap_gid(gid_t *low, gid_t *high)
7149 {
7150 if (idmap_gid_low == 0 || idmap_gid_high == 0)
7151 return false;
7152
7153 if (low)
7154 *low = idmap_gid_low;
7155
7156 if (high)
7157 *high = idmap_gid_high;
7158
7159 return true;
7160 }
7161
7162 static bool handle_idmap_backend(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
7163 {
7164 lp_do_parameter(snum, "idmap config * : backend", pszParmValue);
7165
7166 return true;
7167 }
7168
7169 /* Do some simple checks on "idmap [ug]id" parameter values */
7170
7171 static bool handle_idmap_uid(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
7172 {
7173 lp_do_parameter(snum, "idmap config * : range", pszParmValue);
7174
7175 return true;
7176 }
7177
7178 static bool handle_idmap_gid(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
7179 {
7180 lp_do_parameter(snum, "idmap config * : range", pszParmValue);
7181
7182 return true;
7183 }
7184
7185 /***************************************************************************
7186 Handle the DEBUG level list.
7187 ***************************************************************************/
7188
7189 static bool handle_debug_list(struct loadparm_context *unused, int snum, const char *pszParmValueIn, char **ptr )
7190 {
7191 string_set(ptr, pszParmValueIn);
7192 return debug_parse_levels(pszParmValueIn);
7193 }
7194
7195 /***************************************************************************
7196 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
7197 ***************************************************************************/
7198
7199 static const char *append_ldap_suffix( const char *str )
7200 {
7201 const char *suffix_string;
7202
7203
7204 suffix_string = talloc_asprintf(talloc_tos(), "%s,%s", str,
7205 Globals.szLdapSuffix );
7206 if ( !suffix_string ) {
7207 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
7208 return "";
7209 }
7210
7211 return suffix_string;
7212 }
7213
7214 const char *lp_ldap_machine_suffix(void)
7215 {
7216 if (Globals.szLdapMachineSuffix[0])
7217 return append_ldap_suffix(Globals.szLdapMachineSuffix);
7218
7219 return lp_string(Globals.szLdapSuffix);
7220 }
7221
7222 const char *lp_ldap_user_suffix(void)
7223 {
7224 if (Globals.szLdapUserSuffix[0])
7225 return append_ldap_suffix(Globals.szLdapUserSuffix);
7226
7227 return lp_string(Globals.szLdapSuffix);
7228 }
7229
7230 const char *lp_ldap_group_suffix(void)
7231 {
7232 if (Globals.szLdapGroupSuffix[0])
7233 return append_ldap_suffix(Globals.szLdapGroupSuffix);
7234
7235 return lp_string(Globals.szLdapSuffix);
7236 }
7237
7238 const char *lp_ldap_idmap_suffix(void)
7239 {
7240 if (Globals.szLdapIdmapSuffix[0])
7241 return append_ldap_suffix(Globals.szLdapIdmapSuffix);
7242
7243 return lp_string(Globals.szLdapSuffix);
7244 }
7245
7246 /****************************************************************************
7247 set the value for a P_ENUM
7248 ***************************************************************************/
7249
7250 static void lp_set_enum_parm( struct parm_struct *parm, const char *pszParmValue,
7251 int *ptr )
7252 {
7253 int i;
7254
7255 for (i = 0; parm->enum_list[i].name; i++) {
7256 if ( strequal(pszParmValue, parm->enum_list[i].name)) {
7257 *ptr = parm->enum_list[i].value;
7258 return;
7259 }
7260 }
7261 DEBUG(0, ("WARNING: Ignoring invalid value '%s' for parameter '%s'\n",
7262 pszParmValue, parm->label));
7263 }
7264
7265 /***************************************************************************
7266 ***************************************************************************/
7267
7268 static bool handle_printing(struct loadparm_context *unused, int snum, const char *pszParmValue, char **ptr)
7269 {
7270 static int parm_num = -1;
7271 struct loadparm_service *s;
7272
7273 if ( parm_num == -1 )
7274 parm_num = map_parameter( "printing" );
7275
7276 lp_set_enum_parm( &parm_table[parm_num], pszParmValue, (int*)ptr );
7277
7278 if ( snum < 0 )
7279 s = &sDefault;
7280 else
7281 s = ServicePtrs[snum];
7282
7283 init_printer_values( s );
7284
7285 return true;
7286 }
7287
7288
7289 /***************************************************************************
7290 Initialise a copymap.
7291 ***************************************************************************/
7292
7293 static void init_copymap(struct loadparm_service *pservice)
7294 {
7295 int i;
7296
7297 TALLOC_FREE(pservice->copymap);
7298
7299 pservice->copymap = bitmap_talloc(NULL, NUMPARAMETERS);
7300 if (!pservice->copymap)
7301 DEBUG(0,
7302 ("Couldn't allocate copymap!! (size %d)\n",
7303 (int)NUMPARAMETERS));
7304 else
7305 for (i = 0; i < NUMPARAMETERS; i++)
7306 bitmap_set(pservice->copymap, i);
7307 }
7308
7309 /**
7310 return the parameter pointer for a parameter
7311 */
7312 void *lp_parm_ptr(struct loadparm_service *service, struct parm_struct *parm)
7313 {
7314 if (service == NULL) {
7315 if (parm->p_class == P_LOCAL)
7316 return (void *)(((char *)&sDefault)+parm->offset);
7317 else if (parm->p_class == P_GLOBAL)
7318 return (void *)(((char *)&Globals)+parm->offset);
7319 else return NULL;
7320 } else {
7321 return (void *)(((char *)service) + parm->offset);
7322 }
7323 }
7324
7325 /***************************************************************************
7326 Return the local pointer to a parameter given the service number and parameter
7327 ***************************************************************************/
7328
7329 void *lp_local_ptr_by_snum(int snum, struct parm_struct *parm)
7330 {
7331 return lp_parm_ptr(ServicePtrs[snum], parm);
7332 }
7333
7334 /***************************************************************************
7335 Process a parameter for a particular service number. If snum < 0
7336 then assume we are in the globals.
7337 ***************************************************************************/
7338
7339 bool lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
7340 {
7341 int parmnum, i;
7342 void *parm_ptr = NULL; /* where we are going to store the result */
7343 struct parmlist_entry **opt_list;
7344
7345 parmnum = map_parameter(pszParmName);
7346
7347 if (parmnum < 0) {
7348 if (strchr(pszParmName, ':') == NULL) {
7349 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n",
7350 pszParmName));
7351 return (true);
7352 }
7353
7354 /*
7355 * We've got a parametric option
7356 */
7357
7358 opt_list = (snum < 0)
7359 ? &Globals.param_opt : &ServicePtrs[snum]->param_opt;
7360 set_param_opt(opt_list, pszParmName, pszParmValue, 0);
7361
7362 return (true);
7363 }
7364
7365 /* if it's already been set by the command line, then we don't
7366 override here */
7367 if (parm_table[parmnum].flags & FLAG_CMDLINE) {
7368 return true;
7369 }
7370
7371 if (parm_table[parmnum].flags & FLAG_DEPRECATED) {
7372 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
7373 pszParmName));
7374 }
7375
7376 /* we might point at a service, the default service or a global */
7377 if (snum < 0) {
7378 parm_ptr = lp_parm_ptr(NULL, &parm_table[parmnum]);
7379 } else {
7380 if (parm_table[parmnum].p_class == P_GLOBAL) {
7381 DEBUG(0,
7382 ("Global parameter %s found in service section!\n",
7383 pszParmName));
7384 return (true);
7385 }
7386 parm_ptr = lp_local_ptr_by_snum(snum, &parm_table[parmnum]);
7387 }
7388
7389 if (snum >= 0) {
7390 if (!ServicePtrs[snum]->copymap)
7391 init_copymap(ServicePtrs[snum]);
7392
7393 /* this handles the aliases - set the copymap for other entries with
7394 the same data pointer */
7395 for (i = 0; parm_table[i].label; i++) {
7396 if ((parm_table[i].offset == parm_table[parmnum].offset)
7397 && (parm_table[i].p_class == parm_table[parmnum].p_class)) {
7398 bitmap_clear(ServicePtrs[snum]->copymap, i);
7399 }
7400 }
7401 }
7402
7403 /* if it is a special case then go ahead */
7404 if (parm_table[parmnum].special) {
7405 return parm_table[parmnum].special(NULL, snum, pszParmValue,
7406 (char **)parm_ptr);
7407 }
7408
7409 /* now switch on the type of variable it is */
7410 switch (parm_table[parmnum].type)
7411 {
7412 case P_BOOL:
7413 *(bool *)parm_ptr = lp_bool(pszParmValue);
7414 break;
7415
7416 case P_BOOLREV:
7417 *(bool *)parm_ptr = !lp_bool(pszParmValue);
7418 break;
7419
7420 case P_INTEGER:
7421 *(int *)parm_ptr = lp_int(pszParmValue);
7422 break;
7423
7424 case P_CHAR:
7425 *(char *)parm_ptr = *pszParmValue;
7426 break;
7427
7428 case P_OCTAL:
7429 i = sscanf(pszParmValue, "%o", (int *)parm_ptr);
7430 if ( i != 1 ) {
7431 DEBUG ( 0, ("Invalid octal number %s\n", pszParmName ));
7432 }
7433 break;
7434
7435 case P_BYTES:
7436 {
7437 uint64_t val;
7438 if (conv_str_size_error(pszParmValue, &val)) {
7439 if (val <= INT_MAX) {
7440 *(int *)parm_ptr = (int)val;
7441 break;
7442 }
7443 }
7444
7445 DEBUG(0,("lp_do_parameter(%s): value is not "
7446 "a valid size specifier!\n", pszParmValue));
7447 return false;
7448 }
7449
7450 case P_LIST:
7451 case P_CMDLIST:
7452 TALLOC_FREE(*((char ***)parm_ptr));
7453 *(char ***)parm_ptr = str_list_make_v3(
7454 NULL, pszParmValue, NULL);
7455 break;
7456
7457 case P_STRING:
7458 string_set((char **)parm_ptr, pszParmValue);
7459 break;
7460
7461 case P_USTRING:
7462 {
7463 char *upper_string = strupper_talloc(talloc_tos(),
7464 pszParmValue);
7465 string_set((char **)parm_ptr, upper_string);
7466 TALLOC_FREE(upper_string);
7467 break;
7468 }
7469 case P_ENUM:
7470 lp_set_enum_parm( &parm_table[parmnum], pszParmValue, (int*)parm_ptr );
7471 break;
7472 case P_SEP:
7473 break;
7474 }
7475
7476 return (true);
7477 }
7478
7479 /***************************************************************************
7480 set a parameter, marking it with FLAG_CMDLINE. Parameters marked as
7481 FLAG_CMDLINE won't be overridden by loads from smb.conf.
7482 ***************************************************************************/
7483
7484 static bool lp_set_cmdline_helper(const char *pszParmName, const char *pszParmValue, bool store_values)
7485 {
7486 int parmnum, i;
7487 parmnum = map_parameter(pszParmName);
7488 if (parmnum >= 0) {
7489 parm_table[parmnum].flags &= ~FLAG_CMDLINE;
7490 if (!lp_do_parameter(-1, pszParmName, pszParmValue)) {
7491 return false;
7492 }
7493 parm_table[parmnum].flags |= FLAG_CMDLINE;
7494
7495 /* we have to also set FLAG_CMDLINE on aliases. Aliases must
7496 * be grouped in the table, so we don't have to search the
7497 * whole table */
7498 for (i=parmnum-1;
7499 i>=0 && parm_table[i].offset == parm_table[parmnum].offset
7500 && parm_table[i].p_class == parm_table[parmnum].p_class;
7501 i--) {
7502 parm_table[i].flags |= FLAG_CMDLINE;
7503 }
7504 for (i=parmnum+1;i<NUMPARAMETERS && parm_table[i].offset == parm_table[parmnum].offset
7505 && parm_table[i].p_class == parm_table[parmnum].p_class;i++) {
7506 parm_table[i].flags |= FLAG_CMDLINE;
7507 }
7508
7509 if (store_values) {
7510 store_lp_set_cmdline(pszParmName, pszParmValue);
7511 }
7512 return true;
7513 }
7514
7515 /* it might be parametric */
7516 if (strchr(pszParmName, ':') != NULL) {
7517 set_param_opt(&Globals.param_opt, pszParmName, pszParmValue, FLAG_CMDLINE);
7518 if (store_values) {
7519 store_lp_set_cmdline(pszParmName, pszParmValue);
7520 }
7521 return true;
7522 }
7523
7524 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
7525 return true;
7526 }
7527
7528 bool lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
7529 {
7530 return lp_set_cmdline_helper(pszParmName, pszParmValue, true);
7531 }
7532
7533 /***************************************************************************
7534 Process a parameter.
7535 ***************************************************************************/
7536
7537 static bool do_parameter(const char *pszParmName, const char *pszParmValue,
7538 void *userdata)
7539 {
7540 if (!bInGlobalSection && bGlobalOnly)
7541 return (true);
7542
7543 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
7544
7545 return (lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
7546 pszParmName, pszParmValue));
7547 }
7548
7549 /*
7550 set a option from the commandline in 'a=b' format. Use to support --option
7551 */
7552 bool lp_set_option(const char *option)
7553 {
7554 char *p, *s;
7555 bool ret;
7556
7557 s = talloc_strdup(NULL, option);
7558 if (!s) {
7559 return false;
7560 }
7561
7562 p = strchr(s, '=');
7563 if (!p) {
7564 talloc_free(s);
7565 return false;
7566 }
7567
7568 *p = 0;
7569
7570 /* skip white spaces after the = sign */
7571 do {
7572 p++;
7573 } while (*p == ' ');
7574
7575 ret = lp_set_cmdline(s, p);
7576 talloc_free(s);
7577 return ret;
7578 }
7579
7580 /**************************************************************************
7581 Print a parameter of the specified type.
7582 ***************************************************************************/
7583
7584 static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
7585 {
7586 /* For the seperation of lists values that we print below */
7587 const char *list_sep = ", ";
7588 int i;
7589 switch (p->type)
7590 {
7591 case P_ENUM:
7592 for (i = 0; p->enum_list[i].name; i++) {
7593 if (*(int *)ptr == p->enum_list[i].value) {
7594 fprintf(f, "%s",
7595 p->enum_list[i].name);
7596 break;
7597 }
7598 }
7599 break;
7600
7601 case P_BOOL:
7602 fprintf(f, "%s", BOOLSTR(*(bool *)ptr));
7603 break;
7604
7605 case P_BOOLREV:
7606 fprintf(f, "%s", BOOLSTR(!*(bool *)ptr));
7607 break;
7608
7609 case P_INTEGER:
7610 case P_BYTES:
7611 fprintf(f, "%d", *(int *)ptr);
7612 break;
7613
7614 case P_CHAR:
7615 fprintf(f, "%c", *(char *)ptr);
7616 break;
7617
7618 case P_OCTAL: {
7619 int val = *(int *)ptr;
7620 if (val == -1) {
7621 fprintf(f, "-1");
7622 } else {
7623 fprintf(f, "0%o", val);
7624 }
7625 break;
7626 }
7627
7628 case P_CMDLIST:
7629 list_sep = " ";
7630 /* fall through */
7631 case P_LIST:
7632 if ((char ***)ptr && *(char ***)ptr) {
7633 char **list = *(char ***)ptr;
7634 for (; *list; list++) {
7635 /* surround strings with whitespace in double quotes */
7636 if (*(list+1) == NULL) {
7637 /* last item, no extra separator */
7638 list_sep = "";
7639 }
7640 if ( strchr_m( *list, ' ' ) ) {
7641 fprintf(f, "\"%s\"%s", *list, list_sep);
7642 } else {
7643 fprintf(f, "%s%s", *list, list_sep);
7644 }
7645 }
7646 }
7647 break;
7648
7649 case P_STRING:
7650 case P_USTRING:
7651 if (*(char **)ptr) {
7652 fprintf(f, "%s", *(char **)ptr);
7653 }
7654 break;
7655 case P_SEP:
7656 break;
7657 }
7658 }
7659
7660 /***************************************************************************
7661 Check if two parameters are equal.
7662 ***************************************************************************/
7663
7664 static bool equal_parameter(parm_type type, void *ptr1, void *ptr2)
7665 {
7666 switch (type) {
7667 case P_BOOL:
7668 case P_BOOLREV:
7669 return (*((bool *)ptr1) == *((bool *)ptr2));
7670
7671 case P_INTEGER:
7672 case P_ENUM:
7673 case P_OCTAL:
7674 case P_BYTES:
7675 return (*((int *)ptr1) == *((int *)ptr2));
7676
7677 case P_CHAR:
7678 return (*((char *)ptr1) == *((char *)ptr2));
7679
7680 case P_LIST:
7681 case P_CMDLIST:
7682 return str_list_equal(*(const char ***)ptr1, *(const char ***)ptr2);
7683
7684 case P_STRING:
7685 case P_USTRING:
7686 {
7687 char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
7688 if (p1 && !*p1)
7689 p1 = NULL;
7690 if (p2 && !*p2)
7691 p2 = NULL;
7692 return (p1 == p2 || strequal(p1, p2));
7693 }
7694 case P_SEP:
7695 break;
7696 }
7697 return (false);
7698 }
7699
7700 /***************************************************************************
7701 Initialize any local varients in the sDefault table.
7702 ***************************************************************************/
7703
7704 void init_locals(void)
7705 {
7706 /* None as yet. */
7707 }
7708
7709 /***************************************************************************
7710 Process a new section (service). At this stage all sections are services.
7711 Later we'll have special sections that permit server parameters to be set.
7712 Returns true on success, false on failure.
7713 ***************************************************************************/
7714
7715 static bool do_section(const char *pszSectionName, void *userdata)
7716 {
7717 bool bRetval;
7718 bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
7719 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
7720 bRetval = false;
7721
7722 /* if we were in a global section then do the local inits */
7723 if (bInGlobalSection && !isglobal)
7724 init_locals();
7725
7726 /* if we've just struck a global section, note the fact. */
7727 bInGlobalSection = isglobal;
7728
7729 /* check for multiple global sections */
7730 if (bInGlobalSection) {
7731 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
7732 return (true);
7733 }
7734
7735 if (!bInGlobalSection && bGlobalOnly)
7736 return (true);
7737
7738 /* if we have a current service, tidy it up before moving on */
7739 bRetval = true;
7740
7741 if (iServiceIndex >= 0)
7742 bRetval = service_ok(iServiceIndex);
7743
7744 /* if all is still well, move to the next record in the services array */
7745 if (bRetval) {
7746 /* We put this here to avoid an odd message order if messages are */
7747 /* issued by the post-processing of a previous section. */
7748 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
7749
7750 iServiceIndex = add_a_service(&sDefault, pszSectionName);
7751 if (iServiceIndex < 0) {
7752 DEBUG(0, ("Failed to add a new service\n"));
7753 return (false);
7754 }
7755 /* Clean all parametric options for service */
7756 /* They will be added during parsing again */
7757 free_param_opts(&ServicePtrs[iServiceIndex]->param_opt);
7758 }
7759
7760 return (bRetval);
7761 }
7762
7763
7764 /***************************************************************************
7765 Determine if a partcular base parameter is currentl set to the default value.
7766 ***************************************************************************/
7767
7768 static bool is_default(int i)
7769 {
7770 if (!defaults_saved)
7771 return false;
7772 switch (parm_table[i].type) {
7773 case P_LIST:
7774 case P_CMDLIST:
7775 return str_list_equal((const char **)parm_table[i].def.lvalue,
7776 *(const char ***)lp_parm_ptr(NULL,
7777 &parm_table[i]));
7778 case P_STRING:
7779 case P_USTRING:
7780 return strequal(parm_table[i].def.svalue,
7781 *(char **)lp_parm_ptr(NULL,
7782 &parm_table[i]));
7783 case P_BOOL:
7784 case P_BOOLREV:
7785 return parm_table[i].def.bvalue ==
7786 *(bool *)lp_parm_ptr(NULL,
7787 &parm_table[i]);
7788 case P_CHAR:
7789 return parm_table[i].def.cvalue ==
7790 *(char *)lp_parm_ptr(NULL,
7791 &parm_table[i]);
7792 case P_INTEGER:
7793 case P_OCTAL:
7794 case P_ENUM:
7795 case P_BYTES:
7796 return parm_table[i].def.ivalue ==
7797 *(int *)lp_parm_ptr(NULL,
7798 &parm_table[i]);
7799 case P_SEP:
7800 break;
7801 }
7802 return false;
7803 }
7804
7805 /***************************************************************************
7806 Display the contents of the global structure.
7807 ***************************************************************************/
7808
7809 static void dump_globals(FILE *f)
7810 {
7811 int i;
7812 struct parmlist_entry *data;
7813
7814 fprintf(f, "[global]\n");
7815
7816 for (i = 0; parm_table[i].label; i++)
7817 if (parm_table[i].p_class == P_GLOBAL &&
7818 !(parm_table[i].flags & FLAG_META) &&
7819 (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset))) {
7820 if (defaults_saved && is_default(i))
7821 continue;
7822 fprintf(f, "\t%s = ", parm_table[i].label);
7823 print_parameter(&parm_table[i], lp_parm_ptr(NULL,
7824 &parm_table[i]),
7825 f);
7826 fprintf(f, "\n");
7827 }
7828 if (Globals.param_opt != NULL) {
7829 data = Globals.param_opt;
7830 while(data) {
7831 fprintf(f, "\t%s = %s\n", data->key, data->value);
7832 data = data->next;
7833 }
7834 }
7835
7836 }
7837
7838 /***************************************************************************
7839 Return true if a local parameter is currently set to the global default.
7840 ***************************************************************************/
7841
7842 bool lp_is_default(int snum, struct parm_struct *parm)
7843 {
7844 return equal_parameter(parm->type,
7845 lp_parm_ptr(ServicePtrs[snum], parm),
7846 lp_parm_ptr(NULL, parm));
7847 }
7848
7849 /***************************************************************************
7850 Display the contents of a single services record.
7851 ***************************************************************************/
7852
7853 static void dump_a_service(struct loadparm_service *pService, FILE * f)
7854 {
7855 int i;
7856 struct parmlist_entry *data;
7857
7858 if (pService != &sDefault)
7859 fprintf(f, "[%s]\n", pService->szService);
7860
7861 for (i = 0; parm_table[i].label; i++) {
7862
7863 if (parm_table[i].p_class == P_LOCAL &&
7864 !(parm_table[i].flags & FLAG_META) &&
7865 (*parm_table[i].label != '-') &&
7866 (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset)))
7867 {
7868 if (pService == &sDefault) {
7869 if (defaults_saved && is_default(i))
7870 continue;
7871 } else {
7872 if (equal_parameter(parm_table[i].type,
7873 lp_parm_ptr(pService, &parm_table[i]),
7874 lp_parm_ptr(NULL, &parm_table[i])))
7875 continue;
7876 }
7877
7878 fprintf(f, "\t%s = ", parm_table[i].label);
7879 print_parameter(&parm_table[i],
7880 lp_parm_ptr(pService, &parm_table[i]),
7881 f);
7882 fprintf(f, "\n");
7883 }
7884 }
7885
7886 if (pService->param_opt != NULL) {
7887 data = pService->param_opt;
7888 while(data) {
7889 fprintf(f, "\t%s = %s\n", data->key, data->value);
7890 data = data->next;
7891 }
7892 }
7893 }
7894
7895 /***************************************************************************
7896 Display the contents of a parameter of a single services record.
7897 ***************************************************************************/
7898
7899 bool dump_a_parameter(int snum, char *parm_name, FILE * f, bool isGlobal)
7900 {
7901 int i;
7902 bool result = false;
7903 parm_class p_class;
7904 unsigned flag = 0;
7905 fstring local_parm_name;
7906 char *parm_opt;
7907 const char *parm_opt_value;
7908
7909 /* check for parametrical option */
7910 fstrcpy( local_parm_name, parm_name);
7911 parm_opt = strchr( local_parm_name, ':');
7912
7913 if (parm_opt) {
7914 *parm_opt = '\0';
7915 parm_opt++;
7916 if (strlen(parm_opt)) {
7917 parm_opt_value = lp_parm_const_string( snum,
7918 local_parm_name, parm_opt, NULL);
7919 if (parm_opt_value) {
7920 printf( "%s\n", parm_opt_value);
7921 result = true;
7922 }
7923 }
7924 return result;
7925 }
7926
7927 /* check for a key and print the value */
7928 if (isGlobal) {
7929 p_class = P_GLOBAL;
7930 flag = FLAG_GLOBAL;
7931 } else
7932 p_class = P_LOCAL;
7933
7934 for (i = 0; parm_table[i].label; i++) {
7935 if (strwicmp(parm_table[i].label, parm_name) == 0 &&
7936 !(parm_table[i].flags & FLAG_META) &&
7937 (parm_table[i].p_class == p_class || parm_table[i].flags & flag) &&
7938 (*parm_table[i].label != '-') &&
7939 (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset)))
7940 {
7941 void *ptr;
7942
7943 if (isGlobal) {
7944 ptr = lp_parm_ptr(NULL,
7945 &parm_table[i]);
7946 } else {
7947 ptr = lp_parm_ptr(ServicePtrs[snum],
7948 &parm_table[i]);
7949 }
7950
7951 print_parameter(&parm_table[i],
7952 ptr, f);
7953 fprintf(f, "\n");
7954 result = true;
7955 break;
7956 }
7957 }
7958
7959 return result;
7960 }
7961
7962 /***************************************************************************
7963 Return info about the requested parameter (given as a string).
7964 Return NULL when the string is not a valid parameter name.
7965 ***************************************************************************/
7966
7967 struct parm_struct *lp_get_parameter(const char *param_name)
7968 {
7969 int num = map_parameter(param_name);
7970
7971 if (num < 0) {
7972 return NULL;
7973 }
7974
7975 return &parm_table[num];
7976 }
7977
7978 /***************************************************************************
7979 Return info about the next parameter in a service.
7980 snum==GLOBAL_SECTION_SNUM gives the globals.
7981 Return NULL when out of parameters.
7982 ***************************************************************************/
7983
7984 struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters)
7985 {
7986 if (snum < 0) {
7987 /* do the globals */
7988 for (; parm_table[*i].label; (*i)++) {
7989 if (parm_table[*i].p_class == P_SEPARATOR)
7990 return &parm_table[(*i)++];
7991
7992 if ((*parm_table[*i].label == '-'))
7993 continue;
7994
7995 if ((*i) > 0
7996 && (parm_table[*i].offset ==
7997 parm_table[(*i) - 1].offset)
7998 && (parm_table[*i].p_class ==
7999 parm_table[(*i) - 1].p_class))
8000 continue;
8001
8002 if (is_default(*i) && !allparameters)
8003 continue;
8004
8005 return &parm_table[(*i)++];
8006 }
8007 } else {
8008 struct loadparm_service *pService = ServicePtrs[snum];
8009
8010 for (; parm_table[*i].label; (*i)++) {
8011 if (parm_table[*i].p_class == P_SEPARATOR)
8012 return &parm_table[(*i)++];
8013
8014 if (parm_table[*i].p_class == P_LOCAL &&
8015 (*parm_table[*i].label != '-') &&
8016 ((*i) == 0 ||
8017 (parm_table[*i].offset !=
8018 parm_table[(*i) - 1].offset)))
8019 {
8020 if (allparameters ||
8021 !equal_parameter(parm_table[*i].type,
8022 lp_parm_ptr(pService,
8023 &parm_table[*i]),
8024 lp_parm_ptr(NULL,
8025 &parm_table[*i])))
8026 {
8027 return &parm_table[(*i)++];
8028 }
8029 }
8030 }
8031 }
8032
8033 return NULL;
8034 }
8035
8036
8037 #if 0
8038 /***************************************************************************
8039 Display the contents of a single copy structure.
8040 ***************************************************************************/
8041 static void dump_copy_map(bool *pcopymap)
8042 {
8043 int i;
8044 if (!pcopymap)
8045 return;
8046
8047 printf("\n\tNon-Copied parameters:\n");
8048
8049 for (i = 0; parm_table[i].label; i++)
8050 if (parm_table[i].p_class == P_LOCAL &&
8051 parm_table[i].ptr && !pcopymap[i] &&
8052 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
8053 {
8054 printf("\t\t%s\n", parm_table[i].label);
8055 }
8056 }
8057 #endif
8058
8059 /***************************************************************************
8060 Return TRUE if the passed service number is within range.
8061 ***************************************************************************/
8062
8063 bool lp_snum_ok(int iService)
8064 {
8065 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
8066 }
8067
8068 /***************************************************************************
8069 Auto-load some home services.
8070 ***************************************************************************/
8071
8072 static void lp_add_auto_services(char *str)
8073 {
8074 char *s;
8075 char *p;
8076 int homes;
8077 char *saveptr;
8078
8079 if (!str)
8080 return;
8081
8082 s = SMB_STRDUP(str);
8083 if (!s)
8084 return;
8085
8086 homes = lp_servicenumber(HOMES_NAME);
8087
8088 for (p = strtok_r(s, LIST_SEP, &saveptr); p;
8089 p = strtok_r(NULL, LIST_SEP, &saveptr)) {
8090 char *home;
8091
8092 if (lp_servicenumber(p) >= 0)
8093 continue;
8094
8095 home = get_user_home_dir(talloc_tos(), p);
8096
8097 if (home && home[0] && homes >= 0)
8098 lp_add_home(p, homes, p, home);
8099
8100 TALLOC_FREE(home);
8101 }
8102 SAFE_FREE(s);
8103 }
8104
8105 /***************************************************************************
8106 Auto-load one printer.
8107 ***************************************************************************/
8108
8109 void lp_add_one_printer(const char *name, const char *comment,
8110 const char *location, void *pdata)
8111 {
8112 int printers = lp_servicenumber(PRINTERS_NAME);
8113 int i;
8114
8115 if (lp_servicenumber(name) < 0) {
8116 lp_add_printer(name, printers);
8117 if ((i = lp_servicenumber(name)) >= 0) {
8118 string_set(&ServicePtrs[i]->comment, comment);
8119 ServicePtrs[i]->autoloaded = true;
8120 }
8121 }
8122 }
8123
8124 /***************************************************************************
8125 Have we loaded a services file yet?
8126 ***************************************************************************/
8127
8128 bool lp_loaded(void)
8129 {
8130 return (bLoaded);
8131 }
8132
8133 /***************************************************************************
8134 Unload unused services.
8135 ***************************************************************************/
8136
8137 void lp_killunused(struct smbd_server_connection *sconn,
8138 bool (*snumused) (struct smbd_server_connection *, int))
8139 {
8140 int i;
8141 for (i = 0; i < iNumServices; i++) {
8142 if (!VALID(i))
8143 continue;
8144
8145 /* don't kill autoloaded or usershare services */
8146 if ( ServicePtrs[i]->autoloaded ||
8147 ServicePtrs[i]->usershare == USERSHARE_VALID) {
8148 continue;
8149 }
8150
8151 if (!snumused || !snumused(sconn, i)) {
8152 free_service_byindex(i);
8153 }
8154 }
8155 }
8156
8157 /**
8158 * Kill all except autoloaded and usershare services - convenience wrapper
8159 */
8160 void lp_kill_all_services(void)
8161 {
8162 lp_killunused(NULL, NULL);
8163 }
8164
8165 /***************************************************************************
8166 Unload a service.
8167 ***************************************************************************/
8168
8169 void lp_killservice(int iServiceIn)
8170 {
8171 if (VALID(iServiceIn)) {
8172 free_service_byindex(iServiceIn);
8173 }
8174 }
8175
8176 /***************************************************************************
8177 Save the curent values of all global and sDefault parameters into the
8178 defaults union. This allows swat and testparm to show only the
8179 changed (ie. non-default) parameters.
8180 ***************************************************************************/
8181
8182 static void lp_save_defaults(void)
8183 {
8184 int i;
8185 for (i = 0; parm_table[i].label; i++) {
8186 if (i > 0 && parm_table[i].offset == parm_table[i - 1].offset
8187 && parm_table[i].p_class == parm_table[i - 1].p_class)
8188 continue;
8189 switch (parm_table[i].type) {
8190 case P_LIST:
8191 case P_CMDLIST:
8192 parm_table[i].def.lvalue = str_list_copy(
8193 NULL, *(const char ***)lp_parm_ptr(NULL, &parm_table[i]));
8194 break;
8195 case P_STRING:
8196 case P_USTRING:
8197 parm_table[i].def.svalue = SMB_STRDUP(*(char **)lp_parm_ptr(NULL, &parm_table[i]));
8198 break;
8199 case P_BOOL:
8200 case P_BOOLREV:
8201 parm_table[i].def.bvalue =
8202 *(bool *)lp_parm_ptr(NULL, &parm_table[i]);
8203 break;
8204 case P_CHAR:
8205 parm_table[i].def.cvalue =
8206 *(char *)lp_parm_ptr(NULL, &parm_table[i]);
8207 break;
8208 case P_INTEGER:
8209 case P_OCTAL:
8210 case P_ENUM:
8211 case P_BYTES:
8212 parm_table[i].def.ivalue =
8213 *(int *)lp_parm_ptr(NULL, &parm_table[i]);
8214 break;
8215 case P_SEP:
8216 break;
8217 }
8218 }
8219 defaults_saved = true;
8220 }
8221
8222 /***********************************************************
8223 If we should send plaintext/LANMAN passwords in the clinet
8224 ************************************************************/
8225
8226 static void set_allowed_client_auth(void)
8227 {
8228 if (Globals.bClientNTLMv2Auth) {
8229 Globals.bClientLanManAuth = false;
8230 }
8231 if (!Globals.bClientLanManAuth) {
8232 Globals.bClientPlaintextAuth = false;
8233 }
8234 }
8235
8236 /***************************************************************************
8237 JRA.
8238 The following code allows smbd to read a user defined share file.
8239 Yes, this is my intent. Yes, I'm comfortable with that...
8240
8241 THE FOLLOWING IS SECURITY CRITICAL CODE.
8242
8243 It washes your clothes, it cleans your house, it guards you while you sleep...
8244 Do not f%^k with it....
8245 ***************************************************************************/
8246
8247 #define MAX_USERSHARE_FILE_SIZE (10*1024)
8248
8249 /***************************************************************************
8250 Check allowed stat state of a usershare file.
8251 Ensure we print out who is dicking with us so the admin can
8252 get their sorry ass fired.
8253 ***************************************************************************/
8254
8255 static bool check_usershare_stat(const char *fname,
8256 const SMB_STRUCT_STAT *psbuf)
8257 {
8258 if (!S_ISREG(psbuf->st_ex_mode)) {
8259 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
8260 "not a regular file\n",
8261 fname, (unsigned int)psbuf->st_ex_uid ));
8262 return false;
8263 }
8264
8265 /* Ensure this doesn't have the other write bit set. */
8266 if (psbuf->st_ex_mode & S_IWOTH) {
8267 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
8268 "public write. Refusing to allow as a usershare file.\n",
8269 fname, (unsigned int)psbuf->st_ex_uid ));
8270 return false;
8271 }
8272
8273 /* Should be 10k or less. */
8274 if (psbuf->st_ex_size > MAX_USERSHARE_FILE_SIZE) {
8275 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
8276 "too large (%u) to be a user share file.\n",
8277 fname, (unsigned int)psbuf->st_ex_uid,
8278 (unsigned int)psbuf->st_ex_size ));
8279 return false;
8280 }
8281
8282 return true;
8283 }
8284
8285 /***************************************************************************
8286 Parse the contents of a usershare file.
8287 ***************************************************************************/
8288
8289 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
8290 SMB_STRUCT_STAT *psbuf,
8291 const char *servicename,
8292 int snum,
8293 char **lines,
8294 int numlines,
8295 char **pp_sharepath,
8296 char **pp_comment,
8297 char **pp_cp_servicename,
8298 struct security_descriptor **ppsd,
8299 bool *pallow_guest)
8300 {
8301 const char **prefixallowlist = lp_usershare_prefix_allow_list();
8302 const char **prefixdenylist = lp_usershare_prefix_deny_list();
8303 int us_vers;
8304 SMB_STRUCT_DIR *dp;
8305 SMB_STRUCT_STAT sbuf;
8306 char *sharepath = NULL;
8307 char *comment = NULL;
8308
8309 *pp_sharepath = NULL;
8310 *pp_comment = NULL;
8311
8312 *pallow_guest = false;
8313
8314 if (numlines < 4) {
8315 return USERSHARE_MALFORMED_FILE;
8316 }
8317
8318 if (strcmp(lines[0], "#VERSION 1") == 0) {
8319 us_vers = 1;
8320 } else if (strcmp(lines[0], "#VERSION 2") == 0) {
8321 us_vers = 2;
8322 if (numlines < 5) {
8323 return USERSHARE_MALFORMED_FILE;
8324 }
8325 } else {
8326 return USERSHARE_BAD_VERSION;
8327 }
8328
8329 if (strncmp(lines[1], "path=", 5) != 0) {
8330 return USERSHARE_MALFORMED_PATH;
8331 }
8332
8333 sharepath = talloc_strdup(ctx, &lines[1][5]);
8334 if (!sharepath) {
8335 return USERSHARE_POSIX_ERR;
8336 }
8337 trim_string(sharepath, " ", " ");
8338
8339 if (strncmp(lines[2], "comment=", 8) != 0) {
8340 return USERSHARE_MALFORMED_COMMENT_DEF;
8341 }
8342
8343 comment = talloc_strdup(ctx, &lines[2][8]);
8344 if (!comment) {
8345 return USERSHARE_POSIX_ERR;
8346 }
8347 trim_string(comment, " ", " ");
8348 trim_char(comment, '"', '"');
8349
8350 if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
8351 return USERSHARE_MALFORMED_ACL_DEF;
8352 }
8353
8354 if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
8355 return USERSHARE_ACL_ERR;
8356 }
8357
8358 if (us_vers == 2) {
8359 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
8360 return USERSHARE_MALFORMED_ACL_DEF;
8361 }
8362 if (lines[4][9] == 'y') {
8363 *pallow_guest = true;
8364 }
8365
8366 /* Backwards compatible extension to file version #2. */
8367 if (numlines > 5) {
8368 if (strncmp(lines[5], "sharename=", 10) != 0) {
8369 return USERSHARE_MALFORMED_SHARENAME_DEF;
8370 }
8371 if (!strequal(&lines[5][10], servicename)) {
8372 return USERSHARE_BAD_SHARENAME;
8373 }
8374 *pp_cp_servicename = talloc_strdup(ctx, &lines[5][10]);
8375 if (!*pp_cp_servicename) {
8376 return USERSHARE_POSIX_ERR;
8377 }
8378 }
8379 }
8380
8381 if (*pp_cp_servicename == NULL) {
8382 *pp_cp_servicename = talloc_strdup(ctx, servicename);
8383 if (!*pp_cp_servicename) {
8384 return USERSHARE_POSIX_ERR;
8385 }
8386 }
8387
8388 if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->szPath) == 0)) {
8389 /* Path didn't change, no checks needed. */
8390 *pp_sharepath = sharepath;
8391 *pp_comment = comment;
8392 return USERSHARE_OK;
8393 }
8394
8395 /* The path *must* be absolute. */
8396 if (sharepath[0] != '/') {
8397 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
8398 servicename, sharepath));
8399 return USERSHARE_PATH_NOT_ABSOLUTE;
8400 }
8401
8402 /* If there is a usershare prefix deny list ensure one of these paths
8403 doesn't match the start of the user given path. */
8404 if (prefixdenylist) {
8405 int i;
8406 for ( i=0; prefixdenylist[i]; i++ ) {
8407 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
8408 servicename, i, prefixdenylist[i], sharepath ));
8409 if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
8410 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
8411 "usershare prefix deny list entries.\n",
8412 servicename, sharepath));
8413 return USERSHARE_PATH_IS_DENIED;
8414 }
8415 }
8416 }
8417
8418 /* If there is a usershare prefix allow list ensure one of these paths
8419 does match the start of the user given path. */
8420
8421 if (prefixallowlist) {
8422 int i;
8423 for ( i=0; prefixallowlist[i]; i++ ) {
8424 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
8425 servicename, i, prefixallowlist[i], sharepath ));
8426 if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
8427 break;
8428 }
8429 }
8430 if (prefixallowlist[i] == NULL) {
8431 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
8432 "usershare prefix allow list entries.\n",
8433 servicename, sharepath));
8434 return USERSHARE_PATH_NOT_ALLOWED;
8435 }
8436 }
8437
8438 /* Ensure this is pointing to a directory. */
8439 dp = sys_opendir(sharepath);
8440
8441 if (!dp) {
8442 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
8443 servicename, sharepath));
8444 return USERSHARE_PATH_NOT_DIRECTORY;
8445 }
8446
8447 /* Ensure the owner of the usershare file has permission to share
8448 this directory. */
8449
8450 if (sys_stat(sharepath, &sbuf, false) == -1) {
8451 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
8452 servicename, sharepath, strerror(errno) ));
8453 sys_closedir(dp);
8454 return USERSHARE_POSIX_ERR;
8455 }
8456
8457 sys_closedir(dp);
8458
8459 if (!S_ISDIR(sbuf.st_ex_mode)) {
8460 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
8461 servicename, sharepath ));
8462 return USERSHARE_PATH_NOT_DIRECTORY;
8463 }
8464
8465 /* Check if sharing is restricted to owner-only. */
8466 /* psbuf is the stat of the usershare definition file,
8467 sbuf is the stat of the target directory to be shared. */
8468
8469 if (lp_usershare_owner_only()) {
8470 /* root can share anything. */
8471 if ((psbuf->st_ex_uid != 0) && (sbuf.st_ex_uid != psbuf->st_ex_uid)) {
8472 return USERSHARE_PATH_NOT_ALLOWED;
8473 }
8474 }
8475
8476 *pp_sharepath = sharepath;
8477 *pp_comment = comment;
8478 return USERSHARE_OK;
8479 }
8480
8481 /***************************************************************************
8482 Deal with a usershare file.
8483 Returns:
8484 >= 0 - snum
8485 -1 - Bad name, invalid contents.
8486 - service name already existed and not a usershare, problem
8487 with permissions to share directory etc.
8488 ***************************************************************************/
8489
8490 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
8491 {
8492 SMB_STRUCT_STAT sbuf;
8493 SMB_STRUCT_STAT lsbuf;
8494 char *fname = NULL;
8495 char *sharepath = NULL;
8496 char *comment = NULL;
8497 char *cp_service_name = NULL;
8498 char **lines = NULL;
8499 int numlines = 0;
8500 int fd = -1;
8501 int iService = -1;
8502 TALLOC_CTX *ctx = talloc_stackframe();
8503 struct security_descriptor *psd = NULL;
8504 bool guest_ok = false;
8505 char *canon_name = NULL;
8506 bool added_service = false;
8507 int ret = -1;
8508
8509 /* Ensure share name doesn't contain invalid characters. */
8510 if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
8511 DEBUG(0,("process_usershare_file: share name %s contains "
8512 "invalid characters (any of %s)\n",
8513 file_name, INVALID_SHARENAME_CHARS ));
8514 goto out;
8515 }
8516
8517 canon_name = canonicalize_servicename(ctx, file_name);
8518 if (!canon_name) {
8519 goto out;
8520 }
8521
8522 fname = talloc_asprintf(ctx, "%s/%s", dir_name, file_name);
8523 if (!fname) {
8524 goto out;
8525 }
8526
8527 /* Minimize the race condition by doing an lstat before we
8528 open and fstat. Ensure this isn't a symlink link. */
8529
8530 if (sys_lstat(fname, &lsbuf, false) != 0) {
8531 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
8532 fname, strerror(errno) ));
8533 goto out;
8534 }
8535
8536 /* This must be a regular file, not a symlink, directory or
8537 other strange filetype. */
8538 if (!check_usershare_stat(fname, &lsbuf)) {
8539 goto out;
8540 }
8541
8542 {
8543 TDB_DATA data = dbwrap_fetch_bystring(
8544 ServiceHash, canon_name, canon_name);
8545
8546 iService = -1;
8547
8548 if ((data.dptr != NULL) && (data.dsize == sizeof(iService))) {
8549 iService = *(int *)data.dptr;
8550 }
8551 }
8552
8553 if (iService != -1 &&
8554 timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
8555 &lsbuf.st_ex_mtime) == 0) {
8556 /* Nothing changed - Mark valid and return. */
8557 DEBUG(10,("process_usershare_file: service %s not changed.\n",
8558 canon_name ));
8559 ServicePtrs[iService]->usershare = USERSHARE_VALID;
8560 ret = iService;
8561 goto out;
8562 }
8563
8564 /* Try and open the file read only - no symlinks allowed. */
8565 #ifdef O_NOFOLLOW
8566 fd = sys_open(fname, O_RDONLY|O_NOFOLLOW, 0);
8567 #else
8568 fd = sys_open(fname, O_RDONLY, 0);
8569 #endif
8570
8571 if (fd == -1) {
8572 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
8573 fname, strerror(errno) ));
8574 goto out;
8575 }
8576
8577 /* Now fstat to be *SURE* it's a regular file. */
8578 if (sys_fstat(fd, &sbuf, false) != 0) {
8579 close(fd);
8580 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
8581 fname, strerror(errno) ));
8582 goto out;
8583 }
8584
8585 /* Is it the same dev/inode as was lstated ? */
8586 if (lsbuf.st_ex_dev != sbuf.st_ex_dev || lsbuf.st_ex_ino != sbuf.st_ex_ino) {
8587 close(fd);
8588 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
8589 "Symlink spoofing going on ?\n", fname ));
8590 goto out;
8591 }
8592
8593 /* This must be a regular file, not a symlink, directory or
8594 other strange filetype. */
8595 if (!check_usershare_stat(fname, &sbuf)) {
8596 goto out;
8597 }
8598
8599 lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE, NULL);
8600
8601 close(fd);
8602 if (lines == NULL) {
8603 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
8604 fname, (unsigned int)sbuf.st_ex_uid ));
8605 goto out;
8606 }
8607
8608 if (parse_usershare_file(ctx, &sbuf, file_name,
8609 iService, lines, numlines, &sharepath,
8610 &comment, &cp_service_name,
8611 &psd, &guest_ok) != USERSHARE_OK) {
8612 goto out;
8613 }
8614
8615 /* Everything ok - add the service possibly using a template. */
8616 if (iService < 0) {
8617 const struct loadparm_service *sp = &sDefault;
8618 if (snum_template != -1) {
8619 sp = ServicePtrs[snum_template];
8620 }
8621
8622 if ((iService = add_a_service(sp, cp_service_name)) < 0) {
8623 DEBUG(0, ("process_usershare_file: Failed to add "
8624 "new service %s\n", cp_service_name));
8625 goto out;
8626 }
8627
8628 added_service = true;
8629
8630 /* Read only is controlled by usershare ACL below. */
8631 ServicePtrs[iService]->bRead_only = false;
8632 }
8633
8634 /* Write the ACL of the new/modified share. */
8635 if (!set_share_security(canon_name, psd)) {
8636 DEBUG(0, ("process_usershare_file: Failed to set share "
8637 "security for user share %s\n",
8638 canon_name ));
8639 goto out;
8640 }
8641
8642 /* If from a template it may be marked invalid. */
8643 ServicePtrs[iService]->valid = true;
8644
8645 /* Set the service as a valid usershare. */
8646 ServicePtrs[iService]->usershare = USERSHARE_VALID;
8647
8648 /* Set guest access. */
8649 if (lp_usershare_allow_guests()) {
8650 ServicePtrs[iService]->bGuest_ok = guest_ok;
8651 }
8652
8653 /* And note when it was loaded. */
8654 ServicePtrs[iService]->usershare_last_mod = sbuf.st_ex_mtime;
8655 string_set(&ServicePtrs[iService]->szPath, sharepath);
8656 string_set(&ServicePtrs[iService]->comment, comment);
8657
8658 ret = iService;
8659
8660 out:
8661
8662 if (ret == -1 && iService != -1 && added_service) {
8663 lp_remove_service(iService);
8664 }
8665
8666 TALLOC_FREE(lines);
8667 TALLOC_FREE(ctx);
8668 return ret;
8669 }
8670
8671 /***************************************************************************
8672 Checks if a usershare entry has been modified since last load.
8673 ***************************************************************************/
8674
8675 static bool usershare_exists(int iService, struct timespec *last_mod)
8676 {
8677 SMB_STRUCT_STAT lsbuf;
8678 const char *usersharepath = Globals.szUsersharePath;
8679 char *fname;
8680
8681 if (asprintf(&fname, "%s/%s",
8682 usersharepath,
8683 ServicePtrs[iService]->szService) < 0) {
8684 return false;
8685 }
8686
8687 if (sys_lstat(fname, &lsbuf, false) != 0) {
8688 SAFE_FREE(fname);
8689 return false;
8690 }
8691
8692 if (!S_ISREG(lsbuf.st_ex_mode)) {
8693 SAFE_FREE(fname);
8694 return false;
8695 }
8696
8697 SAFE_FREE(fname);
8698 *last_mod = lsbuf.st_ex_mtime;
8699 return true;
8700 }
8701
8702 /***************************************************************************
8703 Load a usershare service by name. Returns a valid servicenumber or -1.
8704 ***************************************************************************/
8705
8706 int load_usershare_service(const char *servicename)
8707 {
8708 SMB_STRUCT_STAT sbuf;
8709 const char *usersharepath = Globals.szUsersharePath;
8710 int max_user_shares = Globals.iUsershareMaxShares;
8711 int snum_template = -1;
8712
8713 if (*usersharepath == 0 || max_user_shares == 0) {
8714 return -1;
8715 }
8716
8717 if (sys_stat(usersharepath, &sbuf, false) != 0) {
8718 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
8719 usersharepath, strerror(errno) ));
8720 return -1;
8721 }
8722
8723 if (!S_ISDIR(sbuf.st_ex_mode)) {
8724 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
8725 usersharepath ));
8726 return -1;
8727 }
8728
8729 /*
8730 * This directory must be owned by root, and have the 't' bit set.
8731 * It also must not be writable by "other".
8732 */
8733
8734 #ifdef S_ISVTX
8735 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
8736 #else
8737 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
8738 #endif
8739 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
8740 "or does not have the sticky bit 't' set or is writable by anyone.\n",
8741 usersharepath ));
8742 return -1;
8743 }
8744
8745 /* Ensure the template share exists if it's set. */
8746 if (Globals.szUsershareTemplateShare[0]) {
8747 /* We can't use lp_servicenumber here as we are recommending that
8748 template shares have -valid=false set. */
8749 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
8750 if (ServicePtrs[snum_template]->szService &&
8751 strequal(ServicePtrs[snum_template]->szService,
8752 Globals.szUsershareTemplateShare)) {
8753 break;
8754 }
8755 }
8756
8757 if (snum_template == -1) {
8758 DEBUG(0,("load_usershare_service: usershare template share %s "
8759 "does not exist.\n",
8760 Globals.szUsershareTemplateShare ));
8761 return -1;
8762 }
8763 }
8764
8765 return process_usershare_file(usersharepath, servicename, snum_template);
8766 }
8767
8768 /***************************************************************************
8769 Load all user defined shares from the user share directory.
8770 We only do this if we're enumerating the share list.
8771 This is the function that can delete usershares that have
8772 been removed.
8773 ***************************************************************************/
8774
8775 int load_usershare_shares(struct smbd_server_connection *sconn)
8776 {
8777 SMB_STRUCT_DIR *dp;
8778 SMB_STRUCT_STAT sbuf;
8779 SMB_STRUCT_DIRENT *de;
8780 int num_usershares = 0;
8781 int max_user_shares = Globals.iUsershareMaxShares;
8782 unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
8783 unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
8784 unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
8785 int iService;
8786 int snum_template = -1;
8787 const char *usersharepath = Globals.szUsersharePath;
8788 int ret = lp_numservices();
8789
8790 if (max_user_shares == 0 || *usersharepath == '\0') {
8791 return lp_numservices();
8792 }
8793
8794 if (sys_stat(usersharepath, &sbuf, false) != 0) {
8795 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
8796 usersharepath, strerror(errno) ));
8797 return ret;
8798 }
8799
8800 /*
8801 * This directory must be owned by root, and have the 't' bit set.
8802 * It also must not be writable by "other".
8803 */
8804
8805 #ifdef S_ISVTX
8806 if (sbuf.st_ex_uid != 0 || !(sbuf.st_ex_mode & S_ISVTX) || (sbuf.st_ex_mode & S_IWOTH)) {
8807 #else
8808 if (sbuf.st_ex_uid != 0 || (sbuf.st_ex_mode & S_IWOTH)) {
8809 #endif
8810 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
8811 "or does not have the sticky bit 't' set or is writable by anyone.\n",
8812 usersharepath ));
8813 return ret;
8814 }
8815
8816 /* Ensure the template share exists if it's set. */
8817 if (Globals.szUsershareTemplateShare[0]) {
8818 /* We can't use lp_servicenumber here as we are recommending that
8819 template shares have -valid=false set. */
8820 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
8821 if (ServicePtrs[snum_template]->szService &&
8822 strequal(ServicePtrs[snum_template]->szService,
8823 Globals.szUsershareTemplateShare)) {
8824 break;
8825 }
8826 }
8827
8828 if (snum_template == -1) {
8829 DEBUG(0,("load_usershare_shares: usershare template share %s "
8830 "does not exist.\n",
8831 Globals.szUsershareTemplateShare ));
8832 return ret;
8833 }
8834 }
8835
8836 /* Mark all existing usershares as pending delete. */
8837 for (iService = iNumServices - 1; iService >= 0; iService--) {
8838 if (VALID(iService) && ServicePtrs[iService]->usershare) {
8839 ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
8840 }
8841 }
8842
8843 dp = sys_opendir(usersharepath);
8844 if (!dp) {
8845 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
8846 usersharepath, strerror(errno) ));
8847 return ret;
8848 }
8849
8850 for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
8851 (de = sys_readdir(dp));
8852 num_dir_entries++ ) {
8853 int r;
8854 const char *n = de->d_name;
8855
8856 /* Ignore . and .. */
8857 if (*n == '.') {
8858 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
8859 continue;
8860 }
8861 }
8862
8863 if (n[0] == ':') {
8864 /* Temporary file used when creating a share. */
8865 num_tmp_dir_entries++;
8866 }
8867
8868 /* Allow 20% tmp entries. */
8869 if (num_tmp_dir_entries > allowed_tmp_entries) {
8870 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
8871 "in directory %s\n",
8872 num_tmp_dir_entries, usersharepath));
8873 break;
8874 }
8875
8876 r = process_usershare_file(usersharepath, n, snum_template);
8877 if (r == 0) {
8878 /* Update the services count. */
8879 num_usershares++;
8880 if (num_usershares >= max_user_shares) {
8881 DEBUG(0,("load_usershare_shares: max user shares reached "
8882 "on file %s in directory %s\n",
8883 n, usersharepath ));
8884 break;
8885 }
8886 } else if (r == -1) {
8887 num_bad_dir_entries++;
8888 }
8889
8890 /* Allow 20% bad entries. */
8891 if (num_bad_dir_entries > allowed_bad_entries) {
8892 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
8893 "in directory %s\n",
8894 num_bad_dir_entries, usersharepath));
8895 break;
8896 }
8897
8898 /* Allow 20% bad entries. */
8899 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
8900 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
8901 "in directory %s\n",
8902 num_dir_entries, usersharepath));
8903 break;
8904 }
8905 }
8906
8907 sys_closedir(dp);
8908
8909 /* Sweep through and delete any non-refreshed usershares that are
8910 not currently in use. */
8911 for (iService = iNumServices - 1; iService >= 0; iService--) {
8912 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
8913 if (conn_snum_used(sconn, iService)) {
8914 continue;
8915 }
8916 /* Remove from the share ACL db. */
8917 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
8918 lp_servicename(iService) ));
8919 delete_share_security(lp_servicename(iService));
8920 free_service_byindex(iService);
8921 }
8922 }
8923
8924 return lp_numservices();
8925 }
8926
8927 /********************************************************
8928 Destroy global resources allocated in this file
8929 ********************************************************/
8930
8931 void gfree_loadparm(void)
8932 {
8933 int i;
8934
8935 free_file_list();
8936
8937 /* Free resources allocated to services */
8938
8939 for ( i = 0; i < iNumServices; i++ ) {
8940 if ( VALID(i) ) {
8941 free_service_byindex(i);
8942 }
8943 }
8944
8945 SAFE_FREE( ServicePtrs );
8946 iNumServices = 0;
8947
8948 /* Now release all resources allocated to global
8949 parameters and the default service */
8950
8951 free_global_parameters();
8952 }
8953
8954
8955 /***************************************************************************
8956 Allow client apps to specify that they are a client
8957 ***************************************************************************/
8958 static void lp_set_in_client(bool b)
8959 {
8960 in_client = b;
8961 }
8962
8963
8964 /***************************************************************************
8965 Determine if we're running in a client app
8966 ***************************************************************************/
8967 static bool lp_is_in_client(void)
8968 {
8969 return in_client;
8970 }
8971
8972 /***************************************************************************
8973 Load the services array from the services file. Return true on success,
8974 false on failure.
8975 ***************************************************************************/
8976
8977 static bool lp_load_ex(const char *pszFname,
8978 bool global_only,
8979 bool save_defaults,
8980 bool add_ipc,
8981 bool initialize_globals,
8982 bool allow_include_registry,
8983 bool load_all_shares)
8984 {
8985 char *n2 = NULL;
8986 bool bRetval;
8987
8988 bRetval = false;
8989
8990 DEBUG(3, ("lp_load_ex: refreshing parameters\n"));
8991
8992 bInGlobalSection = true;
8993 bGlobalOnly = global_only;
8994 bAllowIncludeRegistry = allow_include_registry;
8995
8996 init_globals(initialize_globals);
8997
8998 free_file_list();
8999
9000 if (save_defaults) {
9001 init_locals();
9002 lp_save_defaults();
9003 }
9004
9005 if (!initialize_globals) {
9006 free_param_opts(&Globals.param_opt);
9007 apply_lp_set_cmdline();
9008 }
9009
9010 lp_do_parameter(-1, "idmap config * : backend", Globals.szIdmapBackend);
9011
9012 /* We get sections first, so have to start 'behind' to make up */
9013 iServiceIndex = -1;
9014
9015 if (lp_config_backend_is_file()) {
9016 n2 = talloc_sub_basic(talloc_tos(), get_current_username(),
9017 current_user_info.domain,
9018 pszFname);
9019 if (!n2) {
9020 smb_panic("lp_load_ex: out of memory");
9021 }
9022
9023 add_to_file_list(pszFname, n2);
9024
9025 bRetval = pm_process(n2, do_section, do_parameter, NULL);
9026 TALLOC_FREE(n2);
9027
9028 /* finish up the last section */
9029 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
9030 if (bRetval) {
9031 if (iServiceIndex >= 0) {
9032 bRetval = service_ok(iServiceIndex);
9033 }
9034 }
9035
9036 if (lp_config_backend_is_registry()) {
9037 /* config backend changed to registry in config file */
9038 /*
9039 * We need to use this extra global variable here to
9040 * survive restart: init_globals uses this as a default
9041 * for ConfigBackend. Otherwise, init_globals would
9042 * send us into an endless loop here.
9043 */
9044 config_backend = CONFIG_BACKEND_REGISTRY;
9045 /* start over */
9046 DEBUG(1, ("lp_load_ex: changing to config backend "
9047 "registry\n"));
9048 init_globals(true);
9049 lp_kill_all_services();
9050 return lp_load_ex(pszFname, global_only, save_defaults,
9051 add_ipc, initialize_globals,
9052 allow_include_registry,
9053 load_all_shares);
9054 }
9055 } else if (lp_config_backend_is_registry()) {
9056 bRetval = process_registry_globals();
9057 } else {
9058 DEBUG(0, ("Illegal config backend given: %d\n",
9059 lp_config_backend()));
9060 bRetval = false;
9061 }
9062
9063 if (bRetval && lp_registry_shares()) {
9064 if (load_all_shares) {
9065 bRetval = process_registry_shares();
9066 } else {
9067 bRetval = reload_registry_shares();
9068 }
9069 }
9070
9071 lp_add_auto_services(lp_auto_services());
9072
9073 if (add_ipc) {
9074 /* When 'restrict anonymous = 2' guest connections to ipc$
9075 are denied */
9076 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
9077 if ( lp_enable_asu_support() ) {
9078 lp_add_ipc("ADMIN$", false);
9079 }
9080 }
9081
9082 set_server_role();
9083 set_allowed_client_auth();
9084
9085 if (lp_security() == SEC_SHARE) {
9086 DEBUG(1, ("WARNING: The security=share option is deprecated\n"));
9087 } else if (lp_security() == SEC_SERVER) {
9088 DEBUG(1, ("WARNING: The security=server option is deprecated\n"));
9089 }
9090
9091 if (lp_security() == SEC_ADS && strchr(lp_passwordserver(), ':')) {
9092 DEBUG(1, ("WARNING: The optional ':port' in password server = %s is deprecated\n",
9093 lp_passwordserver()));
9094 }
9095
9096 bLoaded = true;
9097
9098 /* Now we check bWINSsupport and set szWINSserver to 127.0.0.1 */
9099 /* if bWINSsupport is true and we are in the client */
9100 if (lp_is_in_client() && Globals.bWINSsupport) {
9101 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
9102 }
9103
9104 init_iconv();
9105
9106 fault_configure(smb_panic_s3);
9107
9108 bAllowIncludeRegistry = true;
9109
9110 return (bRetval);
9111 }
9112
9113 bool lp_load(const char *pszFname,
9114 bool global_only,
9115 bool save_defaults,
9116 bool add_ipc,
9117 bool initialize_globals)
9118 {
9119 return lp_load_ex(pszFname,
9120 global_only,
9121 save_defaults,
9122 add_ipc,
9123 initialize_globals,
9124 true, /* allow_include_registry */
9125 false); /* load_all_shares*/
9126 }
9127
9128 bool lp_load_initial_only(const char *pszFname)
9129 {
9130 return lp_load_ex(pszFname,
9131 true, /* global only */
9132 false, /* save_defaults */
9133 false, /* add_ipc */
9134 true, /* initialize_globals */
9135 false, /* allow_include_registry */
9136 false); /* load_all_shares*/
9137 }
9138
9139 /**
9140 * most common lp_load wrapper, loading only the globals
9141 */
9142 bool lp_load_global(const char *file_name)
9143 {
9144 return lp_load_ex(file_name,
9145 true, /* global_only */
9146 false, /* save_defaults */
9147 false, /* add_ipc */
9148 true, /* initialize_globals */
9149 true, /* allow_include_registry */
9150 false); /* load_all_shares*/
9151 }
9152
9153 /**
9154 * lp_load wrapper, especially for clients
9155 */
9156 bool lp_load_client(const char *file_name)
9157 {
9158 lp_set_in_client(true);
9159
9160 return lp_load_global(file_name);
9161 }
9162
9163 /**
9164 * lp_load wrapper, loading only globals, but intended
9165 * for subsequent calls, not reinitializing the globals
9166 * to default values
9167 */
9168 bool lp_load_global_no_reinit(const char *file_name)
9169 {
9170 return lp_load_ex(file_name,
9171 true, /* global_only */
9172 false, /* save_defaults */
9173 false, /* add_ipc */
9174 false, /* initialize_globals */
9175 true, /* allow_include_registry */
9176 false); /* load_all_shares*/
9177 }
9178
9179 /**
9180 * lp_load wrapper, especially for clients, no reinitialization
9181 */
9182 bool lp_load_client_no_reinit(const char *file_name)
9183 {
9184 lp_set_in_client(true);
9185
9186 return lp_load_global_no_reinit(file_name);
9187 }
9188
9189 bool lp_load_with_registry_shares(const char *pszFname,
9190 bool global_only,
9191 bool save_defaults,
9192 bool add_ipc,
9193 bool initialize_globals)
9194 {
9195 return lp_load_ex(pszFname,
9196 global_only,
9197 save_defaults,
9198 add_ipc,
9199 initialize_globals,
9200 true, /* allow_include_registry */
9201 true); /* load_all_shares*/
9202 }
9203
9204 /***************************************************************************
9205 Return the max number of services.
9206 ***************************************************************************/
9207
9208 int lp_numservices(void)
9209 {
9210 return (iNumServices);
9211 }
9212
9213 /***************************************************************************
9214 Display the contents of the services array in human-readable form.
9215 ***************************************************************************/
9216
9217 void lp_dump(FILE *f, bool show_defaults, int maxtoprint)
9218 {
9219 int iService;
9220
9221 if (show_defaults)
9222 defaults_saved = false;
9223
9224 dump_globals(f);
9225
9226 dump_a_service(&sDefault, f);
9227
9228 for (iService = 0; iService < maxtoprint; iService++) {
9229 fprintf(f,"\n");
9230 lp_dump_one(f, show_defaults, iService);
9231 }
9232 }
9233
9234 /***************************************************************************
9235 Display the contents of one service in human-readable form.
9236 ***************************************************************************/
9237
9238 void lp_dump_one(FILE * f, bool show_defaults, int snum)
9239 {
9240 if (VALID(snum)) {
9241 if (ServicePtrs[snum]->szService[0] == '\0')
9242 return;
9243 dump_a_service(ServicePtrs[snum], f);
9244 }
9245 }
9246
9247 /***************************************************************************
9248 Return the number of the service with the given name, or -1 if it doesn't
9249 exist. Note that this is a DIFFERENT ANIMAL from the internal function
9250 getservicebyname()! This works ONLY if all services have been loaded, and
9251 does not copy the found service.
9252 ***************************************************************************/
9253
9254 int lp_servicenumber(const char *pszServiceName)
9255 {
9256 int iService;
9257 fstring serviceName;
9258
9259 if (!pszServiceName) {
9260 return GLOBAL_SECTION_SNUM;
9261 }
9262
9263 for (iService = iNumServices - 1; iService >= 0; iService--) {
9264 if (VALID(iService) && ServicePtrs[iService]->szService) {
9265 /*
9266 * The substitution here is used to support %U is
9267 * service names
9268 */
9269 fstrcpy(serviceName, ServicePtrs[iService]->szService);
9270 standard_sub_basic(get_current_username(),
9271 current_user_info.domain,
9272 serviceName,sizeof(serviceName));
9273 if (strequal(serviceName, pszServiceName)) {
9274 break;
9275 }
9276 }
9277 }
9278
9279 if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
9280 struct timespec last_mod;
9281
9282 if (!usershare_exists(iService, &last_mod)) {
9283 /* Remove the share security tdb entry for it. */
9284 delete_share_security(lp_servicename(iService));
9285 /* Remove it from the array. */
9286 free_service_byindex(iService);
9287 /* Doesn't exist anymore. */
9288 return GLOBAL_SECTION_SNUM;
9289 }
9290
9291 /* Has it been modified ? If so delete and reload. */
9292 if (timespec_compare(&ServicePtrs[iService]->usershare_last_mod,
9293 &last_mod) < 0) {
9294 /* Remove it from the array. */
9295 free_service_byindex(iService);
9296 /* and now reload it. */
9297 iService = load_usershare_service(pszServiceName);
9298 }
9299 }
9300
9301 if (iService < 0) {
9302 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
9303 return GLOBAL_SECTION_SNUM;
9304 }
9305
9306 return (iService);
9307 }
9308
9309 bool share_defined(const char *service_name)
9310 {
9311 return (lp_servicenumber(service_name) != -1);
9312 }
9313
9314 /*******************************************************************
9315 A useful volume label function.
9316 ********************************************************************/
9317
9318 const char *volume_label(int snum)
9319 {
9320 char *ret;
9321 const char *label = lp_volume(snum);
9322 if (!*label) {
9323 label = lp_servicename(snum);
9324 }
9325
9326 /* This returns a 33 byte guarenteed null terminated string. */
9327 ret = talloc_strndup(talloc_tos(), label, 32);
9328 if (!ret) {
9329 return "";
9330 }
9331 return ret;
9332 }
9333
9334 /*******************************************************************
9335 Get the default server type we will announce as via nmbd.
9336 ********************************************************************/
9337
9338 int lp_default_server_announce(void)
9339 {
9340 int default_server_announce = 0;
9341 default_server_announce |= SV_TYPE_WORKSTATION;
9342 default_server_announce |= SV_TYPE_SERVER;
9343 default_server_announce |= SV_TYPE_SERVER_UNIX;
9344
9345 /* note that the flag should be set only if we have a
9346 printer service but nmbd doesn't actually load the
9347 services so we can't tell --jerry */
9348
9349 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
9350
9351 default_server_announce |= SV_TYPE_SERVER_NT;
9352 default_server_announce |= SV_TYPE_NT;
9353
9354 switch (lp_server_role()) {
9355 case ROLE_DOMAIN_MEMBER:
9356 default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
9357 break;
9358 case ROLE_DOMAIN_PDC:
9359 default_server_announce |= SV_TYPE_DOMAIN_CTRL;
9360 break;
9361 case ROLE_DOMAIN_BDC:
9362 default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
9363 break;
9364 case ROLE_STANDALONE:
9365 default:
9366 break;
9367 }
9368 if (lp_time_server())
9369 default_server_announce |= SV_TYPE_TIME_SOURCE;
9370
9371 if (lp_host_msdfs())
9372 default_server_announce |= SV_TYPE_DFS_SERVER;
9373
9374 return default_server_announce;
9375 }
9376
9377 /***********************************************************
9378 If we are PDC then prefer us as DMB
9379 ************************************************************/
9380
9381 bool lp_domain_master(void)
9382 {
9383 if (Globals.iDomainMaster == Auto)
9384 return (lp_server_role() == ROLE_DOMAIN_PDC);
9385
9386 return (bool)Globals.iDomainMaster;
9387 }
9388
9389 /***********************************************************
9390 If we are PDC then prefer us as DMB
9391 ************************************************************/
9392
9393 bool lp_domain_master_true_or_auto(void)
9394 {
9395 if (Globals.iDomainMaster) /* auto or yes */
9396 return true;
9397
9398 return false;
9399 }
9400
9401 /***********************************************************
9402 If we are DMB then prefer us as LMB
9403 ************************************************************/
9404
9405 bool lp_preferred_master(void)
9406 {
9407 if (Globals.iPreferredMaster == Auto)
9408 return (lp_local_master() && lp_domain_master());
9409
9410 return (bool)Globals.iPreferredMaster;
9411 }
9412
9413 /*******************************************************************
9414 Remove a service.
9415 ********************************************************************/
9416
9417 void lp_remove_service(int snum)
9418 {
9419 ServicePtrs[snum]->valid = false;
9420 invalid_services[num_invalid_services++] = snum;
9421 }
9422
9423 /*******************************************************************
9424 Copy a service.
9425 ********************************************************************/
9426
9427 void lp_copy_service(int snum, const char *new_name)
9428 {
9429 do_section(new_name, NULL);
9430 if (snum >= 0) {
9431 snum = lp_servicenumber(new_name);
9432 if (snum >= 0)
9433 lp_do_parameter(snum, "copy", lp_servicename(snum));
9434 }
9435 }
9436
9437
9438 /***********************************************************
9439 Set the global name resolution order (used in smbclient).
9440 ************************************************************/
9441
9442 void lp_set_name_resolve_order(const char *new_order)
9443 {
9444 string_set(&Globals.szNameResolveOrder, new_order);
9445 }
9446
9447 const char *lp_printername(int snum)
9448 {
9449 const char *ret = lp__printername(snum);
9450 if (ret == NULL || (ret != NULL && *ret == '\0'))
9451 ret = lp_const_servicename(snum);
9452
9453 return ret;
9454 }
9455
9456
9457 /***********************************************************
9458 Allow daemons such as winbindd to fix their logfile name.
9459 ************************************************************/
9460
9461 void lp_set_logfile(const char *name)
9462 {
9463 string_set(&Globals.szLogFile, name);
9464 debug_set_logfile(name);
9465 }
9466
9467 /*******************************************************************
9468 Return the max print jobs per queue.
9469 ********************************************************************/
9470
9471 int lp_maxprintjobs(int snum)
9472 {
9473 int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
9474 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
9475 maxjobs = PRINT_MAX_JOBID - 1;
9476
9477 return maxjobs;
9478 }
9479
9480 const char *lp_printcapname(void)
9481 {
9482 if ((Globals.szPrintcapname != NULL) &&
9483 (Globals.szPrintcapname[0] != '\0'))
9484 return Globals.szPrintcapname;
9485
9486 if (sDefault.iPrinting == PRINT_CUPS) {
9487 #ifdef HAVE_CUPS
9488 return "cups";
9489 #else
9490 return "lpstat";
9491 #endif
9492 }
9493
9494 if (sDefault.iPrinting == PRINT_BSD)
9495 return "/etc/printcap";
9496
9497 return PRINTCAP_NAME;
9498 }
9499
9500 static uint32 spoolss_state;
9501
9502 bool lp_disable_spoolss( void )
9503 {
9504 if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
9505 spoolss_state = _lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
9506
9507 return spoolss_state == SVCCTL_STOPPED ? true : false;
9508 }
9509
9510 void lp_set_spoolss_state( uint32 state )
9511 {
9512 SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
9513
9514 spoolss_state = state;
9515 }
9516
9517 uint32 lp_get_spoolss_state( void )
9518 {
9519 return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
9520 }
9521
9522 /*******************************************************************
9523 Ensure we don't use sendfile if server smb signing is active.
9524 ********************************************************************/
9525
9526 bool lp_use_sendfile(int snum, struct smb_signing_state *signing_state)
9527 {
9528 bool sign_active = false;
9529
9530 /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
9531 if (get_Protocol() < PROTOCOL_NT1) {
9532 return false;
9533 }
9534 if (signing_state) {
9535 sign_active = smb_signing_is_active(signing_state);
9536 }
9537 return (lp__use_sendfile(snum) &&
9538 (get_remote_arch() != RA_WIN95) &&
9539 !sign_active);
9540 }
9541
9542 /*******************************************************************
9543 Turn off sendfile if we find the underlying OS doesn't support it.
9544 ********************************************************************/
9545
9546 void set_use_sendfile(int snum, bool val)
9547 {
9548 if (LP_SNUM_OK(snum))
9549 ServicePtrs[snum]->bUseSendfile = val;
9550 else
9551 sDefault.bUseSendfile = val;
9552 }
9553
9554 /*******************************************************************
9555 Turn off storing DOS attributes if this share doesn't support it.
9556 ********************************************************************/
9557
9558 void set_store_dos_attributes(int snum, bool val)
9559 {
9560 if (!LP_SNUM_OK(snum))
9561 return;
9562 ServicePtrs[(snum)]->bStoreDosAttributes = val;
9563 }
9564
9565 void lp_set_mangling_method(const char *new_method)
9566 {
9567 string_set(&Globals.szManglingMethod, new_method);
9568 }
9569
9570 /*******************************************************************
9571 Global state for POSIX pathname processing.
9572 ********************************************************************/
9573
9574 static bool posix_pathnames;
9575
9576 bool lp_posix_pathnames(void)
9577 {
9578 return posix_pathnames;
9579 }
9580
9581 /*******************************************************************
9582 Change everything needed to ensure POSIX pathname processing (currently
9583 not much).
9584 ********************************************************************/
9585
9586 void lp_set_posix_pathnames(void)
9587 {
9588 posix_pathnames = true;
9589 }
9590
9591 /*******************************************************************
9592 Global state for POSIX lock processing - CIFS unix extensions.
9593 ********************************************************************/
9594
9595 bool posix_default_lock_was_set;
9596 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
9597
9598 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
9599 {
9600 if (posix_default_lock_was_set) {
9601 return posix_cifsx_locktype;
9602 } else {
9603 return fsp->posix_open ? POSIX_LOCK : WINDOWS_LOCK;
9604 }
9605 }
9606
9607 /*******************************************************************
9608 ********************************************************************/
9609
9610 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
9611 {
9612 posix_default_lock_was_set = true;
9613 posix_cifsx_locktype = val;
9614 }
9615
9616 int lp_min_receive_file_size(void)
9617 {
9618 if (Globals.iminreceivefile < 0) {
9619 return 0;
9620 }
9621 return MIN(Globals.iminreceivefile, BUFFER_SIZE);
9622 }
9623
9624 /*******************************************************************
9625 If socket address is an empty character string, it is necessary to
9626 define it as "0.0.0.0".
9627 ********************************************************************/
9628
9629 const char *lp_socket_address(void)
9630 {
9631 char *sock_addr = Globals.szSocketAddress;
9632
9633 if (sock_addr[0] == '\0'){
9634 string_set(&Globals.szSocketAddress, "0.0.0.0");
9635 }
9636 return Globals.szSocketAddress;
9637 }
9638
9639 /*******************************************************************
9640 Safe wide links checks.
9641 This helper function always verify the validity of wide links,
9642 even after a configuration file reload.
9643 ********************************************************************/
9644
9645 static bool lp_widelinks_internal(int snum)
9646 {
9647 return (bool)(LP_SNUM_OK(snum)? ServicePtrs[(snum)]->bWidelinks :
9648 sDefault.bWidelinks);
9649 }
9650
9651 void widelinks_warning(int snum)
9652 {
9653 if (lp_allow_insecure_widelinks()) {
9654 return;
9655 }
9656
9657 if (lp_unix_extensions() && lp_widelinks_internal(snum)) {
9658 DEBUG(0,("Share '%s' has wide links and unix extensions enabled. "
9659 "These parameters are incompatible. "
9660 "Wide links will be disabled for this share.\n",
9661 lp_servicename(snum) ));
9662 }
9663 }
9664
9665 bool lp_widelinks(int snum)
9666 {
9667 /* wide links is always incompatible with unix extensions */
9668 if (lp_unix_extensions()) {
9669 /*
9670 * Unless we have "allow insecure widelinks"
9671 * turned on.
9672 */
9673 if (!lp_allow_insecure_widelinks()) {
9674 return false;
9675 }
9676 }
9677
9678 return lp_widelinks_internal(snum);
9679 }
9680
9681 bool lp_writeraw(void)
9682 {
9683 if (lp_async_smb_echo_handler()) {
9684 return false;
9685 }
9686 return _lp_writeraw();
9687 }
9688
9689 bool lp_readraw(void)
9690 {
9691 if (lp_async_smb_echo_handler()) {
9692 return false;
9693 }
9694 return _lp_readraw();
9695 }
reg import