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