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