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