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