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