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