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