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