?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix for CVE-2009-2813.
[Samba.git] / source / param / loadparm.c
blob71a0e7b361dd36250d5181773d80ee2b8a18fb25
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
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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
56 BOOL in_client = False; /* Not in the client by default */
57 BOOL bLoaded = False;
58
59 extern pstring user_socket_options;
60 extern enum protocol_types Protocol;
61 extern userdom_struct current_user_info;
62
63 #ifndef GLOBAL_NAME
64 #define GLOBAL_NAME "global"
65 #endif
66
67 #ifndef PRINTERS_NAME
68 #define PRINTERS_NAME "printers"
69 #endif
70
71 #ifndef HOMES_NAME
72 #define HOMES_NAME "homes"
73 #endif
74
75 /* some helpful bits */
76 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && (ServicePtrs != NULL) && ServicePtrs[(i)]->valid)
77 #define VALID(i) (ServicePtrs != NULL && ServicePtrs[i]->valid)
78
79 #define USERSHARE_VALID 1
80 #define USERSHARE_PENDING_DELETE 2
81
82 int keepalive = DEFAULT_KEEPALIVE;
83 BOOL use_getwd_cache = True;
84
85 extern int extra_time_offset;
86
87 static BOOL defaults_saved = False;
88
89 typedef struct _param_opt_struct param_opt_struct;
90 struct _param_opt_struct {
91 param_opt_struct *prev, *next;
92 char *key;
93 char *value;
94 char **list;
95 };
96
97 /*
98 * This structure describes global (ie., server-wide) parameters.
99 */
100 typedef struct {
101 char *smb_ports;
102 char *dos_charset;
103 char *unix_charset;
104 char *display_charset;
105 char *szPrintcapname;
106 char *szAddPortCommand;
107 char *szEnumPortsCommand;
108 char *szAddPrinterCommand;
109 char *szDeletePrinterCommand;
110 char *szOs2DriverMap;
111 char *szLockDir;
112 char *szPidDir;
113 char *szRootdir;
114 char *szDefaultService;
115 char *szGetQuota;
116 char *szSetQuota;
117 char *szMsgCommand;
118 char *szServerString;
119 char *szAutoServices;
120 char *szPasswdProgram;
121 char *szPasswdChat;
122 char *szLogFile;
123 char *szConfigFile;
124 char *szSMBPasswdFile;
125 char *szPrivateDir;
126 char *szPassdbBackend;
127 char **szPreloadModules;
128 char *szPasswordServer;
129 char *szSocketOptions;
130 char *szRealm;
131 char *szAfsUsernameMap;
132 int iAfsTokenLifetime;
133 char *szLogNtTokenCommand;
134 char *szUsernameMap;
135 char *szLogonScript;
136 char *szLogonPath;
137 char *szLogonDrive;
138 char *szLogonHome;
139 char **szWINSservers;
140 char **szInterfaces;
141 char *szRemoteAnnounce;
142 char *szRemoteBrowseSync;
143 char *szSocketAddress;
144 char *szNISHomeMapName;
145 char *szAnnounceVersion; /* This is initialised in init_globals */
146 char *szWorkgroup;
147 char *szNetbiosName;
148 char **szNetbiosAliases;
149 char *szNetbiosScope;
150 char *szNameResolveOrder;
151 char *szPanicAction;
152 char *szAddUserScript;
153 char *szRenameUserScript;
154 char *szDelUserScript;
155 char *szAddGroupScript;
156 char *szDelGroupScript;
157 char *szAddUserToGroupScript;
158 char *szDelUserFromGroupScript;
159 char *szSetPrimaryGroupScript;
160 char *szAddMachineScript;
161 char *szShutdownScript;
162 char *szAbortShutdownScript;
163 char *szUsernameMapScript;
164 char *szCheckPasswordScript;
165 char *szWINSHook;
166 char *szUtmpDir;
167 char *szWtmpDir;
168 BOOL bUtmp;
169 char *szIdmapUID;
170 char *szIdmapGID;
171 BOOL bPassdbExpandExplicit;
172 int AlgorithmicRidBase;
173 char *szTemplateHomedir;
174 char *szTemplateShell;
175 char *szWinbindSeparator;
176 BOOL bWinbindEnumUsers;
177 BOOL bWinbindEnumGroups;
178 BOOL bWinbindUseDefaultDomain;
179 BOOL bWinbindTrustedDomainsOnly;
180 BOOL bWinbindNestedGroups;
181 BOOL bWinbindRefreshTickets;
182 BOOL bWinbindOfflineLogon;
183 BOOL bWinbindNormalizeNames;
184 char **szIdmapDomains;
185 char **szIdmapBackend; /* deprecated */
186 char *szIdmapAllocBackend;
187 char *szAddShareCommand;
188 char *szChangeShareCommand;
189 char *szDeleteShareCommand;
190 char **szEventLogs;
191 char *szGuestaccount;
192 char *szManglingMethod;
193 char **szServicesList;
194 char *szUsersharePath;
195 char *szUsershareTemplateShare;
196 char **szUsersharePrefixAllowList;
197 char **szUsersharePrefixDenyList;
198 int mangle_prefix;
199 int max_log_size;
200 char *szLogLevel;
201 int max_xmit;
202 int max_mux;
203 int max_open_files;
204 int open_files_db_hash_size;
205 int pwordlevel;
206 int unamelevel;
207 int deadtime;
208 int maxprotocol;
209 int minprotocol;
210 int security;
211 char **AuthMethods;
212 BOOL paranoid_server_security;
213 int maxdisksize;
214 int lpqcachetime;
215 int iMaxSmbdProcesses;
216 BOOL bDisableSpoolss;
217 int syslog;
218 int os_level;
219 int enhanced_browsing;
220 int max_ttl;
221 int max_wins_ttl;
222 int min_wins_ttl;
223 int lm_announce;
224 int lm_interval;
225 int announce_as; /* This is initialised in init_globals */
226 int machine_password_timeout;
227 int map_to_guest;
228 int oplock_break_wait_time;
229 int winbind_cache_time;
230 int winbind_max_idle_children;
231 char **szWinbindNssInfo;
232 int iLockSpinTime;
233 char *szLdapMachineSuffix;
234 char *szLdapUserSuffix;
235 char *szLdapIdmapSuffix;
236 char *szLdapGroupSuffix;
237 int ldap_ssl;
238 char *szLdapSuffix;
239 char *szLdapAdminDn;
240 int ldap_debug_level;
241 int ldap_debug_threshold;
242 int iAclCompat;
243 char *szCupsServer;
244 char *szIPrintServer;
245 int ldap_passwd_sync;
246 int ldap_replication_sleep;
247 int ldap_timeout; /* This is initialised in init_globals */
248 int ldap_page_size;
249 BOOL ldap_delete_dn;
250 BOOL bMsAddPrinterWizard;
251 BOOL bDNSproxy;
252 BOOL bWINSsupport;
253 BOOL bWINSproxy;
254 BOOL bLocalMaster;
255 BOOL bPreferredMaster;
256 BOOL bDomainMaster;
257 BOOL bDomainLogons;
258 BOOL bEncryptPasswords;
259 BOOL bUpdateEncrypt;
260 int clientSchannel;
261 int serverSchannel;
262 BOOL bNullPasswords;
263 BOOL bObeyPamRestrictions;
264 BOOL bLoadPrinters;
265 int PrintcapCacheTime;
266 BOOL bLargeReadwrite;
267 BOOL bReadRaw;
268 BOOL bWriteRaw;
269 BOOL bReadbmpx;
270 BOOL bSyslogOnly;
271 BOOL bBrowseList;
272 BOOL bNISHomeMap;
273 BOOL bTimeServer;
274 BOOL bBindInterfacesOnly;
275 BOOL bPamPasswordChange;
276 BOOL bUnixPasswdSync;
277 BOOL bPasswdChatDebug;
278 int iPasswdChatTimeout;
279 BOOL bTimestampLogs;
280 BOOL bNTSmbSupport;
281 BOOL bNTPipeSupport;
282 BOOL bNTStatusSupport;
283 BOOL bStatCache;
284 int iMaxStatCacheSize;
285 BOOL bKernelOplocks;
286 BOOL bAllowTrustedDomains;
287 BOOL bLanmanAuth;
288 BOOL bNTLMAuth;
289 BOOL bUseSpnego;
290 BOOL bClientLanManAuth;
291 BOOL bClientNTLMv2Auth;
292 BOOL bClientPlaintextAuth;
293 BOOL bClientUseSpnego;
294 BOOL bDebugPrefixTimestamp;
295 BOOL bDebugHiresTimestamp;
296 BOOL bDebugPid;
297 BOOL bDebugUid;
298 BOOL bEnableCoreFiles;
299 BOOL bHostMSDfs;
300 BOOL bUseMmap;
301 BOOL bHostnameLookups;
302 BOOL bUnixExtensions;
303 BOOL bDisableNetbios;
304 BOOL bUseKerberosKeytab;
305 BOOL bDeferSharingViolations;
306 BOOL bEnablePrivileges;
307 BOOL bASUSupport;
308 BOOL bUsershareOwnerOnly;
309 BOOL bUsershareAllowGuests;
310 int restrict_anonymous;
311 int name_cache_timeout;
312 int client_signing;
313 int server_signing;
314 int iUsershareMaxShares;
315 int iIdmapCacheTime;
316 int iIdmapNegativeCacheTime;
317
318 BOOL bResetOnZeroVC;
319 param_opt_struct *param_opt;
320 } global;
321
322 static global Globals;
323
324 /*
325 * This structure describes a single service.
326 */
327 typedef struct {
328 BOOL valid;
329 BOOL autoloaded;
330 int usershare;
331 time_t usershare_last_mod;
332 char *szService;
333 char *szPath;
334 char *szUsername;
335 char **szInvalidUsers;
336 char **szValidUsers;
337 char **szAdminUsers;
338 char *szCopy;
339 char *szInclude;
340 char *szPreExec;
341 char *szPostExec;
342 char *szRootPreExec;
343 char *szRootPostExec;
344 char *szCupsOptions;
345 char *szPrintcommand;
346 char *szLpqcommand;
347 char *szLprmcommand;
348 char *szLppausecommand;
349 char *szLpresumecommand;
350 char *szQueuepausecommand;
351 char *szQueueresumecommand;
352 char *szPrintername;
353 char *szPrintjobUsername;
354 char *szDontdescend;
355 char **szHostsallow;
356 char **szHostsdeny;
357 char *szMagicScript;
358 char *szMagicOutput;
359 char *szMangledMap;
360 char *szVetoFiles;
361 char *szHideFiles;
362 char *szVetoOplockFiles;
363 char *comment;
364 char *force_user;
365 char *force_group;
366 char **readlist;
367 char **writelist;
368 char **printer_admin;
369 char *volume;
370 char *fstype;
371 char **szVfsObjects;
372 char *szMSDfsProxy;
373 char *szAioWriteBehind;
374 char *szDfree;
375 int iMinPrintSpace;
376 int iMaxPrintJobs;
377 int iMaxReportedPrintJobs;
378 int iWriteCacheSize;
379 int iCreate_mask;
380 int iCreate_force_mode;
381 int iSecurity_mask;
382 int iSecurity_force_mode;
383 int iDir_mask;
384 int iDir_force_mode;
385 int iDir_Security_mask;
386 int iDir_Security_force_mode;
387 int iMaxConnections;
388 int iDefaultCase;
389 int iPrinting;
390 int iOplockContentionLimit;
391 int iCSCPolicy;
392 int iBlock_size;
393 int iDfreeCacheTime;
394 BOOL bPreexecClose;
395 BOOL bRootpreexecClose;
396 int iCaseSensitive;
397 BOOL bCasePreserve;
398 BOOL bShortCasePreserve;
399 BOOL bHideDotFiles;
400 BOOL bHideSpecialFiles;
401 BOOL bHideUnReadable;
402 BOOL bHideUnWriteableFiles;
403 BOOL bBrowseable;
404 BOOL bAvailable;
405 BOOL bRead_only;
406 BOOL bNo_set_dir;
407 BOOL bGuest_only;
408 BOOL bAdministrative_share;
409 BOOL bGuest_ok;
410 BOOL bPrint_ok;
411 BOOL bMap_system;
412 BOOL bMap_hidden;
413 BOOL bMap_archive;
414 BOOL bStoreDosAttributes;
415 BOOL bDmapiSupport;
416 BOOL bLocking;
417 int iStrictLocking;
418 BOOL bPosixLocking;
419 BOOL bShareModes;
420 BOOL bOpLocks;
421 BOOL bLevel2OpLocks;
422 BOOL bOnlyUser;
423 BOOL bMangledNames;
424 BOOL bWidelinks;
425 BOOL bSymlinks;
426 BOOL bSyncAlways;
427 BOOL bStrictAllocate;
428 BOOL bStrictSync;
429 char magic_char;
430 BOOL *copymap;
431 BOOL bDeleteReadonly;
432 BOOL bFakeOplocks;
433 BOOL bDeleteVetoFiles;
434 BOOL bDosFilemode;
435 BOOL bDosFiletimes;
436 BOOL bDosFiletimeResolution;
437 BOOL bFakeDirCreateTimes;
438 BOOL bBlockingLocks;
439 BOOL bInheritPerms;
440 BOOL bInheritACLS;
441 BOOL bInheritOwner;
442 BOOL bMSDfsRoot;
443 BOOL bUseClientDriver;
444 BOOL bDefaultDevmode;
445 BOOL bForcePrintername;
446 BOOL bNTAclSupport;
447 BOOL bForceUnknownAclUser;
448 BOOL bUseSendfile;
449 BOOL bProfileAcls;
450 BOOL bMap_acl_inherit;
451 BOOL bAfs_Share;
452 BOOL bEASupport;
453 BOOL bAclCheckPermissions;
454 BOOL bAclMapFullControl;
455 BOOL bAclGroupControl;
456 BOOL bChangeNotify;
457 BOOL bKernelChangeNotify;
458 int iallocation_roundup_size;
459 int iAioReadSize;
460 int iAioWriteSize;
461 int iMap_readonly;
462 int iDirectoryNameCacheSize;
463 param_opt_struct *param_opt;
464
465 char dummy[3]; /* for alignment */
466 } service;
467
468
469 /* This is a default service used to prime a services structure */
470 static service sDefault = {
471 True, /* valid */
472 False, /* not autoloaded */
473 0, /* not a usershare */
474 (time_t)0, /* No last mod time */
475 NULL, /* szService */
476 NULL, /* szPath */
477 NULL, /* szUsername */
478 NULL, /* szInvalidUsers */
479 NULL, /* szValidUsers */
480 NULL, /* szAdminUsers */
481 NULL, /* szCopy */
482 NULL, /* szInclude */
483 NULL, /* szPreExec */
484 NULL, /* szPostExec */
485 NULL, /* szRootPreExec */
486 NULL, /* szRootPostExec */
487 NULL, /* szCupsOptions */
488 NULL, /* szPrintcommand */
489 NULL, /* szLpqcommand */
490 NULL, /* szLprmcommand */
491 NULL, /* szLppausecommand */
492 NULL, /* szLpresumecommand */
493 NULL, /* szQueuepausecommand */
494 NULL, /* szQueueresumecommand */
495 NULL, /* szPrintername */
496 NULL, /* szPrintjobUsername */
497 NULL, /* szDontdescend */
498 NULL, /* szHostsallow */
499 NULL, /* szHostsdeny */
500 NULL, /* szMagicScript */
501 NULL, /* szMagicOutput */
502 NULL, /* szMangledMap */
503 NULL, /* szVetoFiles */
504 NULL, /* szHideFiles */
505 NULL, /* szVetoOplockFiles */
506 NULL, /* comment */
507 NULL, /* force user */
508 NULL, /* force group */
509 NULL, /* readlist */
510 NULL, /* writelist */
511 NULL, /* printer admin */
512 NULL, /* volume */
513 NULL, /* fstype */
514 NULL, /* vfs objects */
515 NULL, /* szMSDfsProxy */
516 NULL, /* szAioWriteBehind */
517 NULL, /* szDfree */
518 0, /* iMinPrintSpace */
519 1000, /* iMaxPrintJobs */
520 0, /* iMaxReportedPrintJobs */
521 0, /* iWriteCacheSize */
522 0744, /* iCreate_mask */
523 0000, /* iCreate_force_mode */
524 0777, /* iSecurity_mask */
525 0, /* iSecurity_force_mode */
526 0755, /* iDir_mask */
527 0000, /* iDir_force_mode */
528 0777, /* iDir_Security_mask */
529 0, /* iDir_Security_force_mode */
530 0, /* iMaxConnections */
531 CASE_LOWER, /* iDefaultCase */
532 DEFAULT_PRINTING, /* iPrinting */
533 2, /* iOplockContentionLimit */
534 0, /* iCSCPolicy */
535 1024, /* iBlock_size */
536 0, /* iDfreeCacheTime */
537 False, /* bPreexecClose */
538 False, /* bRootpreexecClose */
539 Auto, /* case sensitive */
540 True, /* case preserve */
541 True, /* short case preserve */
542 True, /* bHideDotFiles */
543 False, /* bHideSpecialFiles */
544 False, /* bHideUnReadable */
545 False, /* bHideUnWriteableFiles */
546 True, /* bBrowseable */
547 True, /* bAvailable */
548 True, /* bRead_only */
549 True, /* bNo_set_dir */
550 False, /* bGuest_only */
551 False, /* bAdministrative_share */
552 False, /* bGuest_ok */
553 False, /* bPrint_ok */
554 False, /* bMap_system */
555 False, /* bMap_hidden */
556 True, /* bMap_archive */
557 False, /* bStoreDosAttributes */
558 False, /* bDmapiSupport */
559 True, /* bLocking */
560 Auto, /* iStrictLocking */
561 True, /* bPosixLocking */
562 True, /* bShareModes */
563 True, /* bOpLocks */
564 True, /* bLevel2OpLocks */
565 False, /* bOnlyUser */
566 True, /* bMangledNames */
567 True, /* bWidelinks */
568 True, /* bSymlinks */
569 False, /* bSyncAlways */
570 False, /* bStrictAllocate */
571 False, /* bStrictSync */
572 '~', /* magic char */
573 NULL, /* copymap */
574 False, /* bDeleteReadonly */
575 False, /* bFakeOplocks */
576 False, /* bDeleteVetoFiles */
577 False, /* bDosFilemode */
578 True, /* bDosFiletimes */
579 False, /* bDosFiletimeResolution */
580 False, /* bFakeDirCreateTimes */
581 True, /* bBlockingLocks */
582 False, /* bInheritPerms */
583 False, /* bInheritACLS */
584 False, /* bInheritOwner */
585 False, /* bMSDfsRoot */
586 False, /* bUseClientDriver */
587 True, /* bDefaultDevmode */
588 False, /* bForcePrintername */
589 True, /* bNTAclSupport */
590 False, /* bForceUnknownAclUser */
591 False, /* bUseSendfile */
592 False, /* bProfileAcls */
593 False, /* bMap_acl_inherit */
594 False, /* bAfs_Share */
595 False, /* bEASupport */
596 True, /* bAclCheckPermissions */
597 True, /* bAclMapFullControl */
598 False, /* bAclGroupControl */
599 True, /* bChangeNotify */
600 True, /* bKernelChangeNotify */
601 SMB_ROUNDUP_ALLOCATION_SIZE, /* iallocation_roundup_size */
602 0, /* iAioReadSize */
603 0, /* iAioWriteSize */
604 MAP_READONLY_YES, /* iMap_readonly */
605 #ifdef BROKEN_DIRECTORY_HANDLING
606 0, /* iDirectoryNameCacheSize */
607 #else
608 100, /* iDirectoryNameCacheSize */
609 #endif
610 NULL, /* Parametric options */
611
612 "" /* dummy */
613 };
614
615 /* local variables */
616 static service **ServicePtrs = NULL;
617 static int iNumServices = 0;
618 static int iServiceIndex = 0;
619 static TDB_CONTEXT *ServiceHash;
620 static int *invalid_services = NULL;
621 static int num_invalid_services = 0;
622 static BOOL bInGlobalSection = True;
623 static BOOL bGlobalOnly = False;
624 static int server_role;
625 static int default_server_announce;
626
627 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
628
629 /* prototypes for the special type handlers */
630 static BOOL handle_include( int snum, const char *pszParmValue, char **ptr);
631 static BOOL handle_copy( int snum, const char *pszParmValue, char **ptr);
632 static BOOL handle_netbios_name( int snum, const char *pszParmValue, char **ptr);
633 static BOOL handle_idmap_uid( int snum, const char *pszParmValue, char **ptr);
634 static BOOL handle_idmap_gid( int snum, const char *pszParmValue, char **ptr);
635 static BOOL handle_debug_list( int snum, const char *pszParmValue, char **ptr );
636 static BOOL handle_workgroup( int snum, const char *pszParmValue, char **ptr );
637 static BOOL handle_netbios_aliases( int snum, const char *pszParmValue, char **ptr );
638 static BOOL handle_netbios_scope( int snum, const char *pszParmValue, char **ptr );
639 static BOOL handle_charset( int snum, const char *pszParmValue, char **ptr );
640 static BOOL handle_printing( int snum, const char *pszParmValue, char **ptr);
641 static BOOL handle_ldap_debug_level( int snum, const char *pszParmValue, char **ptr);
642
643 static void set_server_role(void);
644 static void set_default_server_announce_type(void);
645 static void set_allowed_client_auth(void);
646
647 static const struct enum_list enum_protocol[] = {
648 {PROTOCOL_NT1, "NT1"},
649 {PROTOCOL_LANMAN2, "LANMAN2"},
650 {PROTOCOL_LANMAN1, "LANMAN1"},
651 {PROTOCOL_CORE, "CORE"},
652 {PROTOCOL_COREPLUS, "COREPLUS"},
653 {PROTOCOL_COREPLUS, "CORE+"},
654 {-1, NULL}
655 };
656
657 static const struct enum_list enum_security[] = {
658 {SEC_SHARE, "SHARE"},
659 {SEC_USER, "USER"},
660 {SEC_SERVER, "SERVER"},
661 {SEC_DOMAIN, "DOMAIN"},
662 #ifdef HAVE_ADS
663 {SEC_ADS, "ADS"},
664 #endif
665 {-1, NULL}
666 };
667
668 static const struct enum_list enum_printing[] = {
669 {PRINT_SYSV, "sysv"},
670 {PRINT_AIX, "aix"},
671 {PRINT_HPUX, "hpux"},
672 {PRINT_BSD, "bsd"},
673 {PRINT_QNX, "qnx"},
674 {PRINT_PLP, "plp"},
675 {PRINT_LPRNG, "lprng"},
676 {PRINT_CUPS, "cups"},
677 {PRINT_IPRINT, "iprint"},
678 {PRINT_LPRNT, "nt"},
679 {PRINT_LPROS2, "os2"},
680 #ifdef DEVELOPER
681 {PRINT_TEST, "test"},
682 {PRINT_VLP, "vlp"},
683 #endif /* DEVELOPER */
684 {-1, NULL}
685 };
686
687 static const struct enum_list enum_ldap_ssl[] = {
688 {LDAP_SSL_OFF, "no"},
689 {LDAP_SSL_OFF, "No"},
690 {LDAP_SSL_OFF, "off"},
691 {LDAP_SSL_OFF, "Off"},
692 {LDAP_SSL_START_TLS, "start tls"},
693 {LDAP_SSL_START_TLS, "Start_tls"},
694 {-1, NULL}
695 };
696
697 static const struct enum_list enum_ldap_passwd_sync[] = {
698 {LDAP_PASSWD_SYNC_OFF, "no"},
699 {LDAP_PASSWD_SYNC_OFF, "No"},
700 {LDAP_PASSWD_SYNC_OFF, "off"},
701 {LDAP_PASSWD_SYNC_OFF, "Off"},
702 {LDAP_PASSWD_SYNC_ON, "Yes"},
703 {LDAP_PASSWD_SYNC_ON, "yes"},
704 {LDAP_PASSWD_SYNC_ON, "on"},
705 {LDAP_PASSWD_SYNC_ON, "On"},
706 {LDAP_PASSWD_SYNC_ONLY, "Only"},
707 {LDAP_PASSWD_SYNC_ONLY, "only"},
708 {-1, NULL}
709 };
710
711 /* Types of machine we can announce as. */
712 #define ANNOUNCE_AS_NT_SERVER 1
713 #define ANNOUNCE_AS_WIN95 2
714 #define ANNOUNCE_AS_WFW 3
715 #define ANNOUNCE_AS_NT_WORKSTATION 4
716
717 static const struct enum_list enum_announce_as[] = {
718 {ANNOUNCE_AS_NT_SERVER, "NT"},
719 {ANNOUNCE_AS_NT_SERVER, "NT Server"},
720 {ANNOUNCE_AS_NT_WORKSTATION, "NT Workstation"},
721 {ANNOUNCE_AS_WIN95, "win95"},
722 {ANNOUNCE_AS_WFW, "WfW"},
723 {-1, NULL}
724 };
725
726 static const struct enum_list enum_map_readonly[] = {
727 {MAP_READONLY_NO, "no"},
728 {MAP_READONLY_NO, "false"},
729 {MAP_READONLY_NO, "0"},
730 {MAP_READONLY_YES, "yes"},
731 {MAP_READONLY_YES, "true"},
732 {MAP_READONLY_YES, "1"},
733 {MAP_READONLY_PERMISSIONS, "permissions"},
734 {MAP_READONLY_PERMISSIONS, "perms"},
735 {-1, NULL}
736 };
737
738 static const struct enum_list enum_case[] = {
739 {CASE_LOWER, "lower"},
740 {CASE_UPPER, "upper"},
741 {-1, NULL}
742 };
743
744 static const struct enum_list enum_bool_auto[] = {
745 {False, "No"},
746 {False, "False"},
747 {False, "0"},
748 {True, "Yes"},
749 {True, "True"},
750 {True, "1"},
751 {Auto, "Auto"},
752 {-1, NULL}
753 };
754
755 /* Client-side offline caching policy types */
756 #define CSC_POLICY_MANUAL 0
757 #define CSC_POLICY_DOCUMENTS 1
758 #define CSC_POLICY_PROGRAMS 2
759 #define CSC_POLICY_DISABLE 3
760
761 static const struct enum_list enum_csc_policy[] = {
762 {CSC_POLICY_MANUAL, "manual"},
763 {CSC_POLICY_DOCUMENTS, "documents"},
764 {CSC_POLICY_PROGRAMS, "programs"},
765 {CSC_POLICY_DISABLE, "disable"},
766 {-1, NULL}
767 };
768
769 /* SMB signing types. */
770 static const struct enum_list enum_smb_signing_vals[] = {
771 {False, "No"},
772 {False, "False"},
773 {False, "0"},
774 {False, "Off"},
775 {False, "disabled"},
776 {True, "Yes"},
777 {True, "True"},
778 {True, "1"},
779 {True, "On"},
780 {True, "enabled"},
781 {Auto, "auto"},
782 {Required, "required"},
783 {Required, "mandatory"},
784 {Required, "force"},
785 {Required, "forced"},
786 {Required, "enforced"},
787 {-1, NULL}
788 };
789
790 /* ACL compatibility options. */
791 static const struct enum_list enum_acl_compat_vals[] = {
792 { ACL_COMPAT_AUTO, "auto" },
793 { ACL_COMPAT_WINNT, "winnt" },
794 { ACL_COMPAT_WIN2K, "win2k" },
795 { -1, NULL}
796 };
797
798 /*
799 Do you want session setups at user level security with a invalid
800 password to be rejected or allowed in as guest? WinNT rejects them
801 but it can be a pain as it means "net view" needs to use a password
802
803 You have 3 choices in the setting of map_to_guest:
804
805 "Never" means session setups with an invalid password
806 are rejected. This is the default.
807
808 "Bad User" means session setups with an invalid password
809 are rejected, unless the username does not exist, in which case it
810 is treated as a guest login
811
812 "Bad Password" means session setups with an invalid password
813 are treated as a guest login
814
815 Note that map_to_guest only has an effect in user or server
816 level security.
817 */
818
819 static const struct enum_list enum_map_to_guest[] = {
820 {NEVER_MAP_TO_GUEST, "Never"},
821 {MAP_TO_GUEST_ON_BAD_USER, "Bad User"},
822 {MAP_TO_GUEST_ON_BAD_PASSWORD, "Bad Password"},
823 {MAP_TO_GUEST_ON_BAD_UID, "Bad Uid"},
824 {-1, NULL}
825 };
826
827 /* Note: We do not initialise the defaults union - it is not allowed in ANSI C
828 *
829 * The FLAG_HIDE is explicit. Paramters set this way do NOT appear in any edit
830 * screen in SWAT. This is used to exclude parameters as well as to squash all
831 * parameters that have been duplicated by pseudonyms.
832 *
833 * NOTE: To display a parameter in BASIC view set FLAG_BASIC
834 * Any parameter that does NOT have FLAG_ADVANCED will not disply at all
835 * Set FLAG_SHARE and FLAG_PRINT to specifically display parameters in
836 * respective views.
837 *
838 * NOTE2: Handling of duplicated (synonym) paramters:
839 * Only the first occurance of a parameter should be enabled by FLAG_BASIC
840 * and/or FLAG_ADVANCED. All duplicates following the first mention should be
841 * set to FLAG_HIDE. ie: Make you must place the parameter that has the preferred
842 * name first, and all synonyms must follow it with the FLAG_HIDE attribute.
843 */
844
845 static struct parm_struct parm_table[] = {
846 {N_("Base Options"), P_SEP, P_SEPARATOR},
847
848 {"dos charset", P_STRING, P_GLOBAL, &Globals.dos_charset, handle_charset, NULL, FLAG_ADVANCED},
849 {"unix charset", P_STRING, P_GLOBAL, &Globals.unix_charset, handle_charset, NULL, FLAG_ADVANCED},
850 {"display charset", P_STRING, P_GLOBAL, &Globals.display_charset, handle_charset, NULL, FLAG_ADVANCED},
851 {"comment", P_STRING, P_LOCAL, &sDefault.comment, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
852 {"path", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
853 {"directory", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_HIDE},
854 {"workgroup", P_USTRING, P_GLOBAL, &Globals.szWorkgroup, handle_workgroup, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
855 #ifdef WITH_ADS
856 {"realm", P_USTRING, P_GLOBAL, &Globals.szRealm, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
857 #endif
858 {"netbios name", P_USTRING, P_GLOBAL, &Globals.szNetbiosName, handle_netbios_name, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
859 {"netbios aliases", P_LIST, P_GLOBAL, &Globals.szNetbiosAliases, handle_netbios_aliases, NULL, FLAG_ADVANCED},
860 {"netbios scope", P_USTRING, P_GLOBAL, &Globals.szNetbiosScope, handle_netbios_scope, NULL, FLAG_ADVANCED},
861 {"server string", P_STRING, P_GLOBAL, &Globals.szServerString, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED },
862 {"interfaces", P_LIST, P_GLOBAL, &Globals.szInterfaces, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
863 {"bind interfaces only", P_BOOL, P_GLOBAL, &Globals.bBindInterfacesOnly, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
864
865 {N_("Security Options"), P_SEP, P_SEPARATOR},
866
867 {"security", P_ENUM, P_GLOBAL, &Globals.security, NULL, enum_security, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
868 {"auth methods", P_LIST, P_GLOBAL, &Globals.AuthMethods, NULL, NULL, FLAG_ADVANCED},
869 {"encrypt passwords", P_BOOL, P_GLOBAL, &Globals.bEncryptPasswords, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
870 {"update encrypted", P_BOOL, P_GLOBAL, &Globals.bUpdateEncrypt, NULL, NULL, FLAG_ADVANCED},
871 {"client schannel", P_ENUM, P_GLOBAL, &Globals.clientSchannel, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
872 {"server schannel", P_ENUM, P_GLOBAL, &Globals.serverSchannel, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
873 {"allow trusted domains", P_BOOL, P_GLOBAL, &Globals.bAllowTrustedDomains, NULL, NULL, FLAG_ADVANCED},
874 {"map to guest", P_ENUM, P_GLOBAL, &Globals.map_to_guest, NULL, enum_map_to_guest, FLAG_ADVANCED},
875 {"null passwords", P_BOOL, P_GLOBAL, &Globals.bNullPasswords, NULL, NULL, FLAG_ADVANCED},
876 {"obey pam restrictions", P_BOOL, P_GLOBAL, &Globals.bObeyPamRestrictions, NULL, NULL, FLAG_ADVANCED},
877 {"password server", P_STRING, P_GLOBAL, &Globals.szPasswordServer, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
878 {"smb passwd file", P_STRING, P_GLOBAL, &Globals.szSMBPasswdFile, NULL, NULL, FLAG_ADVANCED},
879 {"private dir", P_STRING, P_GLOBAL, &Globals.szPrivateDir, NULL, NULL, FLAG_ADVANCED},
880 {"passdb backend", P_STRING, P_GLOBAL, &Globals.szPassdbBackend, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
881 {"algorithmic rid base", P_INTEGER, P_GLOBAL, &Globals.AlgorithmicRidBase, NULL, NULL, FLAG_ADVANCED},
882 {"root directory", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_ADVANCED},
883 {"root dir", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_HIDE},
884 {"root", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_HIDE},
885 {"guest account", P_STRING, P_GLOBAL, &Globals.szGuestaccount, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED},
886 {"enable privileges", P_BOOL, P_GLOBAL, &Globals.bEnablePrivileges, NULL, NULL, FLAG_ADVANCED},
887
888 {"pam password change", P_BOOL, P_GLOBAL, &Globals.bPamPasswordChange, NULL, NULL, FLAG_ADVANCED},
889 {"passwd program", P_STRING, P_GLOBAL, &Globals.szPasswdProgram, NULL, NULL, FLAG_ADVANCED},
890 {"passwd chat", P_STRING, P_GLOBAL, &Globals.szPasswdChat, NULL, NULL, FLAG_ADVANCED},
891 {"passwd chat debug", P_BOOL, P_GLOBAL, &Globals.bPasswdChatDebug, NULL, NULL, FLAG_ADVANCED},
892 {"passwd chat timeout", P_INTEGER, P_GLOBAL, &Globals.iPasswdChatTimeout, NULL, NULL, FLAG_ADVANCED},
893 {"check password script", P_STRING, P_GLOBAL, &Globals.szCheckPasswordScript, NULL, NULL, FLAG_ADVANCED},
894 {"username map", P_STRING, P_GLOBAL, &Globals.szUsernameMap, NULL, NULL, FLAG_ADVANCED},
895 {"password level", P_INTEGER, P_GLOBAL, &Globals.pwordlevel, NULL, NULL, FLAG_ADVANCED},
896 {"username level", P_INTEGER, P_GLOBAL, &Globals.unamelevel, NULL, NULL, FLAG_ADVANCED},
897 {"unix password sync", P_BOOL, P_GLOBAL, &Globals.bUnixPasswdSync, NULL, NULL, FLAG_ADVANCED},
898 {"restrict anonymous", P_INTEGER, P_GLOBAL, &Globals.restrict_anonymous, NULL, NULL, FLAG_ADVANCED},
899 {"lanman auth", P_BOOL, P_GLOBAL, &Globals.bLanmanAuth, NULL, NULL, FLAG_ADVANCED},
900 {"ntlm auth", P_BOOL, P_GLOBAL, &Globals.bNTLMAuth, NULL, NULL, FLAG_ADVANCED},
901 {"client NTLMv2 auth", P_BOOL, P_GLOBAL, &Globals.bClientNTLMv2Auth, NULL, NULL, FLAG_ADVANCED},
902 {"client lanman auth", P_BOOL, P_GLOBAL, &Globals.bClientLanManAuth, NULL, NULL, FLAG_ADVANCED},
903 {"client plaintext auth", P_BOOL, P_GLOBAL, &Globals.bClientPlaintextAuth, NULL, NULL, FLAG_ADVANCED},
904
905 {"username", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
906 {"user", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_HIDE},
907 {"users", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_HIDE},
908
909 {"invalid users", P_LIST, P_LOCAL, &sDefault.szInvalidUsers, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
910 {"valid users", P_LIST, P_LOCAL, &sDefault.szValidUsers, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
911 {"admin users", P_LIST, P_LOCAL, &sDefault.szAdminUsers, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
912 {"read list", P_LIST, P_LOCAL, &sDefault.readlist, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
913 {"write list", P_LIST, P_LOCAL, &sDefault.writelist, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
914 {"printer admin", P_LIST, P_LOCAL, &sDefault.printer_admin, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_PRINT | FLAG_DEPRECATED },
915 {"force user", P_STRING, P_LOCAL, &sDefault.force_user, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
916 {"force group", P_STRING, P_LOCAL, &sDefault.force_group, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
917 {"group", P_STRING, P_LOCAL, &sDefault.force_group, NULL, NULL, FLAG_ADVANCED},
918
919 {"read only", P_BOOL, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE},
920 {"write ok", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
921 {"writeable", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
922 {"writable", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
923
924 {"acl check permissions", P_BOOL, P_LOCAL, &sDefault.bAclCheckPermissions, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
925 {"acl group control", P_BOOL, P_LOCAL, &sDefault.bAclGroupControl, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE },
926 {"acl map full control", P_BOOL, P_LOCAL, &sDefault.bAclMapFullControl, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
927 {"create mask", P_OCTAL, P_LOCAL, &sDefault.iCreate_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
928 {"create mode", P_OCTAL, P_LOCAL, &sDefault.iCreate_mask, NULL, NULL, FLAG_HIDE},
929 {"force create mode", P_OCTAL, P_LOCAL, &sDefault.iCreate_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
930 {"security mask", P_OCTAL, P_LOCAL, &sDefault.iSecurity_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
931 {"force security mode", P_OCTAL, P_LOCAL, &sDefault.iSecurity_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
932 {"directory mask", P_OCTAL, P_LOCAL, &sDefault.iDir_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
933 {"directory mode", P_OCTAL, P_LOCAL, &sDefault.iDir_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
934 {"force directory mode", P_OCTAL, P_LOCAL, &sDefault.iDir_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
935 {"directory security mask", P_OCTAL, P_LOCAL, &sDefault.iDir_Security_mask, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
936 {"force directory security mode", P_OCTAL, P_LOCAL, &sDefault.iDir_Security_force_mode, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
937 {"force unknown acl user", P_BOOL, P_LOCAL, &sDefault.bForceUnknownAclUser, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
938 {"inherit permissions", P_BOOL, P_LOCAL, &sDefault.bInheritPerms, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
939 {"inherit acls", P_BOOL, P_LOCAL, &sDefault.bInheritACLS, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
940 {"inherit owner", P_BOOL, P_LOCAL, &sDefault.bInheritOwner, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
941 {"guest only", P_BOOL, P_LOCAL, &sDefault.bGuest_only, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
942 {"only guest", P_BOOL, P_LOCAL, &sDefault.bGuest_only, NULL, NULL, FLAG_HIDE},
943 {"administrative share", P_BOOL, P_LOCAL, &sDefault.bAdministrative_share, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
944
945 {"guest ok", P_BOOL, P_LOCAL, &sDefault.bGuest_ok, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
946 {"public", P_BOOL, P_LOCAL, &sDefault.bGuest_ok, NULL, NULL, FLAG_HIDE},
947
948 {"only user", P_BOOL, P_LOCAL, &sDefault.bOnlyUser, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_DEPRECATED},
949 {"hosts allow", P_LIST, P_LOCAL, &sDefault.szHostsallow, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
950 {"allow hosts", P_LIST, P_LOCAL, &sDefault.szHostsallow, NULL, NULL, FLAG_HIDE},
951 {"hosts deny", P_LIST, P_LOCAL, &sDefault.szHostsdeny, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
952 {"deny hosts", P_LIST, P_LOCAL, &sDefault.szHostsdeny, NULL, NULL, FLAG_HIDE},
953 {"preload modules", P_LIST, P_GLOBAL, &Globals.szPreloadModules, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
954 {"use kerberos keytab", P_BOOL, P_GLOBAL, &Globals.bUseKerberosKeytab, NULL, NULL, FLAG_ADVANCED},
955
956 {N_("Logging Options"), P_SEP, P_SEPARATOR},
957
958 {"log level", P_STRING, P_GLOBAL, &Globals.szLogLevel, handle_debug_list, NULL, FLAG_ADVANCED},
959 {"debuglevel", P_STRING, P_GLOBAL, &Globals.szLogLevel, handle_debug_list, NULL, FLAG_HIDE},
960 {"syslog", P_INTEGER, P_GLOBAL, &Globals.syslog, NULL, NULL, FLAG_ADVANCED},
961 {"syslog only", P_BOOL, P_GLOBAL, &Globals.bSyslogOnly, NULL, NULL, FLAG_ADVANCED},
962 {"log file", P_STRING, P_GLOBAL, &Globals.szLogFile, NULL, NULL, FLAG_ADVANCED},
963
964 {"max log size", P_INTEGER, P_GLOBAL, &Globals.max_log_size, NULL, NULL, FLAG_ADVANCED},
965 {"debug timestamp", P_BOOL, P_GLOBAL, &Globals.bTimestampLogs, NULL, NULL, FLAG_ADVANCED},
966 {"timestamp logs", P_BOOL, P_GLOBAL, &Globals.bTimestampLogs, NULL, NULL, FLAG_ADVANCED},
967 {"debug prefix timestamp", P_BOOL, P_GLOBAL, &Globals.bDebugPrefixTimestamp, NULL, NULL, FLAG_ADVANCED},
968 {"debug hires timestamp", P_BOOL, P_GLOBAL, &Globals.bDebugHiresTimestamp, NULL, NULL, FLAG_ADVANCED},
969 {"debug pid", P_BOOL, P_GLOBAL, &Globals.bDebugPid, NULL, NULL, FLAG_ADVANCED},
970 {"debug uid", P_BOOL, P_GLOBAL, &Globals.bDebugUid, NULL, NULL, FLAG_ADVANCED},
971 {"enable core files", P_BOOL, P_GLOBAL, &Globals.bEnableCoreFiles, NULL, NULL, FLAG_ADVANCED},
972
973 {N_("Protocol Options"), P_SEP, P_SEPARATOR},
974
975 {"allocation roundup size", P_INTEGER, P_LOCAL, &sDefault.iallocation_roundup_size, NULL, NULL, FLAG_ADVANCED},
976 {"aio read size", P_INTEGER, P_LOCAL, &sDefault.iAioReadSize, NULL, NULL, FLAG_ADVANCED},
977 {"aio write size", P_INTEGER, P_LOCAL, &sDefault.iAioWriteSize, NULL, NULL, FLAG_ADVANCED},
978 {"aio write behind", P_STRING, P_LOCAL, &sDefault.szAioWriteBehind, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL },
979 {"smb ports", P_STRING, P_GLOBAL, &Globals.smb_ports, NULL, NULL, FLAG_ADVANCED},
980 {"large readwrite", P_BOOL, P_GLOBAL, &Globals.bLargeReadwrite, NULL, NULL, FLAG_ADVANCED},
981 {"max protocol", P_ENUM, P_GLOBAL, &Globals.maxprotocol, NULL, enum_protocol, FLAG_ADVANCED},
982 {"protocol", P_ENUM, P_GLOBAL, &Globals.maxprotocol, NULL, enum_protocol, FLAG_ADVANCED},
983 {"min protocol", P_ENUM, P_GLOBAL, &Globals.minprotocol, NULL, enum_protocol, FLAG_ADVANCED},
984 {"read bmpx", P_BOOL, P_GLOBAL, &Globals.bReadbmpx, NULL, NULL, FLAG_ADVANCED},
985 {"read raw", P_BOOL, P_GLOBAL, &Globals.bReadRaw, NULL, NULL, FLAG_ADVANCED},
986 {"write raw", P_BOOL, P_GLOBAL, &Globals.bWriteRaw, NULL, NULL, FLAG_ADVANCED},
987 {"disable netbios", P_BOOL, P_GLOBAL, &Globals.bDisableNetbios, NULL, NULL, FLAG_ADVANCED},
988 {"reset on zero vc", P_BOOL, P_GLOBAL, &Globals.bResetOnZeroVC, NULL, NULL, FLAG_ADVANCED},
989
990 {"acl compatibility", P_ENUM, P_GLOBAL, &Globals.iAclCompat, NULL, enum_acl_compat_vals, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
991 {"defer sharing violations", P_BOOL, P_GLOBAL, &Globals.bDeferSharingViolations, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
992 {"ea support", P_BOOL, P_LOCAL, &sDefault.bEASupport, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
993 {"nt acl support", P_BOOL, P_LOCAL, &sDefault.bNTAclSupport, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
994 {"nt pipe support", P_BOOL, P_GLOBAL, &Globals.bNTPipeSupport, NULL, NULL, FLAG_ADVANCED},
995 {"nt status support", P_BOOL, P_GLOBAL, &Globals.bNTStatusSupport, NULL, NULL, FLAG_ADVANCED},
996 {"profile acls", P_BOOL, P_LOCAL, &sDefault.bProfileAcls, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
997
998 {"announce version", P_STRING, P_GLOBAL, &Globals.szAnnounceVersion, NULL, NULL, FLAG_ADVANCED},
999 {"announce as", P_ENUM, P_GLOBAL, &Globals.announce_as, NULL, enum_announce_as, FLAG_ADVANCED},
1000 {"map acl inherit", P_BOOL, P_LOCAL, &sDefault.bMap_acl_inherit, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1001 {"afs share", P_BOOL, P_LOCAL, &sDefault.bAfs_Share, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1002 {"max mux", P_INTEGER, P_GLOBAL, &Globals.max_mux, NULL, NULL, FLAG_ADVANCED},
1003 {"max xmit", P_INTEGER, P_GLOBAL, &Globals.max_xmit, NULL, NULL, FLAG_ADVANCED},
1004
1005 {"name resolve order", P_STRING, P_GLOBAL, &Globals.szNameResolveOrder, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
1006 {"max ttl", P_INTEGER, P_GLOBAL, &Globals.max_ttl, NULL, NULL, FLAG_ADVANCED},
1007 {"max wins ttl", P_INTEGER, P_GLOBAL, &Globals.max_wins_ttl, NULL, NULL, FLAG_ADVANCED},
1008 {"min wins ttl", P_INTEGER, P_GLOBAL, &Globals.min_wins_ttl, NULL, NULL, FLAG_ADVANCED},
1009 {"time server", P_BOOL, P_GLOBAL, &Globals.bTimeServer, NULL, NULL, FLAG_ADVANCED},
1010 {"unix extensions", P_BOOL, P_GLOBAL, &Globals.bUnixExtensions, NULL, NULL, FLAG_ADVANCED},
1011 {"use spnego", P_BOOL, P_GLOBAL, &Globals.bUseSpnego, NULL, NULL, FLAG_ADVANCED},
1012 {"client signing", P_ENUM, P_GLOBAL, &Globals.client_signing, NULL, enum_smb_signing_vals, FLAG_ADVANCED},
1013 {"server signing", P_ENUM, P_GLOBAL, &Globals.server_signing, NULL, enum_smb_signing_vals, FLAG_ADVANCED},
1014 {"client use spnego", P_BOOL, P_GLOBAL, &Globals.bClientUseSpnego, NULL, NULL, FLAG_ADVANCED},
1015
1016 {"enable asu support", P_BOOL, P_GLOBAL, &Globals.bASUSupport, NULL, NULL, FLAG_ADVANCED},
1017 {"svcctl list", P_LIST, P_GLOBAL, &Globals.szServicesList, NULL, NULL, FLAG_ADVANCED},
1018
1019 {N_("Tuning Options"), P_SEP, P_SEPARATOR},
1020
1021 {"block size", P_INTEGER, P_LOCAL, &sDefault.iBlock_size, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1022 {"deadtime", P_INTEGER, P_GLOBAL, &Globals.deadtime, NULL, NULL, FLAG_ADVANCED},
1023 {"getwd cache", P_BOOL, P_GLOBAL, &use_getwd_cache, NULL, NULL, FLAG_ADVANCED},
1024 {"keepalive", P_INTEGER, P_GLOBAL, &keepalive, NULL, NULL, FLAG_ADVANCED},
1025 {"change notify", P_BOOL, P_LOCAL, &sDefault.bChangeNotify, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE },
1026 {"directory name cache size", P_INTEGER, P_LOCAL, &sDefault.iDirectoryNameCacheSize, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE },
1027 {"kernel change notify", P_BOOL, P_LOCAL, &sDefault.bKernelChangeNotify, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE },
1028
1029 {"lpq cache time", P_INTEGER, P_GLOBAL, &Globals.lpqcachetime, NULL, NULL, FLAG_ADVANCED},
1030 {"max smbd processes", P_INTEGER, P_GLOBAL, &Globals.iMaxSmbdProcesses, NULL, NULL, FLAG_ADVANCED},
1031 {"max connections", P_INTEGER, P_LOCAL, &sDefault.iMaxConnections, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1032 {"paranoid server security", P_BOOL, P_GLOBAL, &Globals.paranoid_server_security, NULL, NULL, FLAG_ADVANCED},
1033 {"max disk size", P_INTEGER, P_GLOBAL, &Globals.maxdisksize, NULL, NULL, FLAG_ADVANCED},
1034 {"max open files", P_INTEGER, P_GLOBAL, &Globals.max_open_files, NULL, NULL, FLAG_ADVANCED},
1035 {"min print space", P_INTEGER, P_LOCAL, &sDefault.iMinPrintSpace, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1036 {"open files database hash size", P_INTEGER, P_GLOBAL, &Globals.open_files_db_hash_size, NULL, NULL, FLAG_ADVANCED},
1037
1038 {"socket options", P_GSTRING, P_GLOBAL, user_socket_options, NULL, NULL, FLAG_ADVANCED},
1039 {"strict allocate", P_BOOL, P_LOCAL, &sDefault.bStrictAllocate, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1040 {"strict sync", P_BOOL, P_LOCAL, &sDefault.bStrictSync, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1041 {"sync always", P_BOOL, P_LOCAL, &sDefault.bSyncAlways, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1042 {"use mmap", P_BOOL, P_GLOBAL, &Globals.bUseMmap, NULL, NULL, FLAG_ADVANCED},
1043 {"use sendfile", P_BOOL, P_LOCAL, &sDefault.bUseSendfile, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1044 {"hostname lookups", P_BOOL, P_GLOBAL, &Globals.bHostnameLookups, NULL, NULL, FLAG_ADVANCED},
1045 {"write cache size", P_INTEGER, P_LOCAL, &sDefault.iWriteCacheSize, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_DEPRECATED},
1046
1047 {"name cache timeout", P_INTEGER, P_GLOBAL, &Globals.name_cache_timeout, NULL, NULL, FLAG_ADVANCED},
1048
1049 {N_("Printing Options"), P_SEP, P_SEPARATOR},
1050
1051 {"max reported print jobs", P_INTEGER, P_LOCAL, &sDefault.iMaxReportedPrintJobs, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1052 {"max print jobs", P_INTEGER, P_LOCAL, &sDefault.iMaxPrintJobs, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1053 {"load printers", P_BOOL, P_GLOBAL, &Globals.bLoadPrinters, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1054 {"printcap cache time", P_INTEGER, P_GLOBAL, &Globals.PrintcapCacheTime, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1055 {"printcap name", P_STRING, P_GLOBAL, &Globals.szPrintcapname, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1056 {"printcap", P_STRING, P_GLOBAL, &Globals.szPrintcapname, NULL, NULL, FLAG_HIDE},
1057 {"printable", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1058 {"print ok", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_HIDE},
1059 {"printing", P_ENUM, P_LOCAL, &sDefault.iPrinting, handle_printing, enum_printing, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1060 {"cups options", P_STRING, P_LOCAL, &sDefault.szCupsOptions, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1061 {"cups server", P_STRING, P_GLOBAL, &Globals.szCupsServer, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1062 {"iprint server", P_STRING, P_GLOBAL, &Globals.szIPrintServer, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1063 {"print command", P_STRING, P_LOCAL, &sDefault.szPrintcommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1064 {"disable spoolss", P_BOOL, P_GLOBAL, &Globals.bDisableSpoolss, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1065 {"enable spoolss", P_BOOLREV, P_GLOBAL, &Globals.bDisableSpoolss, NULL, NULL, FLAG_HIDE},
1066 {"lpq command", P_STRING, P_LOCAL, &sDefault.szLpqcommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1067 {"lprm command", P_STRING, P_LOCAL, &sDefault.szLprmcommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1068 {"lppause command", P_STRING, P_LOCAL, &sDefault.szLppausecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1069 {"lpresume command", P_STRING, P_LOCAL, &sDefault.szLpresumecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1070 {"queuepause command", P_STRING, P_LOCAL, &sDefault.szQueuepausecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1071 {"queueresume command", P_STRING, P_LOCAL, &sDefault.szQueueresumecommand, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT | FLAG_GLOBAL},
1072
1073 {"addport command", P_STRING, P_GLOBAL, &Globals.szAddPortCommand, NULL, NULL, FLAG_ADVANCED},
1074 {"enumports command", P_STRING, P_GLOBAL, &Globals.szEnumPortsCommand, NULL, NULL, FLAG_ADVANCED},
1075 {"addprinter command", P_STRING, P_GLOBAL, &Globals.szAddPrinterCommand, NULL, NULL, FLAG_ADVANCED},
1076 {"deleteprinter command", P_STRING, P_GLOBAL, &Globals.szDeletePrinterCommand, NULL, NULL, FLAG_ADVANCED},
1077 {"show add printer wizard", P_BOOL, P_GLOBAL, &Globals.bMsAddPrinterWizard, NULL, NULL, FLAG_ADVANCED},
1078 {"os2 driver map", P_STRING, P_GLOBAL, &Globals.szOs2DriverMap, NULL, NULL, FLAG_ADVANCED},
1079
1080 {"printer name", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1081 {"printer", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_HIDE},
1082 {"use client driver", P_BOOL, P_LOCAL, &sDefault.bUseClientDriver, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1083 {"default devmode", P_BOOL, P_LOCAL, &sDefault.bDefaultDevmode, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1084 {"force printername", P_BOOL, P_LOCAL, &sDefault.bForcePrintername, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1085 {"printjob username", P_STRING, P_LOCAL, &sDefault.szPrintjobUsername, NULL, NULL, FLAG_ADVANCED | FLAG_PRINT},
1086
1087 {N_("Filename Handling"), P_SEP, P_SEPARATOR},
1088 {"mangling method", P_STRING, P_GLOBAL, &Globals.szManglingMethod, NULL, NULL, FLAG_ADVANCED},
1089 {"mangle prefix", P_INTEGER, P_GLOBAL, &Globals.mangle_prefix, NULL, NULL, FLAG_ADVANCED},
1090
1091 {"default case", P_ENUM, P_LOCAL, &sDefault.iDefaultCase, NULL, enum_case, FLAG_ADVANCED | FLAG_SHARE},
1092 {"case sensitive", P_ENUM, P_LOCAL, &sDefault.iCaseSensitive, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1093 {"casesignames", P_ENUM, P_LOCAL, &sDefault.iCaseSensitive, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL | FLAG_HIDE},
1094 {"preserve case", P_BOOL, P_LOCAL, &sDefault.bCasePreserve, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1095 {"short preserve case", P_BOOL, P_LOCAL, &sDefault.bShortCasePreserve, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1096 {"mangling char", P_CHAR, P_LOCAL, &sDefault.magic_char, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1097 {"hide dot files", P_BOOL, P_LOCAL, &sDefault.bHideDotFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1098 {"hide special files", P_BOOL, P_LOCAL, &sDefault.bHideSpecialFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1099 {"hide unreadable", P_BOOL, P_LOCAL, &sDefault.bHideUnReadable, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1100 {"hide unwriteable files", P_BOOL, P_LOCAL, &sDefault.bHideUnWriteableFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1101 {"delete veto files", P_BOOL, P_LOCAL, &sDefault.bDeleteVetoFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1102 {"veto files", P_STRING, P_LOCAL, &sDefault.szVetoFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL },
1103 {"hide files", P_STRING, P_LOCAL, &sDefault.szHideFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL },
1104 {"veto oplock files", P_STRING, P_LOCAL, &sDefault.szVetoOplockFiles, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL },
1105 {"map archive", P_BOOL, P_LOCAL, &sDefault.bMap_archive, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1106 {"map hidden", P_BOOL, P_LOCAL, &sDefault.bMap_hidden, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1107 {"map system", P_BOOL, P_LOCAL, &sDefault.bMap_system, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1108 {"map readonly", P_ENUM, P_LOCAL, &sDefault.iMap_readonly, NULL, enum_map_readonly, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1109 {"mangled names", P_BOOL, P_LOCAL, &sDefault.bMangledNames, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1110 {"mangled map", P_STRING, P_LOCAL, &sDefault.szMangledMap, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL | FLAG_DEPRECATED },
1111 {"max stat cache size", P_INTEGER, P_GLOBAL, &Globals.iMaxStatCacheSize, NULL, NULL, FLAG_ADVANCED},
1112 {"stat cache", P_BOOL, P_GLOBAL, &Globals.bStatCache, NULL, NULL, FLAG_ADVANCED},
1113 {"store dos attributes", P_BOOL, P_LOCAL, &sDefault.bStoreDosAttributes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1114 {"dmapi support", P_BOOL, P_LOCAL, &sDefault.bDmapiSupport, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1115
1116
1117 {N_("Domain Options"), P_SEP, P_SEPARATOR},
1118
1119 {"machine password timeout", P_INTEGER, P_GLOBAL, &Globals.machine_password_timeout, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD},
1120
1121 {N_("Logon Options"), P_SEP, P_SEPARATOR},
1122
1123 {"add user script", P_STRING, P_GLOBAL, &Globals.szAddUserScript, NULL, NULL, FLAG_ADVANCED},
1124 {"rename user script", P_STRING, P_GLOBAL, &Globals.szRenameUserScript, NULL, NULL, FLAG_ADVANCED},
1125 {"delete user script", P_STRING, P_GLOBAL, &Globals.szDelUserScript, NULL, NULL, FLAG_ADVANCED},
1126 {"add group script", P_STRING, P_GLOBAL, &Globals.szAddGroupScript, NULL, NULL, FLAG_ADVANCED},
1127 {"delete group script", P_STRING, P_GLOBAL, &Globals.szDelGroupScript, NULL, NULL, FLAG_ADVANCED},
1128 {"add user to group script", P_STRING, P_GLOBAL, &Globals.szAddUserToGroupScript, NULL, NULL, FLAG_ADVANCED},
1129 {"delete user from group script", P_STRING, P_GLOBAL, &Globals.szDelUserFromGroupScript, NULL, NULL, FLAG_ADVANCED},
1130 {"set primary group script", P_STRING, P_GLOBAL, &Globals.szSetPrimaryGroupScript, NULL, NULL, FLAG_ADVANCED},
1131 {"add machine script", P_STRING, P_GLOBAL, &Globals.szAddMachineScript, NULL, NULL, FLAG_ADVANCED},
1132 {"shutdown script", P_STRING, P_GLOBAL, &Globals.szShutdownScript, NULL, NULL, FLAG_ADVANCED},
1133 {"abort shutdown script", P_STRING, P_GLOBAL, &Globals.szAbortShutdownScript, NULL, NULL, FLAG_ADVANCED},
1134 {"username map script", P_STRING, P_GLOBAL, &Globals.szUsernameMapScript, NULL, NULL, FLAG_ADVANCED},
1135
1136 {"logon script", P_STRING, P_GLOBAL, &Globals.szLogonScript, NULL, NULL, FLAG_ADVANCED},
1137 {"logon path", P_STRING, P_GLOBAL, &Globals.szLogonPath, NULL, NULL, FLAG_ADVANCED},
1138 {"logon drive", P_STRING, P_GLOBAL, &Globals.szLogonDrive, NULL, NULL, FLAG_ADVANCED},
1139 {"logon home", P_STRING, P_GLOBAL, &Globals.szLogonHome, NULL, NULL, FLAG_ADVANCED},
1140 {"domain logons", P_BOOL, P_GLOBAL, &Globals.bDomainLogons, NULL, NULL, FLAG_ADVANCED},
1141
1142 {N_("Browse Options"), P_SEP, P_SEPARATOR},
1143
1144 {"os level", P_INTEGER, P_GLOBAL, &Globals.os_level, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED},
1145 {"lm announce", P_ENUM, P_GLOBAL, &Globals.lm_announce, NULL, enum_bool_auto, FLAG_ADVANCED},
1146 {"lm interval", P_INTEGER, P_GLOBAL, &Globals.lm_interval, NULL, NULL, FLAG_ADVANCED},
1147 {"preferred master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
1148 {"prefered master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_HIDE},
1149 {"local master", P_BOOL, P_GLOBAL, &Globals.bLocalMaster, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED},
1150 {"domain master", P_ENUM, P_GLOBAL, &Globals.bDomainMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED},
1151 {"browse list", P_BOOL, P_GLOBAL, &Globals.bBrowseList, NULL, NULL, FLAG_ADVANCED},
1152 {"browseable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1153 {"browsable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_HIDE},
1154 {"enhanced browsing", P_BOOL, P_GLOBAL, &Globals.enhanced_browsing, NULL, NULL, FLAG_ADVANCED},
1155
1156 {N_("WINS Options"), P_SEP, P_SEPARATOR},
1157
1158 {"dns proxy", P_BOOL, P_GLOBAL, &Globals.bDNSproxy, NULL, NULL, FLAG_ADVANCED},
1159 {"wins proxy", P_BOOL, P_GLOBAL, &Globals.bWINSproxy, NULL, NULL, FLAG_ADVANCED},
1160
1161 {"wins server", P_LIST, P_GLOBAL, &Globals.szWINSservers, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
1162 {"wins support", P_BOOL, P_GLOBAL, &Globals.bWINSsupport, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD},
1163 {"wins hook", P_STRING, P_GLOBAL, &Globals.szWINSHook, NULL, NULL, FLAG_ADVANCED},
1164
1165 {N_("Locking Options"), P_SEP, P_SEPARATOR},
1166
1167 {"blocking locks", P_BOOL, P_LOCAL, &sDefault.bBlockingLocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1168 {"csc policy", P_ENUM, P_LOCAL, &sDefault.iCSCPolicy, NULL, enum_csc_policy, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1169 {"fake oplocks", P_BOOL, P_LOCAL, &sDefault.bFakeOplocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1170 {"kernel oplocks", P_BOOL, P_GLOBAL, &Globals.bKernelOplocks, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1171 {"locking", P_BOOL, P_LOCAL, &sDefault.bLocking, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1172 {"lock spin time", P_INTEGER, P_GLOBAL, &Globals.iLockSpinTime, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1173
1174 {"oplocks", P_BOOL, P_LOCAL, &sDefault.bOpLocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1175 {"level2 oplocks", P_BOOL, P_LOCAL, &sDefault.bLevel2OpLocks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1176 {"oplock break wait time", P_INTEGER, P_GLOBAL, &Globals.oplock_break_wait_time, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL},
1177 {"oplock contention limit", P_INTEGER, P_LOCAL, &sDefault.iOplockContentionLimit, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1178 {"posix locking", P_BOOL, P_LOCAL, &sDefault.bPosixLocking, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1179 {"strict locking", P_ENUM, P_LOCAL, &sDefault.iStrictLocking, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1180 {"share modes", P_BOOL, P_LOCAL, &sDefault.bShareModes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1181
1182 {N_("Ldap Options"), P_SEP, P_SEPARATOR},
1183
1184 {"ldap admin dn", P_STRING, P_GLOBAL, &Globals.szLdapAdminDn, NULL, NULL, FLAG_ADVANCED},
1185 {"ldap delete dn", P_BOOL, P_GLOBAL, &Globals.ldap_delete_dn, NULL, NULL, FLAG_ADVANCED},
1186 {"ldap group suffix", P_STRING, P_GLOBAL, &Globals.szLdapGroupSuffix, NULL, NULL, FLAG_ADVANCED},
1187 {"ldap idmap suffix", P_STRING, P_GLOBAL, &Globals.szLdapIdmapSuffix, NULL, NULL, FLAG_ADVANCED},
1188 {"ldap machine suffix", P_STRING, P_GLOBAL, &Globals.szLdapMachineSuffix, NULL, NULL, FLAG_ADVANCED},
1189 {"ldap passwd sync", P_ENUM, P_GLOBAL, &Globals.ldap_passwd_sync, NULL, enum_ldap_passwd_sync, FLAG_ADVANCED},
1190 {"ldap password sync", P_ENUM, P_GLOBAL, &Globals.ldap_passwd_sync, NULL, enum_ldap_passwd_sync, FLAG_HIDE},
1191 {"ldap replication sleep", P_INTEGER, P_GLOBAL, &Globals.ldap_replication_sleep, NULL, NULL, FLAG_ADVANCED},
1192 {"ldap suffix", P_STRING, P_GLOBAL, &Globals.szLdapSuffix, NULL, NULL, FLAG_ADVANCED},
1193 {"ldap ssl", P_ENUM, P_GLOBAL, &Globals.ldap_ssl, NULL, enum_ldap_ssl, FLAG_ADVANCED},
1194 {"ldap timeout", P_INTEGER, P_GLOBAL, &Globals.ldap_timeout, NULL, NULL, FLAG_ADVANCED},
1195 {"ldap page size", P_INTEGER, P_GLOBAL, &Globals.ldap_page_size, NULL, NULL, FLAG_ADVANCED},
1196 {"ldap user suffix", P_STRING, P_GLOBAL, &Globals.szLdapUserSuffix, NULL, NULL, FLAG_ADVANCED},
1197
1198 {"ldap debug level", P_INTEGER, P_GLOBAL, &Globals.ldap_debug_level, handle_ldap_debug_level, NULL, FLAG_ADVANCED},
1199 {"ldap debug threshold", P_INTEGER, P_GLOBAL, &Globals.ldap_debug_threshold, NULL, NULL, FLAG_ADVANCED},
1200
1201
1202 {N_("Miscellaneous Options"), P_SEP, P_SEPARATOR},
1203 {"add share command", P_STRING, P_GLOBAL, &Globals.szAddShareCommand, NULL, NULL, FLAG_ADVANCED},
1204 {"change share command", P_STRING, P_GLOBAL, &Globals.szChangeShareCommand, NULL, NULL, FLAG_ADVANCED},
1205 {"delete share command", P_STRING, P_GLOBAL, &Globals.szDeleteShareCommand, NULL, NULL, FLAG_ADVANCED},
1206
1207 {N_("EventLog Options"), P_SEP, P_SEPARATOR},
1208 {"eventlog list", P_LIST, P_GLOBAL, &Globals.szEventLogs, NULL, NULL, FLAG_ADVANCED | FLAG_GLOBAL | FLAG_SHARE},
1209
1210 {"config file", P_STRING, P_GLOBAL, &Globals.szConfigFile, NULL, NULL, FLAG_HIDE},
1211 {"preload", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED},
1212 {"auto services", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED},
1213 {"lock directory", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_ADVANCED},
1214 {"lock dir", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_HIDE},
1215 {"pid directory", P_STRING, P_GLOBAL, &Globals.szPidDir, NULL, NULL, FLAG_ADVANCED},
1216 #ifdef WITH_UTMP
1217 {"utmp directory", P_STRING, P_GLOBAL, &Globals.szUtmpDir, NULL, NULL, FLAG_ADVANCED},
1218 {"wtmp directory", P_STRING, P_GLOBAL, &Globals.szWtmpDir, NULL, NULL, FLAG_ADVANCED},
1219 {"utmp", P_BOOL, P_GLOBAL, &Globals.bUtmp, NULL, NULL, FLAG_ADVANCED},
1220 #endif
1221
1222 {"default service", P_STRING, P_GLOBAL, &Globals.szDefaultService, NULL, NULL, FLAG_ADVANCED},
1223 {"default", P_STRING, P_GLOBAL, &Globals.szDefaultService, NULL, NULL, FLAG_ADVANCED},
1224 {"message command", P_STRING, P_GLOBAL, &Globals.szMsgCommand, NULL, NULL, FLAG_ADVANCED},
1225 {"dfree cache time", P_INTEGER, P_LOCAL, &sDefault.iDfreeCacheTime, NULL, NULL, FLAG_ADVANCED},
1226 {"dfree command", P_STRING, P_LOCAL, &sDefault.szDfree, NULL, NULL, FLAG_ADVANCED},
1227 {"get quota command", P_STRING, P_GLOBAL, &Globals.szGetQuota, NULL, NULL, FLAG_ADVANCED},
1228 {"set quota command", P_STRING, P_GLOBAL, &Globals.szSetQuota, NULL, NULL, FLAG_ADVANCED},
1229 {"remote announce", P_STRING, P_GLOBAL, &Globals.szRemoteAnnounce, NULL, NULL, FLAG_ADVANCED},
1230 {"remote browse sync", P_STRING, P_GLOBAL, &Globals.szRemoteBrowseSync, NULL, NULL, FLAG_ADVANCED},
1231 {"socket address", P_STRING, P_GLOBAL, &Globals.szSocketAddress, NULL, NULL, FLAG_ADVANCED},
1232 {"homedir map", P_STRING, P_GLOBAL, &Globals.szNISHomeMapName, NULL, NULL, FLAG_ADVANCED},
1233 {"afs username map", P_STRING, P_GLOBAL, &Globals.szAfsUsernameMap, NULL, NULL, FLAG_ADVANCED},
1234 {"afs token lifetime", P_INTEGER, P_GLOBAL, &Globals.iAfsTokenLifetime, NULL, NULL, FLAG_ADVANCED},
1235 {"log nt token command", P_STRING, P_GLOBAL, &Globals.szLogNtTokenCommand, NULL, NULL, FLAG_ADVANCED},
1236 {"time offset", P_INTEGER, P_GLOBAL, &extra_time_offset, NULL, NULL, FLAG_ADVANCED},
1237 {"NIS homedir", P_BOOL, P_GLOBAL, &Globals.bNISHomeMap, NULL, NULL, FLAG_ADVANCED},
1238 {"-valid", P_BOOL, P_LOCAL, &sDefault.valid, NULL, NULL, FLAG_HIDE},
1239
1240 {"copy", P_STRING, P_LOCAL, &sDefault.szCopy, handle_copy, NULL, FLAG_HIDE},
1241 {"include", P_STRING, P_LOCAL, &sDefault.szInclude, handle_include, NULL, FLAG_HIDE},
1242 {"preexec", P_STRING, P_LOCAL, &sDefault.szPreExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1243 {"exec", P_STRING, P_LOCAL, &sDefault.szPreExec, NULL, NULL, FLAG_ADVANCED},
1244
1245 {"preexec close", P_BOOL, P_LOCAL, &sDefault.bPreexecClose, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1246 {"postexec", P_STRING, P_LOCAL, &sDefault.szPostExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1247 {"root preexec", P_STRING, P_LOCAL, &sDefault.szRootPreExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1248 {"root preexec close", P_BOOL, P_LOCAL, &sDefault.bRootpreexecClose, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1249 {"root postexec", P_STRING, P_LOCAL, &sDefault.szRootPostExec, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1250 {"available", P_BOOL, P_LOCAL, &sDefault.bAvailable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1251 {"usershare allow guests", P_BOOL, P_GLOBAL, &Globals.bUsershareAllowGuests, NULL, NULL, FLAG_ADVANCED},
1252 {"usershare max shares", P_INTEGER, P_GLOBAL, &Globals.iUsershareMaxShares, NULL, NULL, FLAG_ADVANCED},
1253 {"usershare owner only", P_BOOL, P_GLOBAL, &Globals.bUsershareOwnerOnly, NULL, NULL, FLAG_ADVANCED},
1254 {"usershare path", P_STRING, P_GLOBAL, &Globals.szUsersharePath, NULL, NULL, FLAG_ADVANCED},
1255 {"usershare prefix allow list", P_LIST, P_GLOBAL, &Globals.szUsersharePrefixAllowList, NULL, NULL, FLAG_ADVANCED},
1256 {"usershare prefix deny list", P_LIST, P_GLOBAL, &Globals.szUsersharePrefixDenyList, NULL, NULL, FLAG_ADVANCED},
1257 {"usershare template share", P_STRING, P_GLOBAL, &Globals.szUsershareTemplateShare, NULL, NULL, FLAG_ADVANCED},
1258 {"volume", P_STRING, P_LOCAL, &sDefault.volume, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE },
1259 {"fstype", P_STRING, P_LOCAL, &sDefault.fstype, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1260 {"set directory", P_BOOLREV, P_LOCAL, &sDefault.bNo_set_dir, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1261 {"wide links", P_BOOL, P_LOCAL, &sDefault.bWidelinks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1262 {"follow symlinks", P_BOOL, P_LOCAL, &sDefault.bSymlinks, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1263 {"dont descend", P_STRING, P_LOCAL, &sDefault.szDontdescend, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1264 {"magic script", P_STRING, P_LOCAL, &sDefault.szMagicScript, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1265 {"magic output", P_STRING, P_LOCAL, &sDefault.szMagicOutput, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1266 {"delete readonly", P_BOOL, P_LOCAL, &sDefault.bDeleteReadonly, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1267 {"dos filemode", P_BOOL, P_LOCAL, &sDefault.bDosFilemode, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1268 {"dos filetimes", P_BOOL, P_LOCAL, &sDefault.bDosFiletimes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1269 {"dos filetime resolution", P_BOOL, P_LOCAL, &sDefault.bDosFiletimeResolution, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1270
1271 {"fake directory create times", P_BOOL, P_LOCAL, &sDefault.bFakeDirCreateTimes, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE | FLAG_GLOBAL},
1272 {"panic action", P_STRING, P_GLOBAL, &Globals.szPanicAction, NULL, NULL, FLAG_ADVANCED},
1273
1274 {N_("VFS module options"), P_SEP, P_SEPARATOR},
1275
1276 {"vfs objects", P_LIST, P_LOCAL, &sDefault.szVfsObjects, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1277 {"vfs object", P_LIST, P_LOCAL, &sDefault.szVfsObjects, NULL, NULL, FLAG_HIDE},
1278
1279
1280 {"msdfs root", P_BOOL, P_LOCAL, &sDefault.bMSDfsRoot, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1281 {"msdfs proxy", P_STRING, P_LOCAL, &sDefault.szMSDfsProxy, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
1282 {"host msdfs", P_BOOL, P_GLOBAL, &Globals.bHostMSDfs, NULL, NULL, FLAG_ADVANCED},
1283
1284 {N_("Winbind options"), P_SEP, P_SEPARATOR},
1285
1286 {"passdb expand explicit", P_BOOL, P_GLOBAL, &Globals.bPassdbExpandExplicit, NULL, NULL, FLAG_ADVANCED},
1287 {"idmap domains", P_LIST, P_GLOBAL, &Globals.szIdmapDomains, NULL, NULL, FLAG_ADVANCED},
1288 {"idmap backend", P_LIST, P_GLOBAL, &Globals.szIdmapBackend, NULL, NULL, FLAG_ADVANCED },
1289 {"idmap alloc backend", P_STRING, P_GLOBAL, &Globals.szIdmapAllocBackend, NULL, NULL, FLAG_ADVANCED},
1290 {"idmap cache time", P_INTEGER, P_GLOBAL, &Globals.iIdmapCacheTime, NULL, NULL, FLAG_ADVANCED},
1291 {"idmap negative cache time", P_INTEGER, P_GLOBAL, &Globals.iIdmapNegativeCacheTime, NULL, NULL, FLAG_ADVANCED},
1292 {"idmap uid", P_STRING, P_GLOBAL, &Globals.szIdmapUID, handle_idmap_uid, NULL, FLAG_ADVANCED },
1293 {"winbind uid", P_STRING, P_GLOBAL, &Globals.szIdmapUID, handle_idmap_uid, NULL, FLAG_HIDE },
1294 {"idmap gid", P_STRING, P_GLOBAL, &Globals.szIdmapGID, handle_idmap_gid, NULL, FLAG_ADVANCED },
1295 {"winbind gid", P_STRING, P_GLOBAL, &Globals.szIdmapGID, handle_idmap_gid, NULL, FLAG_HIDE },
1296 {"template homedir", P_STRING, P_GLOBAL, &Globals.szTemplateHomedir, NULL, NULL, FLAG_ADVANCED},
1297 {"template shell", P_STRING, P_GLOBAL, &Globals.szTemplateShell, NULL, NULL, FLAG_ADVANCED},
1298 {"winbind separator", P_STRING, P_GLOBAL, &Globals.szWinbindSeparator, NULL, NULL, FLAG_ADVANCED},
1299 {"winbind cache time", P_INTEGER, P_GLOBAL, &Globals.winbind_cache_time, NULL, NULL, FLAG_ADVANCED},
1300 {"winbind enum users", P_BOOL, P_GLOBAL, &Globals.bWinbindEnumUsers, NULL, NULL, FLAG_ADVANCED},
1301 {"winbind enum groups", P_BOOL, P_GLOBAL, &Globals.bWinbindEnumGroups, NULL, NULL, FLAG_ADVANCED},
1302 {"winbind use default domain", P_BOOL, P_GLOBAL, &Globals.bWinbindUseDefaultDomain, NULL, NULL, FLAG_ADVANCED},
1303 {"winbind trusted domains only", P_BOOL, P_GLOBAL, &Globals.bWinbindTrustedDomainsOnly, NULL, NULL, FLAG_ADVANCED},
1304 {"winbind nested groups", P_BOOL, P_GLOBAL, &Globals.bWinbindNestedGroups, NULL, NULL, FLAG_ADVANCED},
1305 {"winbind nss info", P_LIST, P_GLOBAL, &Globals.szWinbindNssInfo, NULL, NULL, FLAG_ADVANCED},
1306 {"winbind refresh tickets", P_BOOL, P_GLOBAL, &Globals.bWinbindRefreshTickets, NULL, NULL, FLAG_ADVANCED},
1307 {"winbind offline logon", P_BOOL, P_GLOBAL, &Globals.bWinbindOfflineLogon, NULL, NULL, FLAG_ADVANCED},
1308 {"winbind normalize names", P_BOOL, P_GLOBAL, &Globals.bWinbindNormalizeNames, NULL, NULL, FLAG_ADVANCED},
1309
1310 {NULL, P_BOOL, P_NONE, NULL, NULL, NULL, 0}
1311 };
1312
1313 /***************************************************************************
1314 Initialise the sDefault parameter structure for the printer values.
1315 ***************************************************************************/
1316
1317 static void init_printer_values(service *pService)
1318 {
1319 /* choose defaults depending on the type of printing */
1320 switch (pService->iPrinting) {
1321 case PRINT_BSD:
1322 case PRINT_AIX:
1323 case PRINT_LPRNT:
1324 case PRINT_LPROS2:
1325 string_set(&pService->szLpqcommand, "lpq -P'%p'");
1326 string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
1327 string_set(&pService->szPrintcommand, "lpr -r -P'%p' %s");
1328 break;
1329
1330 case PRINT_LPRNG:
1331 case PRINT_PLP:
1332 string_set(&pService->szLpqcommand, "lpq -P'%p'");
1333 string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
1334 string_set(&pService->szPrintcommand, "lpr -r -P'%p' %s");
1335 string_set(&pService->szQueuepausecommand, "lpc stop '%p'");
1336 string_set(&pService->szQueueresumecommand, "lpc start '%p'");
1337 string_set(&pService->szLppausecommand, "lpc hold '%p' %j");
1338 string_set(&pService->szLpresumecommand, "lpc release '%p' %j");
1339 break;
1340
1341 case PRINT_CUPS:
1342 case PRINT_IPRINT:
1343 #ifdef HAVE_CUPS
1344 /* set the lpq command to contain the destination printer
1345 name only. This is used by cups_queue_get() */
1346 string_set(&pService->szLpqcommand, "%p");
1347 string_set(&pService->szLprmcommand, "");
1348 string_set(&pService->szPrintcommand, "");
1349 string_set(&pService->szLppausecommand, "");
1350 string_set(&pService->szLpresumecommand, "");
1351 string_set(&pService->szQueuepausecommand, "");
1352 string_set(&pService->szQueueresumecommand, "");
1353 #else
1354 string_set(&pService->szLpqcommand, "lpq -P'%p'");
1355 string_set(&pService->szLprmcommand, "lprm -P'%p' %j");
1356 string_set(&pService->szPrintcommand, "lpr -P'%p' %s; rm %s");
1357 string_set(&pService->szLppausecommand, "lp -i '%p-%j' -H hold");
1358 string_set(&pService->szLpresumecommand, "lp -i '%p-%j' -H resume");
1359 string_set(&pService->szQueuepausecommand, "disable '%p'");
1360 string_set(&pService->szQueueresumecommand, "enable '%p'");
1361 #endif /* HAVE_CUPS */
1362 break;
1363
1364 case PRINT_SYSV:
1365 case PRINT_HPUX:
1366 string_set(&pService->szLpqcommand, "lpstat -o%p");
1367 string_set(&pService->szLprmcommand, "cancel %p-%j");
1368 string_set(&pService->szPrintcommand, "lp -c -d%p %s; rm %s");
1369 string_set(&pService->szQueuepausecommand, "disable %p");
1370 string_set(&pService->szQueueresumecommand, "enable %p");
1371 #ifndef HPUX
1372 string_set(&pService->szLppausecommand, "lp -i %p-%j -H hold");
1373 string_set(&pService->szLpresumecommand, "lp -i %p-%j -H resume");
1374 #endif /* HPUX */
1375 break;
1376
1377 case PRINT_QNX:
1378 string_set(&pService->szLpqcommand, "lpq -P%p");
1379 string_set(&pService->szLprmcommand, "lprm -P%p %j");
1380 string_set(&pService->szPrintcommand, "lp -r -P%p %s");
1381 break;
1382
1383 #ifdef DEVELOPER
1384 case PRINT_TEST:
1385 case PRINT_VLP:
1386 string_set(&pService->szPrintcommand, "vlp print %p %s");
1387 string_set(&pService->szLpqcommand, "vlp lpq %p");
1388 string_set(&pService->szLprmcommand, "vlp lprm %p %j");
1389 string_set(&pService->szLppausecommand, "vlp lppause %p %j");
1390 string_set(&pService->szLpresumecommand, "vlp lpresum %p %j");
1391 string_set(&pService->szQueuepausecommand, "vlp queuepause %p");
1392 string_set(&pService->szQueueresumecommand, "vlp queueresume %p");
1393 break;
1394 #endif /* DEVELOPER */
1395
1396 }
1397 }
1398
1399 /***************************************************************************
1400 Initialise the global parameter structure.
1401 ***************************************************************************/
1402
1403 static void init_globals(BOOL first_time_only)
1404 {
1405 static BOOL done_init = False;
1406 pstring s;
1407
1408 /* If requested to initialize only once and we've already done it... */
1409 if (first_time_only && done_init) {
1410 /* ... then we have nothing more to do */
1411 return;
1412 }
1413
1414 if (!done_init) {
1415 int i;
1416
1417 /* The logfile can be set before this is invoked. Free it if so. */
1418 if (Globals.szLogFile != NULL) {
1419 string_free(&Globals.szLogFile);
1420 Globals.szLogFile = NULL;
1421 }
1422
1423 memset((void *)&Globals, '\0', sizeof(Globals));
1424
1425 for (i = 0; parm_table[i].label; i++)
1426 if ((parm_table[i].type == P_STRING ||
1427 parm_table[i].type == P_USTRING) &&
1428 parm_table[i].ptr)
1429 string_set((char **)parm_table[i].ptr, "");
1430
1431 string_set(&sDefault.fstype, FSTYPE_STRING);
1432 string_set(&sDefault.szPrintjobUsername, "%U");
1433
1434 init_printer_values(&sDefault);
1435
1436 done_init = True;
1437 }
1438
1439
1440 DEBUG(3, ("Initialising global parameters\n"));
1441
1442 string_set(&Globals.szSMBPasswdFile, dyn_SMB_PASSWD_FILE);
1443 string_set(&Globals.szPrivateDir, dyn_PRIVATE_DIR);
1444
1445 /* use the new 'hash2' method by default, with a prefix of 1 */
1446 string_set(&Globals.szManglingMethod, "hash2");
1447 Globals.mangle_prefix = 1;
1448
1449 string_set(&Globals.szGuestaccount, GUEST_ACCOUNT);
1450
1451 /* using UTF8 by default allows us to support all chars */
1452 string_set(&Globals.unix_charset, DEFAULT_UNIX_CHARSET);
1453
1454 #if defined(HAVE_NL_LANGINFO) && defined(CODESET)
1455 /* If the system supports nl_langinfo(), try to grab the value
1456 from the user's locale */
1457 string_set(&Globals.display_charset, "LOCALE");
1458 #else
1459 string_set(&Globals.display_charset, DEFAULT_DISPLAY_CHARSET);
1460 #endif
1461
1462 /* Use codepage 850 as a default for the dos character set */
1463 string_set(&Globals.dos_charset, DEFAULT_DOS_CHARSET);
1464
1465 /*
1466 * Allow the default PASSWD_CHAT to be overridden in local.h.
1467 */
1468 string_set(&Globals.szPasswdChat, DEFAULT_PASSWD_CHAT);
1469
1470 set_global_myname(myhostname());
1471 string_set(&Globals.szNetbiosName,global_myname());
1472
1473 set_global_myworkgroup(WORKGROUP);
1474 string_set(&Globals.szWorkgroup, lp_workgroup());
1475
1476 string_set(&Globals.szPasswdProgram, "");
1477 string_set(&Globals.szPidDir, dyn_PIDDIR);
1478 string_set(&Globals.szLockDir, dyn_LOCKDIR);
1479 string_set(&Globals.szSocketAddress, "0.0.0.0");
1480 pstrcpy(s, "Samba ");
1481 pstrcat(s, SAMBA_VERSION_STRING);
1482 string_set(&Globals.szServerString, s);
1483 slprintf(s, sizeof(s) - 1, "%d.%d", DEFAULT_MAJOR_VERSION,
1484 DEFAULT_MINOR_VERSION);
1485 string_set(&Globals.szAnnounceVersion, s);
1486 #ifdef DEVELOPER
1487 string_set(&Globals.szPanicAction, "/bin/sleep 999999999");
1488 #endif
1489
1490 pstrcpy(user_socket_options, DEFAULT_SOCKET_OPTIONS);
1491
1492 string_set(&Globals.szLogonDrive, "");
1493 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
1494 string_set(&Globals.szLogonHome, "\\\\%N\\%U");
1495 string_set(&Globals.szLogonPath, "\\\\%N\\%U\\profile");
1496
1497 string_set(&Globals.szNameResolveOrder, "lmhosts wins host bcast");
1498 string_set(&Globals.szPasswordServer, "*");
1499
1500 Globals.AlgorithmicRidBase = BASE_RID;
1501
1502 Globals.bLoadPrinters = True;
1503 Globals.PrintcapCacheTime = 750; /* 12.5 minutes */
1504
1505 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
1506 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
1507 Globals.max_xmit = 0x4104;
1508 Globals.max_mux = 50; /* This is *needed* for profile support. */
1509 Globals.lpqcachetime = 30; /* changed to handle large print servers better -- jerry */
1510 Globals.bDisableSpoolss = False;
1511 Globals.iMaxSmbdProcesses = 0;/* no limit specified */
1512 Globals.pwordlevel = 0;
1513 Globals.unamelevel = 0;
1514 Globals.deadtime = 0;
1515 Globals.bLargeReadwrite = True;
1516 Globals.max_log_size = 5000;
1517 Globals.max_open_files = MAX_OPEN_FILES;
1518 Globals.open_files_db_hash_size = SMB_OPEN_DATABASE_TDB_HASH_SIZE;
1519 Globals.maxprotocol = PROTOCOL_NT1;
1520 Globals.minprotocol = PROTOCOL_CORE;
1521 Globals.security = SEC_USER;
1522 Globals.paranoid_server_security = True;
1523 Globals.bEncryptPasswords = True;
1524 Globals.bUpdateEncrypt = False;
1525 Globals.clientSchannel = Auto;
1526 Globals.serverSchannel = Auto;
1527 Globals.bReadRaw = True;
1528 Globals.bWriteRaw = True;
1529 Globals.bReadbmpx = False;
1530 Globals.bNullPasswords = False;
1531 Globals.bObeyPamRestrictions = False;
1532 Globals.syslog = 1;
1533 Globals.bSyslogOnly = False;
1534 Globals.bTimestampLogs = True;
1535 string_set(&Globals.szLogLevel, "0");
1536 Globals.bDebugPrefixTimestamp = False;
1537 Globals.bDebugHiresTimestamp = False;
1538 Globals.bDebugPid = False;
1539 Globals.bDebugUid = False;
1540 Globals.bEnableCoreFiles = True;
1541 Globals.max_ttl = 60 * 60 * 24 * 3; /* 3 days default. */
1542 Globals.max_wins_ttl = 60 * 60 * 24 * 6; /* 6 days default. */
1543 Globals.min_wins_ttl = 60 * 60 * 6; /* 6 hours default. */
1544 Globals.machine_password_timeout = 60 * 60 * 24 * 7; /* 7 days default. */
1545 Globals.lm_announce = 2; /* = Auto: send only if LM clients found */
1546 Globals.lm_interval = 60;
1547 Globals.announce_as = ANNOUNCE_AS_NT_SERVER;
1548 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1549 Globals.bNISHomeMap = False;
1550 #ifdef WITH_NISPLUS_HOME
1551 string_set(&Globals.szNISHomeMapName, "auto_home.org_dir");
1552 #else
1553 string_set(&Globals.szNISHomeMapName, "auto.home");
1554 #endif
1555 #endif
1556 Globals.bTimeServer = False;
1557 Globals.bBindInterfacesOnly = False;
1558 Globals.bUnixPasswdSync = False;
1559 Globals.bPamPasswordChange = False;
1560 Globals.bPasswdChatDebug = False;
1561 Globals.iPasswdChatTimeout = 2; /* 2 second default. */
1562 Globals.bNTPipeSupport = True; /* Do NT pipes by default. */
1563 Globals.bNTStatusSupport = True; /* Use NT status by default. */
1564 Globals.bStatCache = True; /* use stat cache by default */
1565 Globals.iMaxStatCacheSize = 1024; /* one Meg by default. */
1566 Globals.restrict_anonymous = 0;
1567 Globals.bClientLanManAuth = True; /* Do use the LanMan hash if it is available */
1568 Globals.bClientPlaintextAuth = True; /* Do use a plaintext password if is requested by the server */
1569 Globals.bLanmanAuth = True; /* Do use the LanMan hash if it is available */
1570 Globals.bNTLMAuth = True; /* Do use NTLMv1 if it is available (otherwise NTLMv2) */
1571 Globals.bClientNTLMv2Auth = False; /* Client should not use NTLMv2, as we can't tell that the server supports it. */
1572 /* Note, that we will use NTLM2 session security (which is different), if it is available */
1573
1574 Globals.map_to_guest = 0; /* By Default, "Never" */
1575 Globals.oplock_break_wait_time = 0; /* By Default, 0 msecs. */
1576 Globals.enhanced_browsing = True;
1577 Globals.iLockSpinTime = WINDOWS_MINIMUM_LOCK_TIMEOUT_MS; /* msec. */
1578 #ifdef MMAP_BLACKLIST
1579 Globals.bUseMmap = False;
1580 #else
1581 Globals.bUseMmap = True;
1582 #endif
1583 Globals.bUnixExtensions = True;
1584 Globals.bResetOnZeroVC = False;
1585
1586 /* hostname lookups can be very expensive and are broken on
1587 a large number of sites (tridge) */
1588 Globals.bHostnameLookups = False;
1589
1590 string_set(&Globals.szPassdbBackend, "smbpasswd");
1591 string_set(&Globals.szLdapSuffix, "");
1592 string_set(&Globals.szLdapMachineSuffix, "");
1593 string_set(&Globals.szLdapUserSuffix, "");
1594 string_set(&Globals.szLdapGroupSuffix, "");
1595 string_set(&Globals.szLdapIdmapSuffix, "");
1596
1597 string_set(&Globals.szLdapAdminDn, "");
1598 Globals.ldap_ssl = LDAP_SSL_OFF;
1599 Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
1600 Globals.ldap_delete_dn = False;
1601 Globals.ldap_replication_sleep = 1000; /* wait 1 sec for replication */
1602 Globals.ldap_timeout = LDAP_CONNECT_DEFAULT_TIMEOUT;
1603 Globals.ldap_page_size = LDAP_PAGE_SIZE;
1604
1605 Globals.ldap_debug_level = 0;
1606 Globals.ldap_debug_threshold = 10;
1607
1608 /* This is what we tell the afs client. in reality we set the token
1609 * to never expire, though, when this runs out the afs client will
1610 * forget the token. Set to 0 to get NEVERDATE.*/
1611 Globals.iAfsTokenLifetime = 604800;
1612
1613 /* these parameters are set to defaults that are more appropriate
1614 for the increasing samba install base:
1615
1616 as a member of the workgroup, that will possibly become a
1617 _local_ master browser (lm = True). this is opposed to a forced
1618 local master browser startup (pm = True).
1619
1620 doesn't provide WINS server service by default (wsupp = False),
1621 and doesn't provide domain master browser services by default, either.
1622
1623 */
1624
1625 Globals.bMsAddPrinterWizard = True;
1626 Globals.bPreferredMaster = Auto; /* depending on bDomainMaster */
1627 Globals.os_level = 20;
1628 Globals.bLocalMaster = True;
1629 Globals.bDomainMaster = Auto; /* depending on bDomainLogons */
1630 Globals.bDomainLogons = False;
1631 Globals.bBrowseList = True;
1632 Globals.bWINSsupport = False;
1633 Globals.bWINSproxy = False;
1634
1635 Globals.bDNSproxy = True;
1636
1637 /* this just means to use them if they exist */
1638 Globals.bKernelOplocks = True;
1639
1640 Globals.bAllowTrustedDomains = True;
1641
1642 string_set(&Globals.szTemplateShell, "/bin/false");
1643 string_set(&Globals.szTemplateHomedir, "/home/%D/%U");
1644 string_set(&Globals.szWinbindSeparator, "\\");
1645
1646 string_set(&Globals.szCupsServer, "");
1647 string_set(&Globals.szIPrintServer, "");
1648
1649 Globals.winbind_cache_time = 300; /* 5 minutes */
1650 Globals.bWinbindEnumUsers = False;
1651 Globals.bWinbindEnumGroups = False;
1652 Globals.bWinbindUseDefaultDomain = False;
1653 Globals.bWinbindTrustedDomainsOnly = False;
1654 Globals.bWinbindNestedGroups = True;
1655 Globals.szWinbindNssInfo = str_list_make("template", NULL);
1656 Globals.bWinbindRefreshTickets = False;
1657 Globals.bWinbindOfflineLogon = False;
1658
1659 Globals.iIdmapCacheTime = 900; /* 15 minutes by default */
1660 Globals.iIdmapNegativeCacheTime = 120; /* 2 minutes by default */
1661
1662 Globals.bPassdbExpandExplicit = False;
1663
1664 Globals.name_cache_timeout = 660; /* In seconds */
1665
1666 Globals.bUseSpnego = True;
1667 Globals.bClientUseSpnego = True;
1668
1669 Globals.client_signing = Auto;
1670 Globals.server_signing = False;
1671
1672 Globals.bDeferSharingViolations = True;
1673 string_set(&Globals.smb_ports, SMB_PORTS);
1674
1675 Globals.bEnablePrivileges = True;
1676 Globals.bHostMSDfs = True;
1677 Globals.bASUSupport = False;
1678
1679 /* User defined shares. */
1680 pstrcpy(s, dyn_LOCKDIR);
1681 pstrcat(s, "/usershares");
1682 string_set(&Globals.szUsersharePath, s);
1683 string_set(&Globals.szUsershareTemplateShare, "");
1684 Globals.iUsershareMaxShares = 0;
1685 /* By default disallow sharing of directories not owned by the sharer. */
1686 Globals.bUsershareOwnerOnly = True;
1687 /* By default disallow guest access to usershares. */
1688 Globals.bUsershareAllowGuests = False;
1689 }
1690
1691 static TALLOC_CTX *lp_talloc;
1692
1693 /******************************************************************* a
1694 Free up temporary memory - called from the main loop.
1695 ********************************************************************/
1696
1697 void lp_TALLOC_FREE(void)
1698 {
1699 if (!lp_talloc)
1700 return;
1701 TALLOC_FREE(lp_talloc);
1702 lp_talloc = NULL;
1703 }
1704
1705 TALLOC_CTX *tmp_talloc_ctx(void)
1706 {
1707 if (lp_talloc == NULL) {
1708 lp_talloc = talloc_init("tmp_talloc_ctx");
1709 }
1710
1711 if (lp_talloc == NULL) {
1712 smb_panic("Could not create temporary talloc context\n");
1713 }
1714
1715 return lp_talloc;
1716 }
1717
1718 /*******************************************************************
1719 Convenience routine to grab string parameters into temporary memory
1720 and run standard_sub_basic on them. The buffers can be written to by
1721 callers without affecting the source string.
1722 ********************************************************************/
1723
1724 static char *lp_string(const char *s)
1725 {
1726 char *ret, *tmpstr;
1727
1728 /* The follow debug is useful for tracking down memory problems
1729 especially if you have an inner loop that is calling a lp_*()
1730 function that returns a string. Perhaps this debug should be
1731 present all the time? */
1732
1733 #if 0
1734 DEBUG(10, ("lp_string(%s)\n", s));
1735 #endif
1736
1737 if (!lp_talloc)
1738 lp_talloc = talloc_init("lp_talloc");
1739
1740 tmpstr = alloc_sub_basic(get_current_username(),
1741 current_user_info.domain, s);
1742 if (trim_char(tmpstr, '\"', '\"')) {
1743 if (strchr(tmpstr,'\"') != NULL) {
1744 SAFE_FREE(tmpstr);
1745 tmpstr = alloc_sub_basic(get_current_username(),
1746 current_user_info.domain, s);
1747 }
1748 }
1749 ret = talloc_strdup(lp_talloc, tmpstr);
1750 SAFE_FREE(tmpstr);
1751
1752 return (ret);
1753 }
1754
1755 /*
1756 In this section all the functions that are used to access the
1757 parameters from the rest of the program are defined
1758 */
1759
1760 #define FN_GLOBAL_STRING(fn_name,ptr) \
1761 char *fn_name(void) {return(lp_string(*(char **)(ptr) ? *(char **)(ptr) : ""));}
1762 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1763 const char *fn_name(void) {return(*(const char **)(ptr) ? *(const char **)(ptr) : "");}
1764 #define FN_GLOBAL_LIST(fn_name,ptr) \
1765 const char **fn_name(void) {return(*(const char ***)(ptr));}
1766 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1767 BOOL fn_name(void) {return(*(BOOL *)(ptr));}
1768 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1769 char fn_name(void) {return(*(char *)(ptr));}
1770 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1771 int fn_name(void) {return(*(int *)(ptr));}
1772
1773 #define FN_LOCAL_STRING(fn_name,val) \
1774 char *fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
1775 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1776 const char *fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1777 #define FN_LOCAL_LIST(fn_name,val) \
1778 const char **fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1779 #define FN_LOCAL_BOOL(fn_name,val) \
1780 BOOL fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1781 #define FN_LOCAL_INTEGER(fn_name,val) \
1782 int fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1783
1784 #define FN_LOCAL_PARM_BOOL(fn_name,val) \
1785 BOOL fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1786 #define FN_LOCAL_PARM_INTEGER(fn_name,val) \
1787 int fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1788 #define FN_LOCAL_PARM_STRING(fn_name,val) \
1789 char *fn_name(const struct share_params *p) {return(lp_string((LP_SNUM_OK(p->service) && ServicePtrs[(p->service)]->val) ? ServicePtrs[(p->service)]->val : sDefault.val));}
1790 #define FN_LOCAL_CHAR(fn_name,val) \
1791 char fn_name(const struct share_params *p) {return(LP_SNUM_OK(p->service)? ServicePtrs[(p->service)]->val : sDefault.val);}
1792
1793 FN_GLOBAL_STRING(lp_smb_ports, &Globals.smb_ports)
1794 FN_GLOBAL_STRING(lp_dos_charset, &Globals.dos_charset)
1795 FN_GLOBAL_STRING(lp_unix_charset, &Globals.unix_charset)
1796 FN_GLOBAL_STRING(lp_display_charset, &Globals.display_charset)
1797 FN_GLOBAL_STRING(lp_logfile, &Globals.szLogFile)
1798 FN_GLOBAL_STRING(lp_configfile, &Globals.szConfigFile)
1799 FN_GLOBAL_STRING(lp_smb_passwd_file, &Globals.szSMBPasswdFile)
1800 FN_GLOBAL_STRING(lp_private_dir, &Globals.szPrivateDir)
1801 FN_GLOBAL_STRING(lp_serverstring, &Globals.szServerString)
1802 FN_GLOBAL_INTEGER(lp_printcap_cache_time, &Globals.PrintcapCacheTime)
1803 FN_GLOBAL_STRING(lp_addport_cmd, &Globals.szAddPortCommand)
1804 FN_GLOBAL_STRING(lp_enumports_cmd, &Globals.szEnumPortsCommand)
1805 FN_GLOBAL_STRING(lp_addprinter_cmd, &Globals.szAddPrinterCommand)
1806 FN_GLOBAL_STRING(lp_deleteprinter_cmd, &Globals.szDeletePrinterCommand)
1807 FN_GLOBAL_STRING(lp_os2_driver_map, &Globals.szOs2DriverMap)
1808 FN_GLOBAL_STRING(lp_lockdir, &Globals.szLockDir)
1809 FN_GLOBAL_STRING(lp_piddir, &Globals.szPidDir)
1810 FN_GLOBAL_STRING(lp_mangling_method, &Globals.szManglingMethod)
1811 FN_GLOBAL_INTEGER(lp_mangle_prefix, &Globals.mangle_prefix)
1812 FN_GLOBAL_STRING(lp_utmpdir, &Globals.szUtmpDir)
1813 FN_GLOBAL_STRING(lp_wtmpdir, &Globals.szWtmpDir)
1814 FN_GLOBAL_BOOL(lp_utmp, &Globals.bUtmp)
1815 FN_GLOBAL_STRING(lp_rootdir, &Globals.szRootdir)
1816 FN_GLOBAL_STRING(lp_defaultservice, &Globals.szDefaultService)
1817 FN_GLOBAL_STRING(lp_msg_command, &Globals.szMsgCommand)
1818 FN_GLOBAL_STRING(lp_get_quota_command, &Globals.szGetQuota)
1819 FN_GLOBAL_STRING(lp_set_quota_command, &Globals.szSetQuota)
1820 FN_GLOBAL_STRING(lp_auto_services, &Globals.szAutoServices)
1821 FN_GLOBAL_STRING(lp_passwd_program, &Globals.szPasswdProgram)
1822 FN_GLOBAL_STRING(lp_passwd_chat, &Globals.szPasswdChat)
1823 FN_GLOBAL_STRING(lp_passwordserver, &Globals.szPasswordServer)
1824 FN_GLOBAL_STRING(lp_name_resolve_order, &Globals.szNameResolveOrder)
1825 FN_GLOBAL_STRING(lp_realm, &Globals.szRealm)
1826 FN_GLOBAL_CONST_STRING(lp_afs_username_map, &Globals.szAfsUsernameMap)
1827 FN_GLOBAL_INTEGER(lp_afs_token_lifetime, &Globals.iAfsTokenLifetime)
1828 FN_GLOBAL_STRING(lp_log_nt_token_command, &Globals.szLogNtTokenCommand)
1829 FN_GLOBAL_STRING(lp_username_map, &Globals.szUsernameMap)
1830 FN_GLOBAL_CONST_STRING(lp_logon_script, &Globals.szLogonScript)
1831 FN_GLOBAL_CONST_STRING(lp_logon_path, &Globals.szLogonPath)
1832 FN_GLOBAL_CONST_STRING(lp_logon_drive, &Globals.szLogonDrive)
1833 FN_GLOBAL_CONST_STRING(lp_logon_home, &Globals.szLogonHome)
1834 FN_GLOBAL_STRING(lp_remote_announce, &Globals.szRemoteAnnounce)
1835 FN_GLOBAL_STRING(lp_remote_browse_sync, &Globals.szRemoteBrowseSync)
1836 FN_GLOBAL_LIST(lp_wins_server_list, &Globals.szWINSservers)
1837 FN_GLOBAL_LIST(lp_interfaces, &Globals.szInterfaces)
1838 FN_GLOBAL_STRING(lp_socket_address, &Globals.szSocketAddress)
1839 FN_GLOBAL_STRING(lp_nis_home_map_name, &Globals.szNISHomeMapName)
1840 static FN_GLOBAL_STRING(lp_announce_version, &Globals.szAnnounceVersion)
1841 FN_GLOBAL_LIST(lp_netbios_aliases, &Globals.szNetbiosAliases)
1842 /* FN_GLOBAL_STRING(lp_passdb_backend, &Globals.szPassdbBackend)
1843 * lp_passdb_backend() should be replace by the this macro again after
1844 * some releases.
1845 * */
1846 const char *lp_passdb_backend(void)
1847 {
1848 char *delim, *quote;
1849
1850 delim = strchr( Globals.szPassdbBackend, ' ');
1851 /* no space at all */
1852 if (delim == NULL) {
1853 goto out;
1854 }
1855
1856 quote = strchr(Globals.szPassdbBackend, '"');
1857 /* no quote char or non in the first part */
1858 if (quote == NULL || quote > delim) {
1859 *delim = '\0';
1860 goto warn;
1861 }
1862
1863 quote = strchr(quote+1, '"');
1864 if (quote == NULL) {
1865 DEBUG(0, ("WARNING: Your 'passdb backend' configuration is invalid due to a missing second \" char.\n"));
1866 goto out;
1867 } else if (*(quote+1) == '\0') {
1868 /* space, fitting quote char, and one backend only */
1869 goto out;
1870 } else {
1871 /* terminate string after the fitting quote char */
1872 *(quote+1) = '\0';
1873 }
1874
1875 warn:
1876 DEBUG(0, ("WARNING: Your 'passdb backend' configuration includes multiple backends. This\n"
1877 "is deprecated since Samba 3.0.23. Please check WHATSNEW.txt or the section 'Passdb\n"
1878 "Changes' from the ChangeNotes as part of the Samba HOWTO collection. Only the first\n"
1879 "backend (%s) is used. The rest is ignored.\n", Globals.szPassdbBackend));
1880
1881 out:
1882 return Globals.szPassdbBackend;
1883 }
1884 FN_GLOBAL_LIST(lp_preload_modules, &Globals.szPreloadModules)
1885 FN_GLOBAL_STRING(lp_panic_action, &Globals.szPanicAction)
1886 FN_GLOBAL_STRING(lp_adduser_script, &Globals.szAddUserScript)
1887 FN_GLOBAL_STRING(lp_renameuser_script, &Globals.szRenameUserScript)
1888 FN_GLOBAL_STRING(lp_deluser_script, &Globals.szDelUserScript)
1889
1890 FN_GLOBAL_CONST_STRING(lp_guestaccount, &Globals.szGuestaccount)
1891 FN_GLOBAL_STRING(lp_addgroup_script, &Globals.szAddGroupScript)
1892 FN_GLOBAL_STRING(lp_delgroup_script, &Globals.szDelGroupScript)
1893 FN_GLOBAL_STRING(lp_addusertogroup_script, &Globals.szAddUserToGroupScript)
1894 FN_GLOBAL_STRING(lp_deluserfromgroup_script, &Globals.szDelUserFromGroupScript)
1895 FN_GLOBAL_STRING(lp_setprimarygroup_script, &Globals.szSetPrimaryGroupScript)
1896
1897 FN_GLOBAL_STRING(lp_addmachine_script, &Globals.szAddMachineScript)
1898
1899 FN_GLOBAL_STRING(lp_shutdown_script, &Globals.szShutdownScript)
1900 FN_GLOBAL_STRING(lp_abort_shutdown_script, &Globals.szAbortShutdownScript)
1901 FN_GLOBAL_STRING(lp_username_map_script, &Globals.szUsernameMapScript)
1902
1903 FN_GLOBAL_STRING(lp_check_password_script, &Globals.szCheckPasswordScript)
1904
1905 FN_GLOBAL_STRING(lp_wins_hook, &Globals.szWINSHook)
1906 FN_GLOBAL_CONST_STRING(lp_template_homedir, &Globals.szTemplateHomedir)
1907 FN_GLOBAL_CONST_STRING(lp_template_shell, &Globals.szTemplateShell)
1908 FN_GLOBAL_CONST_STRING(lp_winbind_separator, &Globals.szWinbindSeparator)
1909 FN_GLOBAL_INTEGER(lp_acl_compatibility, &Globals.iAclCompat)
1910 FN_GLOBAL_BOOL(lp_winbind_enum_users, &Globals.bWinbindEnumUsers)
1911 FN_GLOBAL_BOOL(lp_winbind_enum_groups, &Globals.bWinbindEnumGroups)
1912 FN_GLOBAL_BOOL(lp_winbind_use_default_domain, &Globals.bWinbindUseDefaultDomain)
1913 FN_GLOBAL_BOOL(lp_winbind_trusted_domains_only, &Globals.bWinbindTrustedDomainsOnly)
1914 FN_GLOBAL_BOOL(lp_winbind_nested_groups, &Globals.bWinbindNestedGroups)
1915 FN_GLOBAL_BOOL(lp_winbind_refresh_tickets, &Globals.bWinbindRefreshTickets)
1916 FN_GLOBAL_BOOL(lp_winbind_offline_logon, &Globals.bWinbindOfflineLogon)
1917 FN_GLOBAL_BOOL(lp_winbind_normalize_names, &Globals.bWinbindNormalizeNames)
1918
1919 FN_GLOBAL_LIST(lp_idmap_domains, &Globals.szIdmapDomains)
1920 FN_GLOBAL_LIST(lp_idmap_backend, &Globals.szIdmapBackend) /* deprecated */
1921 FN_GLOBAL_STRING(lp_idmap_alloc_backend, &Globals.szIdmapAllocBackend)
1922 FN_GLOBAL_INTEGER(lp_idmap_cache_time, &Globals.iIdmapCacheTime)
1923 FN_GLOBAL_INTEGER(lp_idmap_negative_cache_time, &Globals.iIdmapNegativeCacheTime)
1924 FN_GLOBAL_BOOL(lp_passdb_expand_explicit, &Globals.bPassdbExpandExplicit)
1925
1926 FN_GLOBAL_STRING(lp_ldap_suffix, &Globals.szLdapSuffix)
1927 FN_GLOBAL_STRING(lp_ldap_admin_dn, &Globals.szLdapAdminDn)
1928 FN_GLOBAL_INTEGER(lp_ldap_ssl, &Globals.ldap_ssl)
1929 FN_GLOBAL_INTEGER(lp_ldap_passwd_sync, &Globals.ldap_passwd_sync)
1930 FN_GLOBAL_BOOL(lp_ldap_delete_dn, &Globals.ldap_delete_dn)
1931 FN_GLOBAL_INTEGER(lp_ldap_replication_sleep, &Globals.ldap_replication_sleep)
1932 FN_GLOBAL_INTEGER(lp_ldap_timeout, &Globals.ldap_timeout)
1933 FN_GLOBAL_INTEGER(lp_ldap_page_size, &Globals.ldap_page_size)
1934 FN_GLOBAL_INTEGER(lp_ldap_debug_level, &Globals.ldap_debug_level)
1935 FN_GLOBAL_INTEGER(lp_ldap_debug_threshold, &Globals.ldap_debug_threshold)
1936 FN_GLOBAL_STRING(lp_add_share_cmd, &Globals.szAddShareCommand)
1937 FN_GLOBAL_STRING(lp_change_share_cmd, &Globals.szChangeShareCommand)
1938 FN_GLOBAL_STRING(lp_delete_share_cmd, &Globals.szDeleteShareCommand)
1939 FN_GLOBAL_STRING(lp_usershare_path, &Globals.szUsersharePath)
1940 FN_GLOBAL_LIST(lp_usershare_prefix_allow_list, &Globals.szUsersharePrefixAllowList)
1941 FN_GLOBAL_LIST(lp_usershare_prefix_deny_list, &Globals.szUsersharePrefixDenyList)
1942
1943 FN_GLOBAL_LIST(lp_eventlog_list, &Globals.szEventLogs)
1944
1945 FN_GLOBAL_BOOL(lp_usershare_allow_guests, &Globals.bUsershareAllowGuests)
1946 FN_GLOBAL_BOOL(lp_usershare_owner_only, &Globals.bUsershareOwnerOnly)
1947 FN_GLOBAL_BOOL(lp_disable_netbios, &Globals.bDisableNetbios)
1948 FN_GLOBAL_BOOL(lp_reset_on_zero_vc, &Globals.bResetOnZeroVC)
1949 FN_GLOBAL_BOOL(lp_ms_add_printer_wizard, &Globals.bMsAddPrinterWizard)
1950 FN_GLOBAL_BOOL(lp_dns_proxy, &Globals.bDNSproxy)
1951 FN_GLOBAL_BOOL(lp_wins_support, &Globals.bWINSsupport)
1952 FN_GLOBAL_BOOL(lp_we_are_a_wins_server, &Globals.bWINSsupport)
1953 FN_GLOBAL_BOOL(lp_wins_proxy, &Globals.bWINSproxy)
1954 FN_GLOBAL_BOOL(lp_local_master, &Globals.bLocalMaster)
1955 FN_GLOBAL_BOOL(lp_domain_logons, &Globals.bDomainLogons)
1956 FN_GLOBAL_BOOL(lp_load_printers, &Globals.bLoadPrinters)
1957 FN_GLOBAL_BOOL(lp_readbmpx, &Globals.bReadbmpx)
1958 FN_GLOBAL_BOOL(lp_readraw, &Globals.bReadRaw)
1959 FN_GLOBAL_BOOL(lp_large_readwrite, &Globals.bLargeReadwrite)
1960 FN_GLOBAL_BOOL(lp_writeraw, &Globals.bWriteRaw)
1961 FN_GLOBAL_BOOL(lp_null_passwords, &Globals.bNullPasswords)
1962 FN_GLOBAL_BOOL(lp_obey_pam_restrictions, &Globals.bObeyPamRestrictions)
1963 FN_GLOBAL_BOOL(lp_encrypted_passwords, &Globals.bEncryptPasswords)
1964 FN_GLOBAL_BOOL(lp_update_encrypted, &Globals.bUpdateEncrypt)
1965 FN_GLOBAL_INTEGER(lp_client_schannel, &Globals.clientSchannel)
1966 FN_GLOBAL_INTEGER(lp_server_schannel, &Globals.serverSchannel)
1967 FN_GLOBAL_BOOL(lp_syslog_only, &Globals.bSyslogOnly)
1968 FN_GLOBAL_BOOL(lp_timestamp_logs, &Globals.bTimestampLogs)
1969 FN_GLOBAL_BOOL(lp_debug_prefix_timestamp, &Globals.bDebugPrefixTimestamp)
1970 FN_GLOBAL_BOOL(lp_debug_hires_timestamp, &Globals.bDebugHiresTimestamp)
1971 FN_GLOBAL_BOOL(lp_debug_pid, &Globals.bDebugPid)
1972 FN_GLOBAL_BOOL(lp_debug_uid, &Globals.bDebugUid)
1973 FN_GLOBAL_BOOL(lp_enable_core_files, &Globals.bEnableCoreFiles)
1974 FN_GLOBAL_BOOL(lp_browse_list, &Globals.bBrowseList)
1975 FN_GLOBAL_BOOL(lp_nis_home_map, &Globals.bNISHomeMap)
1976 static FN_GLOBAL_BOOL(lp_time_server, &Globals.bTimeServer)
1977 FN_GLOBAL_BOOL(lp_bind_interfaces_only, &Globals.bBindInterfacesOnly)
1978 FN_GLOBAL_BOOL(lp_pam_password_change, &Globals.bPamPasswordChange)
1979 FN_GLOBAL_BOOL(lp_unix_password_sync, &Globals.bUnixPasswdSync)
1980 FN_GLOBAL_BOOL(lp_passwd_chat_debug, &Globals.bPasswdChatDebug)
1981 FN_GLOBAL_INTEGER(lp_passwd_chat_timeout, &Globals.iPasswdChatTimeout)
1982 FN_GLOBAL_BOOL(lp_nt_pipe_support, &Globals.bNTPipeSupport)
1983 FN_GLOBAL_BOOL(lp_nt_status_support, &Globals.bNTStatusSupport)
1984 FN_GLOBAL_BOOL(lp_stat_cache, &Globals.bStatCache)
1985 FN_GLOBAL_INTEGER(lp_max_stat_cache_size, &Globals.iMaxStatCacheSize)
1986 FN_GLOBAL_BOOL(lp_allow_trusted_domains, &Globals.bAllowTrustedDomains)
1987 FN_GLOBAL_INTEGER(lp_restrict_anonymous, &Globals.restrict_anonymous)
1988 FN_GLOBAL_BOOL(lp_lanman_auth, &Globals.bLanmanAuth)
1989 FN_GLOBAL_BOOL(lp_ntlm_auth, &Globals.bNTLMAuth)
1990 FN_GLOBAL_BOOL(lp_client_plaintext_auth, &Globals.bClientPlaintextAuth)
1991 FN_GLOBAL_BOOL(lp_client_lanman_auth, &Globals.bClientLanManAuth)
1992 FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, &Globals.bClientNTLMv2Auth)
1993 FN_GLOBAL_BOOL(lp_host_msdfs, &Globals.bHostMSDfs)
1994 FN_GLOBAL_BOOL(lp_kernel_oplocks, &Globals.bKernelOplocks)
1995 FN_GLOBAL_BOOL(lp_enhanced_browsing, &Globals.enhanced_browsing)
1996 FN_GLOBAL_BOOL(lp_use_mmap, &Globals.bUseMmap)
1997 FN_GLOBAL_BOOL(lp_unix_extensions, &Globals.bUnixExtensions)
1998 FN_GLOBAL_BOOL(lp_use_spnego, &Globals.bUseSpnego)
1999 FN_GLOBAL_BOOL(lp_client_use_spnego, &Globals.bClientUseSpnego)
2000 FN_GLOBAL_BOOL(lp_hostname_lookups, &Globals.bHostnameLookups)
2001 FN_LOCAL_PARM_BOOL(lp_change_notify, bChangeNotify)
2002 FN_LOCAL_PARM_BOOL(lp_kernel_change_notify, bKernelChangeNotify)
2003 FN_GLOBAL_BOOL(lp_use_kerberos_keytab, &Globals.bUseKerberosKeytab)
2004 FN_GLOBAL_BOOL(lp_defer_sharing_violations, &Globals.bDeferSharingViolations)
2005 FN_GLOBAL_BOOL(lp_enable_privileges, &Globals.bEnablePrivileges)
2006 FN_GLOBAL_BOOL(lp_enable_asu_support, &Globals.bASUSupport)
2007 FN_GLOBAL_INTEGER(lp_os_level, &Globals.os_level)
2008 FN_GLOBAL_INTEGER(lp_max_ttl, &Globals.max_ttl)
2009 FN_GLOBAL_INTEGER(lp_max_wins_ttl, &Globals.max_wins_ttl)
2010 FN_GLOBAL_INTEGER(lp_min_wins_ttl, &Globals.min_wins_ttl)
2011 FN_GLOBAL_INTEGER(lp_max_log_size, &Globals.max_log_size)
2012 FN_GLOBAL_INTEGER(lp_max_open_files, &Globals.max_open_files)
2013 FN_GLOBAL_INTEGER(lp_open_files_db_hash_size, &Globals.open_files_db_hash_size)
2014 FN_GLOBAL_INTEGER(lp_maxxmit, &Globals.max_xmit)
2015 FN_GLOBAL_INTEGER(lp_maxmux, &Globals.max_mux)
2016 FN_GLOBAL_INTEGER(lp_passwordlevel, &Globals.pwordlevel)
2017 FN_GLOBAL_INTEGER(lp_usernamelevel, &Globals.unamelevel)
2018 FN_GLOBAL_INTEGER(lp_deadtime, &Globals.deadtime)
2019 FN_GLOBAL_INTEGER(lp_maxprotocol, &Globals.maxprotocol)
2020 FN_GLOBAL_INTEGER(lp_minprotocol, &Globals.minprotocol)
2021 FN_GLOBAL_INTEGER(lp_security, &Globals.security)
2022 FN_GLOBAL_LIST(lp_auth_methods, &Globals.AuthMethods)
2023 FN_GLOBAL_BOOL(lp_paranoid_server_security, &Globals.paranoid_server_security)
2024 FN_GLOBAL_INTEGER(lp_maxdisksize, &Globals.maxdisksize)
2025 FN_GLOBAL_INTEGER(lp_lpqcachetime, &Globals.lpqcachetime)
2026 FN_GLOBAL_INTEGER(lp_max_smbd_processes, &Globals.iMaxSmbdProcesses)
2027 FN_GLOBAL_INTEGER(_lp_disable_spoolss, &Globals.bDisableSpoolss)
2028 FN_GLOBAL_INTEGER(lp_syslog, &Globals.syslog)
2029 static FN_GLOBAL_INTEGER(lp_announce_as, &Globals.announce_as)
2030 FN_GLOBAL_INTEGER(lp_lm_announce, &Globals.lm_announce)
2031 FN_GLOBAL_INTEGER(lp_lm_interval, &Globals.lm_interval)
2032 FN_GLOBAL_INTEGER(lp_machine_password_timeout, &Globals.machine_password_timeout)
2033 FN_GLOBAL_INTEGER(lp_map_to_guest, &Globals.map_to_guest)
2034 FN_GLOBAL_INTEGER(lp_oplock_break_wait_time, &Globals.oplock_break_wait_time)
2035 FN_GLOBAL_INTEGER(lp_lock_spin_time, &Globals.iLockSpinTime)
2036 FN_GLOBAL_INTEGER(lp_usershare_max_shares, &Globals.iUsershareMaxShares)
2037
2038 FN_LOCAL_STRING(lp_preexec, szPreExec)
2039 FN_LOCAL_STRING(lp_postexec, szPostExec)
2040 FN_LOCAL_STRING(lp_rootpreexec, szRootPreExec)
2041 FN_LOCAL_STRING(lp_rootpostexec, szRootPostExec)
2042 FN_LOCAL_STRING(lp_servicename, szService)
2043 FN_LOCAL_CONST_STRING(lp_const_servicename, szService)
2044 FN_LOCAL_STRING(lp_pathname, szPath)
2045 FN_LOCAL_STRING(lp_dontdescend, szDontdescend)
2046 FN_LOCAL_STRING(lp_username, szUsername)
2047 FN_LOCAL_LIST(lp_invalid_users, szInvalidUsers)
2048 FN_LOCAL_LIST(lp_valid_users, szValidUsers)
2049 FN_LOCAL_LIST(lp_admin_users, szAdminUsers)
2050 FN_GLOBAL_LIST(lp_svcctl_list, &Globals.szServicesList)
2051 FN_LOCAL_STRING(lp_cups_options, szCupsOptions)
2052 FN_GLOBAL_STRING(lp_cups_server, &Globals.szCupsServer)
2053 FN_GLOBAL_STRING(lp_iprint_server, &Globals.szIPrintServer)
2054 FN_LOCAL_STRING(lp_printcommand, szPrintcommand)
2055 FN_LOCAL_STRING(lp_lpqcommand, szLpqcommand)
2056 FN_LOCAL_STRING(lp_lprmcommand, szLprmcommand)
2057 FN_LOCAL_STRING(lp_lppausecommand, szLppausecommand)
2058 FN_LOCAL_STRING(lp_lpresumecommand, szLpresumecommand)
2059 FN_LOCAL_STRING(lp_queuepausecommand, szQueuepausecommand)
2060 FN_LOCAL_STRING(lp_queueresumecommand, szQueueresumecommand)
2061 static FN_LOCAL_STRING(_lp_printername, szPrintername)
2062 FN_LOCAL_CONST_STRING(lp_printjob_username, szPrintjobUsername)
2063 FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
2064 FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
2065 FN_LOCAL_STRING(lp_magicscript, szMagicScript)
2066 FN_LOCAL_STRING(lp_magicoutput, szMagicOutput)
2067 FN_LOCAL_STRING(lp_comment, comment)
2068 FN_LOCAL_STRING(lp_force_user, force_user)
2069 FN_LOCAL_STRING(lp_force_group, force_group)
2070 FN_LOCAL_LIST(lp_readlist, readlist)
2071 FN_LOCAL_LIST(lp_writelist, writelist)
2072 FN_LOCAL_LIST(lp_printer_admin, printer_admin)
2073 FN_LOCAL_STRING(lp_fstype, fstype)
2074 FN_LOCAL_LIST(lp_vfs_objects, szVfsObjects)
2075 FN_LOCAL_STRING(lp_msdfs_proxy, szMSDfsProxy)
2076 static FN_LOCAL_STRING(lp_volume, volume)
2077 FN_LOCAL_PARM_STRING(lp_mangled_map, szMangledMap)
2078 FN_LOCAL_STRING(lp_veto_files, szVetoFiles)
2079 FN_LOCAL_STRING(lp_hide_files, szHideFiles)
2080 FN_LOCAL_STRING(lp_veto_oplocks, szVetoOplockFiles)
2081 FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
2082 FN_LOCAL_STRING(lp_aio_write_behind, szAioWriteBehind)
2083 FN_LOCAL_STRING(lp_dfree_command, szDfree)
2084 FN_LOCAL_BOOL(lp_autoloaded, autoloaded)
2085 FN_LOCAL_BOOL(lp_preexec_close, bPreexecClose)
2086 FN_LOCAL_BOOL(lp_rootpreexec_close, bRootpreexecClose)
2087 FN_LOCAL_INTEGER(lp_casesensitive, iCaseSensitive)
2088 FN_LOCAL_BOOL(lp_preservecase, bCasePreserve)
2089 FN_LOCAL_BOOL(lp_shortpreservecase, bShortCasePreserve)
2090 FN_LOCAL_BOOL(lp_hide_dot_files, bHideDotFiles)
2091 FN_LOCAL_BOOL(lp_hide_special_files, bHideSpecialFiles)
2092 FN_LOCAL_BOOL(lp_hideunreadable, bHideUnReadable)
2093 FN_LOCAL_BOOL(lp_hideunwriteable_files, bHideUnWriteableFiles)
2094 FN_LOCAL_BOOL(lp_browseable, bBrowseable)
2095 FN_LOCAL_BOOL(lp_readonly, bRead_only)
2096 FN_LOCAL_BOOL(lp_no_set_dir, bNo_set_dir)
2097 FN_LOCAL_BOOL(lp_guest_ok, bGuest_ok)
2098 FN_LOCAL_BOOL(lp_guest_only, bGuest_only)
2099 FN_LOCAL_BOOL(lp_administrative_share, bAdministrative_share)
2100 FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
2101 FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
2102 FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
2103 FN_LOCAL_BOOL(lp_store_dos_attributes, bStoreDosAttributes)
2104 FN_LOCAL_BOOL(lp_dmapi_support, bDmapiSupport)
2105 FN_LOCAL_PARM_BOOL(lp_locking, bLocking)
2106 FN_LOCAL_PARM_INTEGER(lp_strict_locking, iStrictLocking)
2107 FN_LOCAL_PARM_BOOL(lp_posix_locking, bPosixLocking)
2108 FN_LOCAL_BOOL(lp_share_modes, bShareModes)
2109 FN_LOCAL_BOOL(lp_oplocks, bOpLocks)
2110 FN_LOCAL_BOOL(lp_level2_oplocks, bLevel2OpLocks)
2111 FN_LOCAL_BOOL(lp_onlyuser, bOnlyUser)
2112 FN_LOCAL_PARM_BOOL(lp_manglednames, bMangledNames)
2113 FN_LOCAL_BOOL(lp_widelinks, bWidelinks)
2114 FN_LOCAL_BOOL(lp_symlinks, bSymlinks)
2115 FN_LOCAL_BOOL(lp_syncalways, bSyncAlways)
2116 FN_LOCAL_BOOL(lp_strict_allocate, bStrictAllocate)
2117 FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
2118 FN_LOCAL_BOOL(lp_map_system, bMap_system)
2119 FN_LOCAL_BOOL(lp_delete_readonly, bDeleteReadonly)
2120 FN_LOCAL_BOOL(lp_fake_oplocks, bFakeOplocks)
2121 FN_LOCAL_BOOL(lp_recursive_veto_delete, bDeleteVetoFiles)
2122 FN_LOCAL_BOOL(lp_dos_filemode, bDosFilemode)
2123 FN_LOCAL_BOOL(lp_dos_filetimes, bDosFiletimes)
2124 FN_LOCAL_BOOL(lp_dos_filetime_resolution, bDosFiletimeResolution)
2125 FN_LOCAL_BOOL(lp_fake_dir_create_times, bFakeDirCreateTimes)
2126 FN_LOCAL_BOOL(lp_blocking_locks, bBlockingLocks)
2127 FN_LOCAL_BOOL(lp_inherit_perms, bInheritPerms)
2128 FN_LOCAL_BOOL(lp_inherit_acls, bInheritACLS)
2129 FN_LOCAL_BOOL(lp_inherit_owner, bInheritOwner)
2130 FN_LOCAL_BOOL(lp_use_client_driver, bUseClientDriver)
2131 FN_LOCAL_BOOL(lp_default_devmode, bDefaultDevmode)
2132 FN_LOCAL_BOOL(lp_force_printername, bForcePrintername)
2133 FN_LOCAL_BOOL(lp_nt_acl_support, bNTAclSupport)
2134 FN_LOCAL_BOOL(lp_force_unknown_acl_user, bForceUnknownAclUser)
2135 FN_LOCAL_BOOL(lp_ea_support, bEASupport)
2136 FN_LOCAL_BOOL(_lp_use_sendfile, bUseSendfile)
2137 FN_LOCAL_BOOL(lp_profile_acls, bProfileAcls)
2138 FN_LOCAL_BOOL(lp_map_acl_inherit, bMap_acl_inherit)
2139 FN_LOCAL_BOOL(lp_afs_share, bAfs_Share)
2140 FN_LOCAL_BOOL(lp_acl_check_permissions, bAclCheckPermissions)
2141 FN_LOCAL_BOOL(lp_acl_group_control, bAclGroupControl)
2142 FN_LOCAL_BOOL(lp_acl_map_full_control, bAclMapFullControl)
2143 FN_LOCAL_INTEGER(lp_create_mask, iCreate_mask)
2144 FN_LOCAL_INTEGER(lp_force_create_mode, iCreate_force_mode)
2145 FN_LOCAL_INTEGER(lp_security_mask, iSecurity_mask)
2146 FN_LOCAL_INTEGER(lp_force_security_mode, iSecurity_force_mode)
2147 FN_LOCAL_INTEGER(lp_dir_mask, iDir_mask)
2148 FN_LOCAL_INTEGER(lp_force_dir_mode, iDir_force_mode)
2149 FN_LOCAL_INTEGER(lp_dir_security_mask, iDir_Security_mask)
2150 FN_LOCAL_INTEGER(lp_force_dir_security_mode, iDir_Security_force_mode)
2151 FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
2152 FN_LOCAL_INTEGER(lp_defaultcase, iDefaultCase)
2153 FN_LOCAL_INTEGER(lp_minprintspace, iMinPrintSpace)
2154 FN_LOCAL_INTEGER(lp_printing, iPrinting)
2155 FN_LOCAL_INTEGER(lp_max_reported_jobs, iMaxReportedPrintJobs)
2156 FN_LOCAL_INTEGER(lp_oplock_contention_limit, iOplockContentionLimit)
2157 FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
2158 FN_LOCAL_INTEGER(lp_write_cache_size, iWriteCacheSize)
2159 FN_LOCAL_INTEGER(lp_block_size, iBlock_size)
2160 FN_LOCAL_INTEGER(lp_dfree_cache_time, iDfreeCacheTime)
2161 FN_LOCAL_INTEGER(lp_allocation_roundup_size, iallocation_roundup_size)
2162 FN_LOCAL_INTEGER(lp_aio_read_size, iAioReadSize)
2163 FN_LOCAL_INTEGER(lp_aio_write_size, iAioWriteSize)
2164 FN_LOCAL_INTEGER(lp_map_readonly, iMap_readonly)
2165 FN_LOCAL_INTEGER(lp_directory_name_cache_size, iDirectoryNameCacheSize)
2166 FN_LOCAL_CHAR(lp_magicchar, magic_char)
2167 FN_GLOBAL_INTEGER(lp_winbind_cache_time, &Globals.winbind_cache_time)
2168 FN_GLOBAL_LIST(lp_winbind_nss_info, &Globals.szWinbindNssInfo)
2169 FN_GLOBAL_INTEGER(lp_algorithmic_rid_base, &Globals.AlgorithmicRidBase)
2170 FN_GLOBAL_INTEGER(lp_name_cache_timeout, &Globals.name_cache_timeout)
2171 FN_GLOBAL_INTEGER(lp_client_signing, &Globals.client_signing)
2172 FN_GLOBAL_INTEGER(lp_server_signing, &Globals.server_signing)
2173
2174 /* local prototypes */
2175
2176 static int map_parameter(const char *pszParmName);
2177 static BOOL set_boolean(BOOL *pb, const char *pszParmValue);
2178 static int getservicebyname(const char *pszServiceName,
2179 service * pserviceDest);
2180 static void copy_service(service * pserviceDest,
2181 service * pserviceSource, BOOL *pcopymapDest);
2182 static BOOL service_ok(int iService);
2183 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue);
2184 static BOOL do_section(const char *pszSectionName);
2185 static void init_copymap(service * pservice);
2186 static BOOL hash_a_service(const char *name, int number);
2187 static void free_service_byindex(int iService);
2188 static char * canonicalize_servicename(const char *name);
2189
2190 /* This is a helper function for parametrical options support. */
2191 /* It returns a pointer to parametrical option value if it exists or NULL otherwise */
2192 /* Actual parametrical functions are quite simple */
2193 static param_opt_struct *get_parametrics(int snum, const char *type, const char *option)
2194 {
2195 BOOL global_section = False;
2196 char* param_key;
2197 param_opt_struct *data;
2198
2199 if (snum >= iNumServices) return NULL;
2200
2201 if (snum < 0) {
2202 data = Globals.param_opt;
2203 global_section = True;
2204 } else {
2205 data = ServicePtrs[snum]->param_opt;
2206 }
2207
2208 asprintf(&param_key, "%s:%s", type, option);
2209 if (!param_key) {
2210 DEBUG(0,("asprintf failed!\n"));
2211 return NULL;
2212 }
2213
2214 while (data) {
2215 if (strcmp(data->key, param_key) == 0) {
2216 string_free(&param_key);
2217 return data;
2218 }
2219 data = data->next;
2220 }
2221
2222 if (!global_section) {
2223 /* Try to fetch the same option but from globals */
2224 /* but only if we are not already working with Globals */
2225 data = Globals.param_opt;
2226 while (data) {
2227 if (strcmp(data->key, param_key) == 0) {
2228 string_free(&param_key);
2229 return data;
2230 }
2231 data = data->next;
2232 }
2233 }
2234
2235 string_free(&param_key);
2236
2237 return NULL;
2238 }
2239
2240
2241 #define MISSING_PARAMETER(name) \
2242 DEBUG(0, ("%s(): value is NULL or empty!\n", #name))
2243
2244 /*******************************************************************
2245 convenience routine to return int parameters.
2246 ********************************************************************/
2247 static int lp_int(const char *s)
2248 {
2249
2250 if (!s || !*s) {
2251 MISSING_PARAMETER(lp_int);
2252 return (-1);
2253 }
2254
2255 return (int)strtol(s, NULL, 0);
2256 }
2257
2258 /*******************************************************************
2259 convenience routine to return unsigned long parameters.
2260 ********************************************************************/
2261 static unsigned long lp_ulong(const char *s)
2262 {
2263
2264 if (!s || !*s) {
2265 MISSING_PARAMETER(lp_ulong);
2266 return (0);
2267 }
2268
2269 return strtoul(s, NULL, 0);
2270 }
2271
2272 /*******************************************************************
2273 convenience routine to return boolean parameters.
2274 ********************************************************************/
2275 static BOOL lp_bool(const char *s)
2276 {
2277 BOOL ret = False;
2278
2279 if (!s || !*s) {
2280 MISSING_PARAMETER(lp_bool);
2281 return False;
2282 }
2283
2284 if (!set_boolean(&ret,s)) {
2285 DEBUG(0,("lp_bool(%s): value is not boolean!\n",s));
2286 return False;
2287 }
2288
2289 return ret;
2290 }
2291
2292 /*******************************************************************
2293 convenience routine to return enum parameters.
2294 ********************************************************************/
2295 static int lp_enum(const char *s,const struct enum_list *_enum)
2296 {
2297 int i;
2298
2299 if (!s || !*s || !_enum) {
2300 MISSING_PARAMETER(lp_enum);
2301 return (-1);
2302 }
2303
2304 for (i=0; _enum[i].name; i++) {
2305 if (strequal(_enum[i].name,s))
2306 return _enum[i].value;
2307 }
2308
2309 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
2310 return (-1);
2311 }
2312
2313 #undef MISSING_PARAMETER
2314
2315 /* DO NOT USE lp_parm_string ANYMORE!!!!
2316 * use lp_parm_const_string or lp_parm_talloc_string
2317 *
2318 * lp_parm_string is only used to let old modules find this symbol
2319 */
2320 #undef lp_parm_string
2321 char *lp_parm_string(const char *servicename, const char *type, const char *option);
2322 char *lp_parm_string(const char *servicename, const char *type, const char *option)
2323 {
2324 return lp_parm_talloc_string(lp_servicenumber(servicename), type, option, NULL);
2325 }
2326
2327 /* Return parametric option from a given service. Type is a part of option before ':' */
2328 /* Parametric option has following syntax: 'Type: option = value' */
2329 /* the returned value is talloced in lp_talloc */
2330 char *lp_parm_talloc_string(int snum, const char *type, const char *option, const char *def)
2331 {
2332 param_opt_struct *data = get_parametrics(snum, type, option);
2333
2334 if (data == NULL||data->value==NULL) {
2335 if (def) {
2336 return lp_string(def);
2337 } else {
2338 return NULL;
2339 }
2340 }
2341
2342 return lp_string(data->value);
2343 }
2344
2345 /* Return parametric option from a given service. Type is a part of option before ':' */
2346 /* Parametric option has following syntax: 'Type: option = value' */
2347 const char *lp_parm_const_string(int snum, const char *type, const char *option, const char *def)
2348 {
2349 param_opt_struct *data = get_parametrics(snum, type, option);
2350
2351 if (data == NULL||data->value==NULL)
2352 return def;
2353
2354 return data->value;
2355 }
2356
2357 /* Return parametric option from a given service. Type is a part of option before ':' */
2358 /* Parametric option has following syntax: 'Type: option = value' */
2359
2360 const char **lp_parm_string_list(int snum, const char *type, const char *option, const char **def)
2361 {
2362 param_opt_struct *data = get_parametrics(snum, type, option);
2363
2364 if (data == NULL||data->value==NULL)
2365 return (const char **)def;
2366
2367 if (data->list==NULL) {
2368 data->list = str_list_make(data->value, NULL);
2369 }
2370
2371 return (const char **)data->list;
2372 }
2373
2374 /* Return parametric option from a given service. Type is a part of option before ':' */
2375 /* Parametric option has following syntax: 'Type: option = value' */
2376
2377 int lp_parm_int(int snum, const char *type, const char *option, int def)
2378 {
2379 param_opt_struct *data = get_parametrics(snum, type, option);
2380
2381 if (data && data->value && *data->value)
2382 return lp_int(data->value);
2383
2384 return def;
2385 }
2386
2387 /* Return parametric option from a given service. Type is a part of option before ':' */
2388 /* Parametric option has following syntax: 'Type: option = value' */
2389
2390 unsigned long lp_parm_ulong(int snum, const char *type, const char *option, unsigned long def)
2391 {
2392 param_opt_struct *data = get_parametrics(snum, type, option);
2393
2394 if (data && data->value && *data->value)
2395 return lp_ulong(data->value);
2396
2397 return def;
2398 }
2399
2400 /* Return parametric option from a given service. Type is a part of option before ':' */
2401 /* Parametric option has following syntax: 'Type: option = value' */
2402
2403 BOOL lp_parm_bool(int snum, const char *type, const char *option, BOOL def)
2404 {
2405 param_opt_struct *data = get_parametrics(snum, type, option);
2406
2407 if (data && data->value && *data->value)
2408 return lp_bool(data->value);
2409
2410 return def;
2411 }
2412
2413 /* Return parametric option from a given service. Type is a part of option before ':' */
2414 /* Parametric option has following syntax: 'Type: option = value' */
2415
2416 int lp_parm_enum(int snum, const char *type, const char *option,
2417 const struct enum_list *_enum, int def)
2418 {
2419 param_opt_struct *data = get_parametrics(snum, type, option);
2420
2421 if (data && data->value && *data->value && _enum)
2422 return lp_enum(data->value, _enum);
2423
2424 return def;
2425 }
2426
2427
2428 /***************************************************************************
2429 Initialise a service to the defaults.
2430 ***************************************************************************/
2431
2432 static void init_service(service * pservice)
2433 {
2434 memset((char *)pservice, '\0', sizeof(service));
2435 copy_service(pservice, &sDefault, NULL);
2436 }
2437
2438 /***************************************************************************
2439 Free the dynamically allocated parts of a service struct.
2440 ***************************************************************************/
2441
2442 static void free_service(service *pservice)
2443 {
2444 int i;
2445 param_opt_struct *data, *pdata;
2446 if (!pservice)
2447 return;
2448
2449 if (pservice->szService)
2450 DEBUG(5, ("free_service: Freeing service %s\n",
2451 pservice->szService));
2452
2453 string_free(&pservice->szService);
2454 SAFE_FREE(pservice->copymap);
2455
2456 for (i = 0; parm_table[i].label; i++) {
2457 if ((parm_table[i].type == P_STRING ||
2458 parm_table[i].type == P_USTRING) &&
2459 parm_table[i].p_class == P_LOCAL)
2460 string_free((char **)
2461 (((char *)pservice) +
2462 PTR_DIFF(parm_table[i].ptr, &sDefault)));
2463 else if (parm_table[i].type == P_LIST &&
2464 parm_table[i].p_class == P_LOCAL)
2465 str_list_free((char ***)
2466 (((char *)pservice) +
2467 PTR_DIFF(parm_table[i].ptr, &sDefault)));
2468 }
2469
2470 data = pservice->param_opt;
2471 if (data)
2472 DEBUG(5,("Freeing parametrics:\n"));
2473 while (data) {
2474 DEBUG(5,("[%s = %s]\n", data->key, data->value));
2475 string_free(&data->key);
2476 string_free(&data->value);
2477 str_list_free(&data->list);
2478 pdata = data->next;
2479 SAFE_FREE(data);
2480 data = pdata;
2481 }
2482
2483 ZERO_STRUCTP(pservice);
2484 }
2485
2486
2487 /***************************************************************************
2488 remove a service indexed in the ServicePtrs array from the ServiceHash
2489 and free the dynamically allocated parts
2490 ***************************************************************************/
2491
2492 static void free_service_byindex(int idx)
2493 {
2494 if ( !LP_SNUM_OK(idx) )
2495 return;
2496
2497 ServicePtrs[idx]->valid = False;
2498 invalid_services[num_invalid_services++] = idx;
2499
2500 /* we have to cleanup the hash record */
2501
2502 if (ServicePtrs[idx]->szService) {
2503 char *canon_name = canonicalize_servicename( ServicePtrs[idx]->szService );
2504
2505 tdb_delete_bystring(ServiceHash, canon_name );
2506 }
2507
2508 free_service(ServicePtrs[idx]);
2509 }
2510
2511 /***************************************************************************
2512 Add a new service to the services array initialising it with the given
2513 service.
2514 ***************************************************************************/
2515
2516 static int add_a_service(const service *pservice, const char *name)
2517 {
2518 int i;
2519 service tservice;
2520 int num_to_alloc = iNumServices + 1;
2521 param_opt_struct *data, *pdata;
2522
2523 tservice = *pservice;
2524
2525 /* it might already exist */
2526 if (name) {
2527 i = getservicebyname(name, NULL);
2528 if (i >= 0) {
2529 /* Clean all parametric options for service */
2530 /* They will be added during parsing again */
2531 data = ServicePtrs[i]->param_opt;
2532 while (data) {
2533 string_free(&data->key);
2534 string_free(&data->value);
2535 str_list_free(&data->list);
2536 pdata = data->next;
2537 SAFE_FREE(data);
2538 data = pdata;
2539 }
2540 ServicePtrs[i]->param_opt = NULL;
2541 return (i);
2542 }
2543 }
2544
2545 /* find an invalid one */
2546 i = iNumServices;
2547 if (num_invalid_services > 0) {
2548 i = invalid_services[--num_invalid_services];
2549 }
2550
2551 /* if not, then create one */
2552 if (i == iNumServices) {
2553 service **tsp;
2554 int *tinvalid;
2555
2556 tsp = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(ServicePtrs, service *, num_to_alloc);
2557 if (tsp == NULL) {
2558 DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
2559 return (-1);
2560 }
2561 ServicePtrs = tsp;
2562 ServicePtrs[iNumServices] = SMB_MALLOC_P(service);
2563 if (!ServicePtrs[iNumServices]) {
2564 DEBUG(0,("add_a_service: out of memory!\n"));
2565 return (-1);
2566 }
2567 iNumServices++;
2568
2569 /* enlarge invalid_services here for now... */
2570 tinvalid = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(invalid_services, int,
2571 num_to_alloc);
2572 if (tinvalid == NULL) {
2573 DEBUG(0,("add_a_service: failed to enlarge "
2574 "invalid_services!\n"));
2575 return (-1);
2576 }
2577 invalid_services = tinvalid;
2578 } else {
2579 free_service_byindex(i);
2580 }
2581
2582 ServicePtrs[i]->valid = True;
2583
2584 init_service(ServicePtrs[i]);
2585 copy_service(ServicePtrs[i], &tservice, NULL);
2586 if (name)
2587 string_set(&ServicePtrs[i]->szService, name);
2588
2589 DEBUG(8,("add_a_service: Creating snum = %d for %s\n",
2590 i, ServicePtrs[i]->szService));
2591
2592 if (!hash_a_service(ServicePtrs[i]->szService, i)) {
2593 return (-1);
2594 }
2595
2596 return (i);
2597 }
2598
2599 /***************************************************************************
2600 Convert a string to uppercase and remove whitespaces.
2601 ***************************************************************************/
2602
2603 static char *canonicalize_servicename(const char *src)
2604 {
2605 static fstring canon; /* is fstring large enough? */
2606
2607 if ( !src ) {
2608 DEBUG(0,("canonicalize_servicename: NULL source name!\n"));
2609 return NULL;
2610 }
2611
2612 fstrcpy( canon, src );
2613 strlower_m( canon );
2614
2615 return canon;
2616 }
2617
2618 /***************************************************************************
2619 Add a name/index pair for the services array to the hash table.
2620 ***************************************************************************/
2621
2622 static BOOL hash_a_service(const char *name, int idx)
2623 {
2624 char *canon_name;
2625
2626 if ( !ServiceHash ) {
2627 DEBUG(10,("hash_a_service: creating tdb servicehash\n"));
2628 ServiceHash = tdb_open("servicehash", 1031, TDB_INTERNAL,
2629 (O_RDWR|O_CREAT), 0600);
2630 if ( !ServiceHash ) {
2631 DEBUG(0,("hash_a_service: open tdb servicehash failed!\n"));
2632 return False;
2633 }
2634 }
2635
2636 DEBUG(10,("hash_a_service: hashing index %d for service name %s\n",
2637 idx, name));
2638
2639 if ( !(canon_name = canonicalize_servicename( name )) )
2640 return False;
2641
2642 tdb_store_int32(ServiceHash, canon_name, idx);
2643
2644 return True;
2645 }
2646
2647 /***************************************************************************
2648 Add a new home service, with the specified home directory, defaults coming
2649 from service ifrom.
2650 ***************************************************************************/
2651
2652 BOOL lp_add_home(const char *pszHomename, int iDefaultService,
2653 const char *user, const char *pszHomedir)
2654 {
2655 int i;
2656 pstring newHomedir;
2657
2658 if (pszHomename == NULL || user == NULL || pszHomedir == NULL ||
2659 pszHomedir[0] == '\0') {
2660 return False;
2661 }
2662
2663 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
2664
2665 if (i < 0)
2666 return (False);
2667
2668 if (!(*(ServicePtrs[iDefaultService]->szPath))
2669 || strequal(ServicePtrs[iDefaultService]->szPath, lp_pathname(GLOBAL_SECTION_SNUM))) {
2670 pstrcpy(newHomedir, pszHomedir);
2671 string_set(&ServicePtrs[i]->szPath, newHomedir);
2672 }
2673
2674 if (!(*(ServicePtrs[i]->comment))) {
2675 pstring comment;
2676 slprintf(comment, sizeof(comment) - 1,
2677 "Home directory of %s", user);
2678 string_set(&ServicePtrs[i]->comment, comment);
2679 }
2680
2681 /* set the browseable flag from the global default */
2682
2683 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2684
2685 ServicePtrs[i]->autoloaded = True;
2686
2687 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
2688 user, ServicePtrs[i]->szPath ));
2689
2690 return (True);
2691 }
2692
2693 /***************************************************************************
2694 Add a new service, based on an old one.
2695 ***************************************************************************/
2696
2697 int lp_add_service(const char *pszService, int iDefaultService)
2698 {
2699 return (add_a_service(ServicePtrs[iDefaultService], pszService));
2700 }
2701
2702 /***************************************************************************
2703 Add the IPC service.
2704 ***************************************************************************/
2705
2706 static BOOL lp_add_ipc(const char *ipc_name, BOOL guest_ok)
2707 {
2708 pstring comment;
2709 int i = add_a_service(&sDefault, ipc_name);
2710
2711 if (i < 0)
2712 return (False);
2713
2714 slprintf(comment, sizeof(comment) - 1,
2715 "IPC Service (%s)", Globals.szServerString);
2716
2717 string_set(&ServicePtrs[i]->szPath, tmpdir());
2718 string_set(&ServicePtrs[i]->szUsername, "");
2719 string_set(&ServicePtrs[i]->comment, comment);
2720 string_set(&ServicePtrs[i]->fstype, "IPC");
2721 ServicePtrs[i]->iMaxConnections = 0;
2722 ServicePtrs[i]->bAvailable = True;
2723 ServicePtrs[i]->bRead_only = True;
2724 ServicePtrs[i]->bGuest_only = False;
2725 ServicePtrs[i]->bAdministrative_share = True;
2726 ServicePtrs[i]->bGuest_ok = guest_ok;
2727 ServicePtrs[i]->bPrint_ok = False;
2728 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2729
2730 DEBUG(3, ("adding IPC service\n"));
2731
2732 return (True);
2733 }
2734
2735 /***************************************************************************
2736 Add a new printer service, with defaults coming from service iFrom.
2737 ***************************************************************************/
2738
2739 BOOL lp_add_printer(const char *pszPrintername, int iDefaultService)
2740 {
2741 const char *comment = "From Printcap";
2742 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
2743
2744 if (i < 0)
2745 return (False);
2746
2747 /* note that we do NOT default the availability flag to True - */
2748 /* we take it from the default service passed. This allows all */
2749 /* dynamic printers to be disabled by disabling the [printers] */
2750 /* entry (if/when the 'available' keyword is implemented!). */
2751
2752 /* the printer name is set to the service name. */
2753 string_set(&ServicePtrs[i]->szPrintername, pszPrintername);
2754 string_set(&ServicePtrs[i]->comment, comment);
2755
2756 /* set the browseable flag from the gloabl default */
2757 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2758
2759 /* Printers cannot be read_only. */
2760 ServicePtrs[i]->bRead_only = False;
2761 /* No share modes on printer services. */
2762 ServicePtrs[i]->bShareModes = False;
2763 /* No oplocks on printer services. */
2764 ServicePtrs[i]->bOpLocks = False;
2765 /* Printer services must be printable. */
2766 ServicePtrs[i]->bPrint_ok = True;
2767
2768 DEBUG(3, ("adding printer service %s\n", pszPrintername));
2769
2770 return (True);
2771 }
2772
2773 /***************************************************************************
2774 Map a parameter's string representation to something we can use.
2775 Returns False if the parameter string is not recognised, else TRUE.
2776 ***************************************************************************/
2777
2778 static int map_parameter(const char *pszParmName)
2779 {
2780 int iIndex;
2781
2782 if (*pszParmName == '-' && !strequal(pszParmName, "-valid"))
2783 return (-1);
2784
2785 for (iIndex = 0; parm_table[iIndex].label; iIndex++)
2786 if (strwicmp(parm_table[iIndex].label, pszParmName) == 0)
2787 return (iIndex);
2788
2789 /* Warn only if it isn't parametric option */
2790 if (strchr(pszParmName, ':') == NULL)
2791 DEBUG(0, ("Unknown parameter encountered: \"%s\"\n", pszParmName));
2792 /* We do return 'fail' for parametric options as well because they are
2793 stored in different storage
2794 */
2795 return (-1);
2796 }
2797
2798 /***************************************************************************
2799 Show all parameter's name, type, [values,] and flags.
2800 ***************************************************************************/
2801
2802 void show_parameter_list(void)
2803 {
2804 int classIndex, parmIndex, enumIndex, flagIndex;
2805 BOOL hadFlag;
2806 const char *section_names[] = { "local", "global", NULL};
2807 const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
2808 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING", "P_GSTRING",
2809 "P_UGSTRING", "P_ENUM", "P_SEP"};
2810 unsigned flags[] = { FLAG_BASIC, FLAG_SHARE, FLAG_PRINT, FLAG_GLOBAL,
2811 FLAG_WIZARD, FLAG_ADVANCED, FLAG_DEVELOPER, FLAG_DEPRECATED,
2812 FLAG_HIDE, FLAG_DOS_STRING};
2813 const char *flag_names[] = { "FLAG_BASIC", "FLAG_SHARE", "FLAG_PRINT",
2814 "FLAG_GLOBAL", "FLAG_WIZARD", "FLAG_ADVANCED", "FLAG_DEVELOPER",
2815 "FLAG_DEPRECATED", "FLAG_HIDE", "FLAG_DOS_STRING", NULL};
2816
2817 for ( classIndex=0; section_names[classIndex]; classIndex++) {
2818 printf("[%s]\n", section_names[classIndex]);
2819 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
2820 if (parm_table[parmIndex].p_class == classIndex) {
2821 printf("%s=%s",
2822 parm_table[parmIndex].label,
2823 type[parm_table[parmIndex].type]);
2824 switch (parm_table[parmIndex].type) {
2825 case P_ENUM:
2826 printf(",");
2827 for (enumIndex=0; parm_table[parmIndex].enum_list[enumIndex].name; enumIndex++)
2828 printf("%s%s",
2829 enumIndex ? "|" : "",
2830 parm_table[parmIndex].enum_list[enumIndex].name);
2831 break;
2832 default:
2833 break;
2834 }
2835 printf(",");
2836 hadFlag = False;
2837 for ( flagIndex=0; flag_names[flagIndex]; flagIndex++ ) {
2838 if (parm_table[parmIndex].flags & flags[flagIndex]) {
2839 printf("%s%s",
2840 hadFlag ? "|" : "",
2841 flag_names[flagIndex]);
2842 hadFlag = True;
2843 }
2844 }
2845 printf("\n");
2846 }
2847 }
2848 }
2849 }
2850
2851 /***************************************************************************
2852 Set a boolean variable from the text value stored in the passed string.
2853 Returns True in success, False if the passed string does not correctly
2854 represent a boolean.
2855 ***************************************************************************/
2856
2857 static BOOL set_boolean(BOOL *pb, const char *pszParmValue)
2858 {
2859 BOOL bRetval;
2860
2861 bRetval = True;
2862 if (strwicmp(pszParmValue, "yes") == 0 ||
2863 strwicmp(pszParmValue, "true") == 0 ||
2864 strwicmp(pszParmValue, "1") == 0)
2865 *pb = True;
2866 else if (strwicmp(pszParmValue, "no") == 0 ||
2867 strwicmp(pszParmValue, "False") == 0 ||
2868 strwicmp(pszParmValue, "0") == 0)
2869 *pb = False;
2870 else {
2871 DEBUG(0,
2872 ("ERROR: Badly formed boolean in configuration file: \"%s\".\n",
2873 pszParmValue));
2874 bRetval = False;
2875 }
2876 return (bRetval);
2877 }
2878
2879 /***************************************************************************
2880 Find a service by name. Otherwise works like get_service.
2881 ***************************************************************************/
2882
2883 static int getservicebyname(const char *pszServiceName, service * pserviceDest)
2884 {
2885 int iService = -1;
2886 char *canon_name;
2887
2888 if (ServiceHash != NULL) {
2889 if ( !(canon_name = canonicalize_servicename( pszServiceName )) )
2890 return -1;
2891
2892 iService = tdb_fetch_int32(ServiceHash, canon_name );
2893
2894 if (LP_SNUM_OK(iService)) {
2895 if (pserviceDest != NULL) {
2896 copy_service(pserviceDest, ServicePtrs[iService], NULL);
2897 }
2898 } else {
2899 iService = -1;
2900 }
2901 }
2902
2903 return (iService);
2904 }
2905
2906 /***************************************************************************
2907 Copy a service structure to another.
2908 If pcopymapDest is NULL then copy all fields
2909 ***************************************************************************/
2910
2911 static void copy_service(service * pserviceDest, service * pserviceSource, BOOL *pcopymapDest)
2912 {
2913 int i;
2914 BOOL bcopyall = (pcopymapDest == NULL);
2915 param_opt_struct *data, *pdata, *paramo;
2916 BOOL not_added;
2917
2918 for (i = 0; parm_table[i].label; i++)
2919 if (parm_table[i].ptr && parm_table[i].p_class == P_LOCAL &&
2920 (bcopyall || pcopymapDest[i])) {
2921 void *def_ptr = parm_table[i].ptr;
2922 void *src_ptr =
2923 ((char *)pserviceSource) + PTR_DIFF(def_ptr,
2924 &sDefault);
2925 void *dest_ptr =
2926 ((char *)pserviceDest) + PTR_DIFF(def_ptr,
2927 &sDefault);
2928
2929 switch (parm_table[i].type) {
2930 case P_BOOL:
2931 case P_BOOLREV:
2932 *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
2933 break;
2934
2935 case P_INTEGER:
2936 case P_ENUM:
2937 case P_OCTAL:
2938 *(int *)dest_ptr = *(int *)src_ptr;
2939 break;
2940
2941 case P_CHAR:
2942 *(char *)dest_ptr = *(char *)src_ptr;
2943 break;
2944
2945 case P_STRING:
2946 string_set((char **)dest_ptr,
2947 *(char **)src_ptr);
2948 break;
2949
2950 case P_USTRING:
2951 string_set((char **)dest_ptr,
2952 *(char **)src_ptr);
2953 strupper_m(*(char **)dest_ptr);
2954 break;
2955 case P_LIST:
2956 str_list_free((char ***)dest_ptr);
2957 str_list_copy((char ***)dest_ptr, *(const char ***)src_ptr);
2958 break;
2959 default:
2960 break;
2961 }
2962 }
2963
2964 if (bcopyall) {
2965 init_copymap(pserviceDest);
2966 if (pserviceSource->copymap)
2967 memcpy((void *)pserviceDest->copymap,
2968 (void *)pserviceSource->copymap,
2969 sizeof(BOOL) * NUMPARAMETERS);
2970 }
2971
2972 data = pserviceSource->param_opt;
2973 while (data) {
2974 not_added = True;
2975 pdata = pserviceDest->param_opt;
2976 /* Traverse destination */
2977 while (pdata) {
2978 /* If we already have same option, override it */
2979 if (strcmp(pdata->key, data->key) == 0) {
2980 string_free(&pdata->value);
2981 str_list_free(&data->list);
2982 pdata->value = SMB_STRDUP(data->value);
2983 not_added = False;
2984 break;
2985 }
2986 pdata = pdata->next;
2987 }
2988 if (not_added) {
2989 paramo = SMB_XMALLOC_P(param_opt_struct);
2990 paramo->key = SMB_STRDUP(data->key);
2991 paramo->value = SMB_STRDUP(data->value);
2992 paramo->list = NULL;
2993 DLIST_ADD(pserviceDest->param_opt, paramo);
2994 }
2995 data = data->next;
2996 }
2997 }
2998
2999 /***************************************************************************
3000 Check a service for consistency. Return False if the service is in any way
3001 incomplete or faulty, else True.
3002 ***************************************************************************/
3003
3004 static BOOL service_ok(int iService)
3005 {
3006 BOOL bRetval;
3007
3008 bRetval = True;
3009 if (ServicePtrs[iService]->szService[0] == '\0') {
3010 DEBUG(0, ("The following message indicates an internal error:\n"));
3011 DEBUG(0, ("No service name in service entry.\n"));
3012 bRetval = False;
3013 }
3014
3015 /* The [printers] entry MUST be printable. I'm all for flexibility, but */
3016 /* I can't see why you'd want a non-printable printer service... */
3017 if (strwicmp(ServicePtrs[iService]->szService, PRINTERS_NAME) == 0) {
3018 if (!ServicePtrs[iService]->bPrint_ok) {
3019 DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
3020 ServicePtrs[iService]->szService));
3021 ServicePtrs[iService]->bPrint_ok = True;
3022 }
3023 /* [printers] service must also be non-browsable. */
3024 if (ServicePtrs[iService]->bBrowseable)
3025 ServicePtrs[iService]->bBrowseable = False;
3026 }
3027
3028 if (ServicePtrs[iService]->szPath[0] == '\0' &&
3029 strwicmp(ServicePtrs[iService]->szService, HOMES_NAME) != 0 &&
3030 ServicePtrs[iService]->szMSDfsProxy[0] == '\0'
3031 ) {
3032 DEBUG(0, ("WARNING: No path in service %s - making it unavailable!\n",
3033 ServicePtrs[iService]->szService));
3034 ServicePtrs[iService]->bAvailable = False;
3035 }
3036
3037 /* If a service is flagged unavailable, log the fact at level 0. */
3038 if (!ServicePtrs[iService]->bAvailable)
3039 DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
3040 ServicePtrs[iService]->szService));
3041
3042 return (bRetval);
3043 }
3044
3045 static struct file_lists {
3046 struct file_lists *next;
3047 char *name;
3048 char *subfname;
3049 time_t modtime;
3050 } *file_lists = NULL;
3051
3052 /*******************************************************************
3053 Keep a linked list of all config files so we know when one has changed
3054 it's date and needs to be reloaded.
3055 ********************************************************************/
3056
3057 static void add_to_file_list(const char *fname, const char *subfname)
3058 {
3059 struct file_lists *f = file_lists;
3060
3061 while (f) {
3062 if (f->name && !strcmp(f->name, fname))
3063 break;
3064 f = f->next;
3065 }
3066
3067 if (!f) {
3068 f = SMB_MALLOC_P(struct file_lists);
3069 if (!f)
3070 return;
3071 f->next = file_lists;
3072 f->name = SMB_STRDUP(fname);
3073 if (!f->name) {
3074 SAFE_FREE(f);
3075 return;
3076 }
3077 f->subfname = SMB_STRDUP(subfname);
3078 if (!f->subfname) {
3079 SAFE_FREE(f);
3080 return;
3081 }
3082 file_lists = f;
3083 f->modtime = file_modtime(subfname);
3084 } else {
3085 time_t t = file_modtime(subfname);
3086 if (t)
3087 f->modtime = t;
3088 }
3089 }
3090
3091 /*******************************************************************
3092 Check if a config file has changed date.
3093 ********************************************************************/
3094
3095 BOOL lp_file_list_changed(void)
3096 {
3097 struct file_lists *f = file_lists;
3098
3099 DEBUG(6, ("lp_file_list_changed()\n"));
3100
3101 while (f) {
3102 pstring n2;
3103 time_t mod_time;
3104
3105 pstrcpy(n2, f->name);
3106 standard_sub_basic( get_current_username(),
3107 current_user_info.domain,
3108 n2, sizeof(n2) );
3109
3110 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
3111 f->name, n2, ctime(&f->modtime)));
3112
3113 mod_time = file_modtime(n2);
3114
3115 if (mod_time && ((f->modtime != mod_time) || (f->subfname == NULL) || (strcmp(n2, f->subfname) != 0))) {
3116 DEBUGADD(6,
3117 ("file %s modified: %s\n", n2,
3118 ctime(&mod_time)));
3119 f->modtime = mod_time;
3120 SAFE_FREE(f->subfname);
3121 f->subfname = SMB_STRDUP(n2);
3122 return (True);
3123 }
3124 f = f->next;
3125 }
3126 return (False);
3127 }
3128
3129 /***************************************************************************
3130 Run standard_sub_basic on netbios name... needed because global_myname
3131 is not accessed through any lp_ macro.
3132 Note: We must *NOT* use string_set() here as ptr points to global_myname.
3133 ***************************************************************************/
3134
3135 static BOOL handle_netbios_name(int snum, const char *pszParmValue, char **ptr)
3136 {
3137 BOOL ret;
3138 pstring netbios_name;
3139
3140 pstrcpy(netbios_name, pszParmValue);
3141
3142 standard_sub_basic(get_current_username(), current_user_info.domain,
3143 netbios_name, sizeof(netbios_name));
3144
3145 ret = set_global_myname(netbios_name);
3146 string_set(&Globals.szNetbiosName,global_myname());
3147
3148 DEBUG(4, ("handle_netbios_name: set global_myname to: %s\n",
3149 global_myname()));
3150
3151 return ret;
3152 }
3153
3154 static BOOL handle_charset(int snum, const char *pszParmValue, char **ptr)
3155 {
3156 if (strcmp(*ptr, pszParmValue) != 0) {
3157 string_set(ptr, pszParmValue);
3158 init_iconv();
3159 }
3160 return True;
3161 }
3162
3163
3164
3165 static BOOL handle_workgroup(int snum, const char *pszParmValue, char **ptr)
3166 {
3167 BOOL ret;
3168
3169 ret = set_global_myworkgroup(pszParmValue);
3170 string_set(&Globals.szWorkgroup,lp_workgroup());
3171
3172 return ret;
3173 }
3174
3175 static BOOL handle_netbios_scope(int snum, const char *pszParmValue, char **ptr)
3176 {
3177 BOOL ret;
3178
3179 ret = set_global_scope(pszParmValue);
3180 string_set(&Globals.szNetbiosScope,global_scope());
3181
3182 return ret;
3183 }
3184
3185 static BOOL handle_netbios_aliases(int snum, const char *pszParmValue, char **ptr)
3186 {
3187 str_list_free(&Globals.szNetbiosAliases);
3188 Globals.szNetbiosAliases = str_list_make(pszParmValue, NULL);
3189 return set_netbios_aliases((const char **)Globals.szNetbiosAliases);
3190 }
3191
3192 /***************************************************************************
3193 Handle the include operation.
3194 ***************************************************************************/
3195
3196 static BOOL handle_include(int snum, const char *pszParmValue, char **ptr)
3197 {
3198 pstring fname;
3199 pstrcpy(fname, pszParmValue);
3200
3201 standard_sub_basic(get_current_username(), current_user_info.domain,
3202 fname,sizeof(fname));
3203
3204 add_to_file_list(pszParmValue, fname);
3205
3206 string_set(ptr, fname);
3207
3208 if (file_exist(fname, NULL))
3209 return (pm_process(fname, do_section, do_parameter));
3210
3211 DEBUG(2, ("Can't find include file %s\n", fname));
3212
3213 return (False);
3214 }
3215
3216 /***************************************************************************
3217 Handle the interpretation of the copy parameter.
3218 ***************************************************************************/
3219
3220 static BOOL handle_copy(int snum, const char *pszParmValue, char **ptr)
3221 {
3222 BOOL bRetval;
3223 int iTemp;
3224 service serviceTemp;
3225
3226 string_set(ptr, pszParmValue);
3227
3228 init_service(&serviceTemp);
3229
3230 bRetval = False;
3231
3232 DEBUG(3, ("Copying service from service %s\n", pszParmValue));
3233
3234 if ((iTemp = getservicebyname(pszParmValue, &serviceTemp)) >= 0) {
3235 if (iTemp == iServiceIndex) {
3236 DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
3237 } else {
3238 copy_service(ServicePtrs[iServiceIndex],
3239 &serviceTemp,
3240 ServicePtrs[iServiceIndex]->copymap);
3241 bRetval = True;
3242 }
3243 } else {
3244 DEBUG(0, ("Unable to copy service - source not found: %s\n", pszParmValue));
3245 bRetval = False;
3246 }
3247
3248 free_service(&serviceTemp);
3249 return (bRetval);
3250 }
3251
3252 static BOOL handle_ldap_debug_level(int snum, const char *pszParmValue, char **ptr)
3253 {
3254 Globals.ldap_debug_level = lp_int(pszParmValue);
3255 init_ldap_debugging();
3256 return True;
3257 }
3258
3259 /***************************************************************************
3260 Handle idmap/non unix account uid and gid allocation parameters. The format of these
3261 parameters is:
3262
3263 [global]
3264
3265 idmap uid = 1000-1999
3266 idmap gid = 700-899
3267
3268 We only do simple parsing checks here. The strings are parsed into useful
3269 structures in the idmap daemon code.
3270
3271 ***************************************************************************/
3272
3273 /* Some lp_ routines to return idmap [ug]id information */
3274
3275 static uid_t idmap_uid_low, idmap_uid_high;
3276 static gid_t idmap_gid_low, idmap_gid_high;
3277
3278 BOOL lp_idmap_uid(uid_t *low, uid_t *high)
3279 {
3280 if (idmap_uid_low == 0 || idmap_uid_high == 0)
3281 return False;
3282
3283 if (low)
3284 *low = idmap_uid_low;
3285
3286 if (high)
3287 *high = idmap_uid_high;
3288
3289 return True;
3290 }
3291
3292 BOOL lp_idmap_gid(gid_t *low, gid_t *high)
3293 {
3294 if (idmap_gid_low == 0 || idmap_gid_high == 0)
3295 return False;
3296
3297 if (low)
3298 *low = idmap_gid_low;
3299
3300 if (high)
3301 *high = idmap_gid_high;
3302
3303 return True;
3304 }
3305
3306 /* Do some simple checks on "idmap [ug]id" parameter values */
3307
3308 static BOOL handle_idmap_uid(int snum, const char *pszParmValue, char **ptr)
3309 {
3310 uint32 low, high;
3311
3312 if (sscanf(pszParmValue, "%u - %u", &low, &high) != 2 || high < low)
3313 return False;
3314
3315 /* Parse OK */
3316
3317 string_set(ptr, pszParmValue);
3318
3319 idmap_uid_low = low;
3320 idmap_uid_high = high;
3321
3322 return True;
3323 }
3324
3325 static BOOL handle_idmap_gid(int snum, const char *pszParmValue, char **ptr)
3326 {
3327 uint32 low, high;
3328
3329 if (sscanf(pszParmValue, "%u - %u", &low, &high) != 2 || high < low)
3330 return False;
3331
3332 /* Parse OK */
3333
3334 string_set(ptr, pszParmValue);
3335
3336 idmap_gid_low = low;
3337 idmap_gid_high = high;
3338
3339 return True;
3340 }
3341
3342 /***************************************************************************
3343 Handle the DEBUG level list.
3344 ***************************************************************************/
3345
3346 static BOOL handle_debug_list( int snum, const char *pszParmValueIn, char **ptr )
3347 {
3348 pstring pszParmValue;
3349
3350 pstrcpy(pszParmValue, pszParmValueIn);
3351 string_set(ptr, pszParmValueIn);
3352 return debug_parse_levels( pszParmValue );
3353 }
3354
3355 /***************************************************************************
3356 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
3357 ***************************************************************************/
3358
3359 static const char *append_ldap_suffix( const char *str )
3360 {
3361 const char *suffix_string;
3362
3363
3364 if (!lp_talloc)
3365 lp_talloc = talloc_init("lp_talloc");
3366
3367 suffix_string = talloc_asprintf( lp_talloc, "%s,%s", str, Globals.szLdapSuffix );
3368 if ( !suffix_string ) {
3369 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
3370 return "";
3371 }
3372
3373 return suffix_string;
3374 }
3375
3376 const char *lp_ldap_machine_suffix(void)
3377 {
3378 if (Globals.szLdapMachineSuffix[0])
3379 return append_ldap_suffix(Globals.szLdapMachineSuffix);
3380
3381 return lp_string(Globals.szLdapSuffix);
3382 }
3383
3384 const char *lp_ldap_user_suffix(void)
3385 {
3386 if (Globals.szLdapUserSuffix[0])
3387 return append_ldap_suffix(Globals.szLdapUserSuffix);
3388
3389 return lp_string(Globals.szLdapSuffix);
3390 }
3391
3392 const char *lp_ldap_group_suffix(void)
3393 {
3394 if (Globals.szLdapGroupSuffix[0])
3395 return append_ldap_suffix(Globals.szLdapGroupSuffix);
3396
3397 return lp_string(Globals.szLdapSuffix);
3398 }
3399
3400 const char *lp_ldap_idmap_suffix(void)
3401 {
3402 if (Globals.szLdapIdmapSuffix[0])
3403 return append_ldap_suffix(Globals.szLdapIdmapSuffix);
3404
3405 return lp_string(Globals.szLdapSuffix);
3406 }
3407
3408 /****************************************************************************
3409 set the value for a P_ENUM
3410 ***************************************************************************/
3411
3412 static void lp_set_enum_parm( struct parm_struct *parm, const char *pszParmValue,
3413 int *ptr )
3414 {
3415 int i;
3416
3417 for (i = 0; parm->enum_list[i].name; i++) {
3418 if ( strequal(pszParmValue, parm->enum_list[i].name)) {
3419 *ptr = parm->enum_list[i].value;
3420 break;
3421 }
3422 }
3423 }
3424
3425 /***************************************************************************
3426 ***************************************************************************/
3427
3428 static BOOL handle_printing(int snum, const char *pszParmValue, char **ptr)
3429 {
3430 static int parm_num = -1;
3431 service *s;
3432
3433 if ( parm_num == -1 )
3434 parm_num = map_parameter( "printing" );
3435
3436 lp_set_enum_parm( &parm_table[parm_num], pszParmValue, (int*)ptr );
3437
3438 if ( snum < 0 )
3439 s = &sDefault;
3440 else
3441 s = ServicePtrs[snum];
3442
3443 init_printer_values( s );
3444
3445 return True;
3446 }
3447
3448
3449 /***************************************************************************
3450 Initialise a copymap.
3451 ***************************************************************************/
3452
3453 static void init_copymap(service * pservice)
3454 {
3455 int i;
3456 SAFE_FREE(pservice->copymap);
3457 pservice->copymap = SMB_MALLOC_ARRAY(BOOL,NUMPARAMETERS);
3458 if (!pservice->copymap)
3459 DEBUG(0,
3460 ("Couldn't allocate copymap!! (size %d)\n",
3461 (int)NUMPARAMETERS));
3462 else
3463 for (i = 0; i < NUMPARAMETERS; i++)
3464 pservice->copymap[i] = True;
3465 }
3466
3467 /***************************************************************************
3468 Return the local pointer to a parameter given the service number and the
3469 pointer into the default structure.
3470 ***************************************************************************/
3471
3472 void *lp_local_ptr(int snum, void *ptr)
3473 {
3474 return (void *)(((char *)ServicePtrs[snum]) + PTR_DIFF(ptr, &sDefault));
3475 }
3476
3477 /***************************************************************************
3478 Process a parameter for a particular service number. If snum < 0
3479 then assume we are in the globals.
3480 ***************************************************************************/
3481
3482 BOOL lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
3483 {
3484 int parmnum, i, slen;
3485 void *parm_ptr = NULL; /* where we are going to store the result */
3486 void *def_ptr = NULL;
3487 pstring param_key;
3488 char *sep;
3489 param_opt_struct *paramo, *data;
3490 BOOL not_added;
3491
3492 parmnum = map_parameter(pszParmName);
3493
3494 if (parmnum < 0) {
3495 if ((sep=strchr(pszParmName, ':')) != NULL) {
3496 *sep = '\0';
3497 ZERO_STRUCT(param_key);
3498 pstr_sprintf(param_key, "%s:", pszParmName);
3499 slen = strlen(param_key);
3500 pstrcat(param_key, sep+1);
3501 trim_char(param_key+slen, ' ', ' ');
3502 not_added = True;
3503 data = (snum < 0) ? Globals.param_opt :
3504 ServicePtrs[snum]->param_opt;
3505 /* Traverse destination */
3506 while (data) {
3507 /* If we already have same option, override it */
3508 if (strcmp(data->key, param_key) == 0) {
3509 string_free(&data->value);
3510 str_list_free(&data->list);
3511 data->value = SMB_STRDUP(pszParmValue);
3512 not_added = False;
3513 break;
3514 }
3515 data = data->next;
3516 }
3517 if (not_added) {
3518 paramo = SMB_XMALLOC_P(param_opt_struct);
3519 paramo->key = SMB_STRDUP(param_key);
3520 paramo->value = SMB_STRDUP(pszParmValue);
3521 paramo->list = NULL;
3522 if (snum < 0) {
3523 DLIST_ADD(Globals.param_opt, paramo);
3524 } else {
3525 DLIST_ADD(ServicePtrs[snum]->param_opt, paramo);
3526 }
3527 }
3528
3529 *sep = ':';
3530 return (True);
3531 }
3532 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
3533 return (True);
3534 }
3535
3536 if (parm_table[parmnum].flags & FLAG_DEPRECATED) {
3537 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
3538 pszParmName));
3539 }
3540
3541 def_ptr = parm_table[parmnum].ptr;
3542
3543 /* we might point at a service, the default service or a global */
3544 if (snum < 0) {
3545 parm_ptr = def_ptr;
3546 } else {
3547 if (parm_table[parmnum].p_class == P_GLOBAL) {
3548 DEBUG(0,
3549 ("Global parameter %s found in service section!\n",
3550 pszParmName));
3551 return (True);
3552 }
3553 parm_ptr =
3554 ((char *)ServicePtrs[snum]) + PTR_DIFF(def_ptr,
3555 &sDefault);
3556 }
3557
3558 if (snum >= 0) {
3559 if (!ServicePtrs[snum]->copymap)
3560 init_copymap(ServicePtrs[snum]);
3561
3562 /* this handles the aliases - set the copymap for other entries with
3563 the same data pointer */
3564 for (i = 0; parm_table[i].label; i++)
3565 if (parm_table[i].ptr == parm_table[parmnum].ptr)
3566 ServicePtrs[snum]->copymap[i] = False;
3567 }
3568
3569 /* if it is a special case then go ahead */
3570 if (parm_table[parmnum].special) {
3571 parm_table[parmnum].special(snum, pszParmValue, (char **)parm_ptr);
3572 return (True);
3573 }
3574
3575 /* now switch on the type of variable it is */
3576 switch (parm_table[parmnum].type)
3577 {
3578 case P_BOOL:
3579 *(BOOL *)parm_ptr = lp_bool(pszParmValue);
3580 break;
3581
3582 case P_BOOLREV:
3583 *(BOOL *)parm_ptr = !lp_bool(pszParmValue);
3584 break;
3585
3586 case P_INTEGER:
3587 *(int *)parm_ptr = lp_int(pszParmValue);
3588 break;
3589
3590 case P_CHAR:
3591 *(char *)parm_ptr = *pszParmValue;
3592 break;
3593
3594 case P_OCTAL:
3595 i = sscanf(pszParmValue, "%o", (int *)parm_ptr);
3596 if ( i != 1 ) {
3597 DEBUG ( 0, ("Invalid octal number %s\n", pszParmName ));
3598 }
3599 break;
3600
3601 case P_LIST:
3602 str_list_free((char ***)parm_ptr);
3603 *(char ***)parm_ptr = str_list_make(pszParmValue, NULL);
3604 break;
3605
3606 case P_STRING:
3607 string_set((char **)parm_ptr, pszParmValue);
3608 break;
3609
3610 case P_USTRING:
3611 string_set((char **)parm_ptr, pszParmValue);
3612 strupper_m(*(char **)parm_ptr);
3613 break;
3614
3615 case P_GSTRING:
3616 pstrcpy((char *)parm_ptr, pszParmValue);
3617 break;
3618
3619 case P_UGSTRING:
3620 pstrcpy((char *)parm_ptr, pszParmValue);
3621 strupper_m((char *)parm_ptr);
3622 break;
3623
3624 case P_ENUM:
3625 lp_set_enum_parm( &parm_table[parmnum], pszParmValue, (int*)parm_ptr );
3626 break;
3627 case P_SEP:
3628 break;
3629 }
3630
3631 return (True);
3632 }
3633
3634 /***************************************************************************
3635 Process a parameter.
3636 ***************************************************************************/
3637
3638 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue)
3639 {
3640 if (!bInGlobalSection && bGlobalOnly)
3641 return (True);
3642
3643 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
3644
3645 return (lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
3646 pszParmName, pszParmValue));
3647 }
3648
3649 /***************************************************************************
3650 Print a parameter of the specified type.
3651 ***************************************************************************/
3652
3653 static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
3654 {
3655 int i;
3656 switch (p->type)
3657 {
3658 case P_ENUM:
3659 for (i = 0; p->enum_list[i].name; i++) {
3660 if (*(int *)ptr == p->enum_list[i].value) {
3661 fprintf(f, "%s",
3662 p->enum_list[i].name);
3663 break;
3664 }
3665 }
3666 break;
3667
3668 case P_BOOL:
3669 fprintf(f, "%s", BOOLSTR(*(BOOL *)ptr));
3670 break;
3671
3672 case P_BOOLREV:
3673 fprintf(f, "%s", BOOLSTR(!*(BOOL *)ptr));
3674 break;
3675
3676 case P_INTEGER:
3677 fprintf(f, "%d", *(int *)ptr);
3678 break;
3679
3680 case P_CHAR:
3681 fprintf(f, "%c", *(char *)ptr);
3682 break;
3683
3684 case P_OCTAL:
3685 fprintf(f, "%s", octal_string(*(int *)ptr));
3686 break;
3687
3688 case P_LIST:
3689 if ((char ***)ptr && *(char ***)ptr) {
3690 char **list = *(char ***)ptr;
3691
3692 for (; *list; list++) {
3693 /* surround strings with whitespace in double quotes */
3694 if ( strchr_m( *list, ' ' ) )
3695 fprintf(f, "\"%s\"%s", *list, ((*(list+1))?", ":""));
3696 else
3697 fprintf(f, "%s%s", *list, ((*(list+1))?", ":""));
3698 }
3699 }
3700 break;
3701
3702 case P_GSTRING:
3703 case P_UGSTRING:
3704 if ((char *)ptr) {
3705 fprintf(f, "%s", (char *)ptr);
3706 }
3707 break;
3708
3709 case P_STRING:
3710 case P_USTRING:
3711 if (*(char **)ptr) {
3712 fprintf(f, "%s", *(char **)ptr);
3713 }
3714 break;
3715 case P_SEP:
3716 break;
3717 }
3718 }
3719
3720 /***************************************************************************
3721 Check if two parameters are equal.
3722 ***************************************************************************/
3723
3724 static BOOL equal_parameter(parm_type type, void *ptr1, void *ptr2)
3725 {
3726 switch (type) {
3727 case P_BOOL:
3728 case P_BOOLREV:
3729 return (*((BOOL *)ptr1) == *((BOOL *)ptr2));
3730
3731 case P_INTEGER:
3732 case P_ENUM:
3733 case P_OCTAL:
3734 return (*((int *)ptr1) == *((int *)ptr2));
3735
3736 case P_CHAR:
3737 return (*((char *)ptr1) == *((char *)ptr2));
3738
3739 case P_LIST:
3740 return str_list_compare(*(char ***)ptr1, *(char ***)ptr2);
3741
3742 case P_GSTRING:
3743 case P_UGSTRING:
3744 {
3745 char *p1 = (char *)ptr1, *p2 = (char *)ptr2;
3746 if (p1 && !*p1)
3747 p1 = NULL;
3748 if (p2 && !*p2)
3749 p2 = NULL;
3750 return (p1 == p2 || strequal(p1, p2));
3751 }
3752 case P_STRING:
3753 case P_USTRING:
3754 {
3755 char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
3756 if (p1 && !*p1)
3757 p1 = NULL;
3758 if (p2 && !*p2)
3759 p2 = NULL;
3760 return (p1 == p2 || strequal(p1, p2));
3761 }
3762 case P_SEP:
3763 break;
3764 }
3765 return (False);
3766 }
3767
3768 /***************************************************************************
3769 Initialize any local varients in the sDefault table.
3770 ***************************************************************************/
3771
3772 void init_locals(void)
3773 {
3774 /* None as yet. */
3775 }
3776
3777 /***************************************************************************
3778 Process a new section (service). At this stage all sections are services.
3779 Later we'll have special sections that permit server parameters to be set.
3780 Returns True on success, False on failure.
3781 ***************************************************************************/
3782
3783 static BOOL do_section(const char *pszSectionName)
3784 {
3785 BOOL bRetval;
3786 BOOL isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
3787 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
3788 bRetval = False;
3789
3790 /* if we were in a global section then do the local inits */
3791 if (bInGlobalSection && !isglobal)
3792 init_locals();
3793
3794 /* if we've just struck a global section, note the fact. */
3795 bInGlobalSection = isglobal;
3796
3797 /* check for multiple global sections */
3798 if (bInGlobalSection) {
3799 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
3800 return (True);
3801 }
3802
3803 if (!bInGlobalSection && bGlobalOnly)
3804 return (True);
3805
3806 /* if we have a current service, tidy it up before moving on */
3807 bRetval = True;
3808
3809 if (iServiceIndex >= 0)
3810 bRetval = service_ok(iServiceIndex);
3811
3812 /* if all is still well, move to the next record in the services array */
3813 if (bRetval) {
3814 /* We put this here to avoid an odd message order if messages are */
3815 /* issued by the post-processing of a previous section. */
3816 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
3817
3818 if ((iServiceIndex = add_a_service(&sDefault, pszSectionName))
3819 < 0) {
3820 DEBUG(0, ("Failed to add a new service\n"));
3821 return (False);
3822 }
3823 }
3824
3825 return (bRetval);
3826 }
3827
3828
3829 /***************************************************************************
3830 Determine if a partcular base parameter is currentl set to the default value.
3831 ***************************************************************************/
3832
3833 static BOOL is_default(int i)
3834 {
3835 if (!defaults_saved)
3836 return False;
3837 switch (parm_table[i].type) {
3838 case P_LIST:
3839 return str_list_compare (parm_table[i].def.lvalue,
3840 *(char ***)parm_table[i].ptr);
3841 case P_STRING:
3842 case P_USTRING:
3843 return strequal(parm_table[i].def.svalue,
3844 *(char **)parm_table[i].ptr);
3845 case P_GSTRING:
3846 case P_UGSTRING:
3847 return strequal(parm_table[i].def.svalue,
3848 (char *)parm_table[i].ptr);
3849 case P_BOOL:
3850 case P_BOOLREV:
3851 return parm_table[i].def.bvalue ==
3852 *(BOOL *)parm_table[i].ptr;
3853 case P_CHAR:
3854 return parm_table[i].def.cvalue ==
3855 *(char *)parm_table[i].ptr;
3856 case P_INTEGER:
3857 case P_OCTAL:
3858 case P_ENUM:
3859 return parm_table[i].def.ivalue ==
3860 *(int *)parm_table[i].ptr;
3861 case P_SEP:
3862 break;
3863 }
3864 return False;
3865 }
3866
3867 /***************************************************************************
3868 Display the contents of the global structure.
3869 ***************************************************************************/
3870
3871 static void dump_globals(FILE *f)
3872 {
3873 int i;
3874 param_opt_struct *data;
3875
3876 fprintf(f, "[global]\n");
3877
3878 for (i = 0; parm_table[i].label; i++)
3879 if (parm_table[i].p_class == P_GLOBAL &&
3880 parm_table[i].ptr &&
3881 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
3882 if (defaults_saved && is_default(i))
3883 continue;
3884 fprintf(f, "\t%s = ", parm_table[i].label);
3885 print_parameter(&parm_table[i], parm_table[i].ptr, f);
3886 fprintf(f, "\n");
3887 }
3888 if (Globals.param_opt != NULL) {
3889 data = Globals.param_opt;
3890 while(data) {
3891 fprintf(f, "\t%s = %s\n", data->key, data->value);
3892 data = data->next;
3893 }
3894 }
3895
3896 }
3897
3898 /***************************************************************************
3899 Return True if a local parameter is currently set to the global default.
3900 ***************************************************************************/
3901
3902 BOOL lp_is_default(int snum, struct parm_struct *parm)
3903 {
3904 int pdiff = PTR_DIFF(parm->ptr, &sDefault);
3905
3906 return equal_parameter(parm->type,
3907 ((char *)ServicePtrs[snum]) + pdiff,
3908 ((char *)&sDefault) + pdiff);
3909 }
3910
3911 /***************************************************************************
3912 Display the contents of a single services record.
3913 ***************************************************************************/
3914
3915 static void dump_a_service(service * pService, FILE * f)
3916 {
3917 int i;
3918 param_opt_struct *data;
3919
3920 if (pService != &sDefault)
3921 fprintf(f, "[%s]\n", pService->szService);
3922
3923 for (i = 0; parm_table[i].label; i++) {
3924
3925 if (parm_table[i].p_class == P_LOCAL &&
3926 parm_table[i].ptr &&
3927 (*parm_table[i].label != '-') &&
3928 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
3929 {
3930
3931 int pdiff = PTR_DIFF(parm_table[i].ptr, &sDefault);
3932
3933 if (pService == &sDefault) {
3934 if (defaults_saved && is_default(i))
3935 continue;
3936 } else {
3937 if (equal_parameter(parm_table[i].type,
3938 ((char *)pService) +
3939 pdiff,
3940 ((char *)&sDefault) +
3941 pdiff))
3942 continue;
3943 }
3944
3945 fprintf(f, "\t%s = ", parm_table[i].label);
3946 print_parameter(&parm_table[i],
3947 ((char *)pService) + pdiff, f);
3948 fprintf(f, "\n");
3949 }
3950 }
3951
3952 if (pService->param_opt != NULL) {
3953 data = pService->param_opt;
3954 while(data) {
3955 fprintf(f, "\t%s = %s\n", data->key, data->value);
3956 data = data->next;
3957 }
3958 }
3959 }
3960
3961 /***************************************************************************
3962 Display the contents of a parameter of a single services record.
3963 ***************************************************************************/
3964
3965 BOOL dump_a_parameter(int snum, char *parm_name, FILE * f, BOOL isGlobal)
3966 {
3967 int i;
3968 BOOL result = False;
3969 parm_class p_class;
3970 unsigned flag = 0;
3971 fstring local_parm_name;
3972 char *parm_opt;
3973 const char *parm_opt_value;
3974
3975 /* check for parametrical option */
3976 fstrcpy( local_parm_name, parm_name);
3977 parm_opt = strchr( local_parm_name, ':');
3978
3979 if (parm_opt) {
3980 *parm_opt = '\0';
3981 parm_opt++;
3982 if (strlen(parm_opt)) {
3983 parm_opt_value = lp_parm_const_string( snum,
3984 local_parm_name, parm_opt, NULL);
3985 if (parm_opt_value) {
3986 printf( "%s\n", parm_opt_value);
3987 result = True;
3988 }
3989 }
3990 return result;
3991 }
3992
3993 /* check for a key and print the value */
3994 if (isGlobal) {
3995 p_class = P_GLOBAL;
3996 flag = FLAG_GLOBAL;
3997 } else
3998 p_class = P_LOCAL;
3999
4000 for (i = 0; parm_table[i].label; i++) {
4001 if (strwicmp(parm_table[i].label, parm_name) == 0 &&
4002 (parm_table[i].p_class == p_class || parm_table[i].flags & flag) &&
4003 parm_table[i].ptr &&
4004 (*parm_table[i].label != '-') &&
4005 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
4006 {
4007 void *ptr;
4008
4009 if (isGlobal) {
4010 ptr = parm_table[i].ptr;
4011 } else {
4012 service * pService = ServicePtrs[snum];
4013 ptr = ((char *)pService) +
4014 PTR_DIFF(parm_table[i].ptr, &sDefault);
4015 }
4016
4017 print_parameter(&parm_table[i],
4018 ptr, f);
4019 fprintf(f, "\n");
4020 result = True;
4021 break;
4022 }
4023 }
4024
4025 return result;
4026 }
4027
4028 /***************************************************************************
4029 Return info about the next service in a service. snum==GLOBAL_SECTION_SNUM gives the globals.
4030 Return NULL when out of parameters.
4031 ***************************************************************************/
4032
4033 struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters)
4034 {
4035 if (snum < 0) {
4036 /* do the globals */
4037 for (; parm_table[*i].label; (*i)++) {
4038 if (parm_table[*i].p_class == P_SEPARATOR)
4039 return &parm_table[(*i)++];
4040
4041 if (!parm_table[*i].ptr
4042 || (*parm_table[*i].label == '-'))
4043 continue;
4044
4045 if ((*i) > 0
4046 && (parm_table[*i].ptr ==
4047 parm_table[(*i) - 1].ptr))
4048 continue;
4049
4050 return &parm_table[(*i)++];
4051 }
4052 } else {
4053 service *pService = ServicePtrs[snum];
4054
4055 for (; parm_table[*i].label; (*i)++) {
4056 if (parm_table[*i].p_class == P_SEPARATOR)
4057 return &parm_table[(*i)++];
4058
4059 if (parm_table[*i].p_class == P_LOCAL &&
4060 parm_table[*i].ptr &&
4061 (*parm_table[*i].label != '-') &&
4062 ((*i) == 0 ||
4063 (parm_table[*i].ptr !=
4064 parm_table[(*i) - 1].ptr)))
4065 {
4066 int pdiff =
4067 PTR_DIFF(parm_table[*i].ptr,
4068 &sDefault);
4069
4070 if (allparameters ||
4071 !equal_parameter(parm_table[*i].type,
4072 ((char *)pService) +
4073 pdiff,
4074 ((char *)&sDefault) +
4075 pdiff))
4076 {
4077 return &parm_table[(*i)++];
4078 }
4079 }
4080 }
4081 }
4082
4083 return NULL;
4084 }
4085
4086
4087 #if 0
4088 /***************************************************************************
4089 Display the contents of a single copy structure.
4090 ***************************************************************************/
4091 static void dump_copy_map(BOOL *pcopymap)
4092 {
4093 int i;
4094 if (!pcopymap)
4095 return;
4096
4097 printf("\n\tNon-Copied parameters:\n");
4098
4099 for (i = 0; parm_table[i].label; i++)
4100 if (parm_table[i].p_class == P_LOCAL &&
4101 parm_table[i].ptr && !pcopymap[i] &&
4102 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
4103 {
4104 printf("\t\t%s\n", parm_table[i].label);
4105 }
4106 }
4107 #endif
4108
4109 /***************************************************************************
4110 Return TRUE if the passed service number is within range.
4111 ***************************************************************************/
4112
4113 BOOL lp_snum_ok(int iService)
4114 {
4115 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
4116 }
4117
4118 /***************************************************************************
4119 Auto-load some home services.
4120 ***************************************************************************/
4121
4122 static void lp_add_auto_services(char *str)
4123 {
4124 char *s;
4125 char *p;
4126 int homes;
4127
4128 if (!str)
4129 return;
4130
4131 s = SMB_STRDUP(str);
4132 if (!s)
4133 return;
4134
4135 homes = lp_servicenumber(HOMES_NAME);
4136
4137 for (p = strtok(s, LIST_SEP); p; p = strtok(NULL, LIST_SEP)) {
4138 char *home = get_user_home_dir(p);
4139
4140 if (lp_servicenumber(p) >= 0)
4141 continue;
4142
4143 if (home && home[0] && homes >= 0)
4144 lp_add_home(p, homes, p, home);
4145 }
4146 SAFE_FREE(s);
4147 }
4148
4149 /***************************************************************************
4150 Auto-load one printer.
4151 ***************************************************************************/
4152
4153 void lp_add_one_printer(char *name, char *comment)
4154 {
4155 int printers = lp_servicenumber(PRINTERS_NAME);
4156 int i;
4157
4158 if (lp_servicenumber(name) < 0) {
4159 lp_add_printer(name, printers);
4160 if ((i = lp_servicenumber(name)) >= 0) {
4161 string_set(&ServicePtrs[i]->comment, comment);
4162 ServicePtrs[i]->autoloaded = True;
4163 }
4164 }
4165 }
4166
4167 /***************************************************************************
4168 Have we loaded a services file yet?
4169 ***************************************************************************/
4170
4171 BOOL lp_loaded(void)
4172 {
4173 return (bLoaded);
4174 }
4175
4176 /***************************************************************************
4177 Unload unused services.
4178 ***************************************************************************/
4179
4180 void lp_killunused(BOOL (*snumused) (int))
4181 {
4182 int i;
4183 for (i = 0; i < iNumServices; i++) {
4184 if (!VALID(i))
4185 continue;
4186
4187 /* don't kill autoloaded or usershare services */
4188 if ( ServicePtrs[i]->autoloaded ||
4189 ServicePtrs[i]->usershare == USERSHARE_VALID) {
4190 continue;
4191 }
4192
4193 if (!snumused || !snumused(i)) {
4194 free_service_byindex(i);
4195 }
4196 }
4197 }
4198
4199 /***************************************************************************
4200 Unload a service.
4201 ***************************************************************************/
4202
4203 void lp_killservice(int iServiceIn)
4204 {
4205 if (VALID(iServiceIn)) {
4206 free_service_byindex(iServiceIn);
4207 }
4208 }
4209
4210 /***************************************************************************
4211 Save the curent values of all global and sDefault parameters into the
4212 defaults union. This allows swat and testparm to show only the
4213 changed (ie. non-default) parameters.
4214 ***************************************************************************/
4215
4216 static void lp_save_defaults(void)
4217 {
4218 int i;
4219 for (i = 0; parm_table[i].label; i++) {
4220 if (i > 0 && parm_table[i].ptr == parm_table[i - 1].ptr)
4221 continue;
4222 switch (parm_table[i].type) {
4223 case P_LIST:
4224 str_list_copy(&(parm_table[i].def.lvalue),
4225 *(const char ***)parm_table[i].ptr);
4226 break;
4227 case P_STRING:
4228 case P_USTRING:
4229 if (parm_table[i].ptr) {
4230 parm_table[i].def.svalue = SMB_STRDUP(*(char **)parm_table[i].ptr);
4231 } else {
4232 parm_table[i].def.svalue = NULL;
4233 }
4234 break;
4235 case P_GSTRING:
4236 case P_UGSTRING:
4237 if (parm_table[i].ptr) {
4238 parm_table[i].def.svalue = SMB_STRDUP((char *)parm_table[i].ptr);
4239 } else {
4240 parm_table[i].def.svalue = NULL;
4241 }
4242 break;
4243 case P_BOOL:
4244 case P_BOOLREV:
4245 parm_table[i].def.bvalue =
4246 *(BOOL *)parm_table[i].ptr;
4247 break;
4248 case P_CHAR:
4249 parm_table[i].def.cvalue =
4250 *(char *)parm_table[i].ptr;
4251 break;
4252 case P_INTEGER:
4253 case P_OCTAL:
4254 case P_ENUM:
4255 parm_table[i].def.ivalue =
4256 *(int *)parm_table[i].ptr;
4257 break;
4258 case P_SEP:
4259 break;
4260 }
4261 }
4262 defaults_saved = True;
4263 }
4264
4265 /*******************************************************************
4266 Set the server type we will announce as via nmbd.
4267 ********************************************************************/
4268
4269 static const struct srv_role_tab {
4270 uint32 role;
4271 const char *role_str;
4272 } srv_role_tab [] = {
4273 { ROLE_STANDALONE, "ROLE_STANDALONE" },
4274 { ROLE_DOMAIN_MEMBER, "ROLE_DOMAIN_MEMBER" },
4275 { ROLE_DOMAIN_BDC, "ROLE_DOMAIN_BDC" },
4276 { ROLE_DOMAIN_PDC, "ROLE_DOMAIN_PDC" },
4277 { 0, NULL }
4278 };
4279
4280 const char* server_role_str(uint32 role)
4281 {
4282 int i = 0;
4283 for (i=0; srv_role_tab[i].role_str; i++) {
4284 if (role == srv_role_tab[i].role) {
4285 return srv_role_tab[i].role_str;
4286 }
4287 }
4288 return NULL;
4289 }
4290
4291 static void set_server_role(void)
4292 {
4293 server_role = ROLE_STANDALONE;
4294
4295 switch (lp_security()) {
4296 case SEC_SHARE:
4297 if (lp_domain_logons())
4298 DEBUG(0, ("Server's Role (logon server) conflicts with share-level security\n"));
4299 break;
4300 case SEC_SERVER:
4301 if (lp_domain_logons())
4302 DEBUG(0, ("Server's Role (logon server) conflicts with server-level security\n"));
4303 /* this used to be considered ROLE_DOMAIN_MEMBER but that's just wrong */
4304 server_role = ROLE_STANDALONE;
4305 break;
4306 case SEC_DOMAIN:
4307 if (lp_domain_logons()) {
4308 DEBUG(1, ("Server's Role (logon server) NOT ADVISED with domain-level security\n"));
4309 server_role = ROLE_DOMAIN_BDC;
4310 break;
4311 }
4312 server_role = ROLE_DOMAIN_MEMBER;
4313 break;
4314 case SEC_ADS:
4315 if (lp_domain_logons()) {
4316 server_role = ROLE_DOMAIN_PDC;
4317 break;
4318 }
4319 server_role = ROLE_DOMAIN_MEMBER;
4320 break;
4321 case SEC_USER:
4322 if (lp_domain_logons()) {
4323
4324 if (Globals.bDomainMaster) /* auto or yes */
4325 server_role = ROLE_DOMAIN_PDC;
4326 else
4327 server_role = ROLE_DOMAIN_BDC;
4328 }
4329 break;
4330 default:
4331 DEBUG(0, ("Server's Role undefined due to unknown security mode\n"));
4332 break;
4333 }
4334
4335 DEBUG(10, ("set_server_role: role = %s\n", server_role_str(server_role)));
4336 }
4337
4338 /***********************************************************
4339 If we should send plaintext/LANMAN passwords in the clinet
4340 ************************************************************/
4341
4342 static void set_allowed_client_auth(void)
4343 {
4344 if (Globals.bClientNTLMv2Auth) {
4345 Globals.bClientLanManAuth = False;
4346 }
4347 if (!Globals.bClientLanManAuth) {
4348 Globals.bClientPlaintextAuth = False;
4349 }
4350 }
4351
4352 /***************************************************************************
4353 JRA.
4354 The following code allows smbd to read a user defined share file.
4355 Yes, this is my intent. Yes, I'm comfortable with that...
4356
4357 THE FOLLOWING IS SECURITY CRITICAL CODE.
4358
4359 It washes your clothes, it cleans your house, it guards you while you sleep...
4360 Do not f%^k with it....
4361 ***************************************************************************/
4362
4363 #define MAX_USERSHARE_FILE_SIZE (10*1024)
4364
4365 /***************************************************************************
4366 Check allowed stat state of a usershare file.
4367 Ensure we print out who is dicking with us so the admin can
4368 get their sorry ass fired.
4369 ***************************************************************************/
4370
4371 static BOOL check_usershare_stat(const char *fname, SMB_STRUCT_STAT *psbuf)
4372 {
4373 if (!S_ISREG(psbuf->st_mode)) {
4374 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
4375 "not a regular file\n",
4376 fname, (unsigned int)psbuf->st_uid ));
4377 return False;
4378 }
4379
4380 /* Ensure this doesn't have the other write bit set. */
4381 if (psbuf->st_mode & S_IWOTH) {
4382 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
4383 "public write. Refusing to allow as a usershare file.\n",
4384 fname, (unsigned int)psbuf->st_uid ));
4385 return False;
4386 }
4387
4388 /* Should be 10k or less. */
4389 if (psbuf->st_size > MAX_USERSHARE_FILE_SIZE) {
4390 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
4391 "too large (%u) to be a user share file.\n",
4392 fname, (unsigned int)psbuf->st_uid,
4393 (unsigned int)psbuf->st_size ));
4394 return False;
4395 }
4396
4397 return True;
4398 }
4399
4400 /***************************************************************************
4401 Parse the contents of a usershare file.
4402 ***************************************************************************/
4403
4404 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
4405 SMB_STRUCT_STAT *psbuf,
4406 const char *servicename,
4407 int snum,
4408 char **lines,
4409 int numlines,
4410 pstring sharepath,
4411 pstring comment,
4412 SEC_DESC **ppsd,
4413 BOOL *pallow_guest)
4414 {
4415 const char **prefixallowlist = lp_usershare_prefix_allow_list();
4416 const char **prefixdenylist = lp_usershare_prefix_deny_list();
4417 int us_vers;
4418 SMB_STRUCT_DIR *dp;
4419 SMB_STRUCT_STAT sbuf;
4420
4421 *pallow_guest = False;
4422
4423 if (numlines < 4) {
4424 return USERSHARE_MALFORMED_FILE;
4425 }
4426
4427 if (strcmp(lines[0], "#VERSION 1") == 0) {
4428 us_vers = 1;
4429 } else if (strcmp(lines[0], "#VERSION 2") == 0) {
4430 us_vers = 2;
4431 if (numlines < 5) {
4432 return USERSHARE_MALFORMED_FILE;
4433 }
4434 } else {
4435 return USERSHARE_BAD_VERSION;
4436 }
4437
4438 if (strncmp(lines[1], "path=", 5) != 0) {
4439 return USERSHARE_MALFORMED_PATH;
4440 }
4441
4442 pstrcpy(sharepath, &lines[1][5]);
4443 trim_string(sharepath, " ", " ");
4444
4445 if (strncmp(lines[2], "comment=", 8) != 0) {
4446 return USERSHARE_MALFORMED_COMMENT_DEF;
4447 }
4448
4449 pstrcpy(comment, &lines[2][8]);
4450 trim_string(comment, " ", " ");
4451 trim_char(comment, '"', '"');
4452
4453 if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
4454 return USERSHARE_MALFORMED_ACL_DEF;
4455 }
4456
4457 if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
4458 return USERSHARE_ACL_ERR;
4459 }
4460
4461 if (us_vers == 2) {
4462 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
4463 return USERSHARE_MALFORMED_ACL_DEF;
4464 }
4465 if (lines[4][9] == 'y') {
4466 *pallow_guest = True;
4467 }
4468 }
4469
4470 if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->szPath) == 0)) {
4471 /* Path didn't change, no checks needed. */
4472 return USERSHARE_OK;
4473 }
4474
4475 /* The path *must* be absolute. */
4476 if (sharepath[0] != '/') {
4477 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
4478 servicename, sharepath));
4479 return USERSHARE_PATH_NOT_ABSOLUTE;
4480 }
4481
4482 /* If there is a usershare prefix deny list ensure one of these paths
4483 doesn't match the start of the user given path. */
4484 if (prefixdenylist) {
4485 int i;
4486 for ( i=0; prefixdenylist[i]; i++ ) {
4487 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
4488 servicename, i, prefixdenylist[i], sharepath ));
4489 if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
4490 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
4491 "usershare prefix deny list entries.\n",
4492 servicename, sharepath));
4493 return USERSHARE_PATH_IS_DENIED;
4494 }
4495 }
4496 }
4497
4498 /* If there is a usershare prefix allow list ensure one of these paths
4499 does match the start of the user given path. */
4500
4501 if (prefixallowlist) {
4502 int i;
4503 for ( i=0; prefixallowlist[i]; i++ ) {
4504 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
4505 servicename, i, prefixallowlist[i], sharepath ));
4506 if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
4507 break;
4508 }
4509 }
4510 if (prefixallowlist[i] == NULL) {
4511 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
4512 "usershare prefix allow list entries.\n",
4513 servicename, sharepath));
4514 return USERSHARE_PATH_NOT_ALLOWED;
4515 }
4516 }
4517
4518 /* Ensure this is pointing to a directory. */
4519 dp = sys_opendir(sharepath);
4520
4521 if (!dp) {
4522 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
4523 servicename, sharepath));
4524 return USERSHARE_PATH_NOT_DIRECTORY;
4525 }
4526
4527 /* Ensure the owner of the usershare file has permission to share
4528 this directory. */
4529
4530 if (sys_stat(sharepath, &sbuf) == -1) {
4531 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
4532 servicename, sharepath, strerror(errno) ));
4533 sys_closedir(dp);
4534 return USERSHARE_POSIX_ERR;
4535 }
4536
4537 sys_closedir(dp);
4538
4539 if (!S_ISDIR(sbuf.st_mode)) {
4540 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
4541 servicename, sharepath ));
4542 return USERSHARE_PATH_NOT_DIRECTORY;
4543 }
4544
4545 /* Check if sharing is restricted to owner-only. */
4546 /* psbuf is the stat of the usershare definition file,
4547 sbuf is the stat of the target directory to be shared. */
4548
4549 if (lp_usershare_owner_only()) {
4550 /* root can share anything. */
4551 if ((psbuf->st_uid != 0) && (sbuf.st_uid != psbuf->st_uid)) {
4552 return USERSHARE_PATH_NOT_ALLOWED;
4553 }
4554 }
4555
4556 return USERSHARE_OK;
4557 }
4558
4559 /***************************************************************************
4560 Deal with a usershare file.
4561 Returns:
4562 >= 0 - snum
4563 -1 - Bad name, invalid contents.
4564 - service name already existed and not a usershare, problem
4565 with permissions to share directory etc.
4566 ***************************************************************************/
4567
4568 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
4569 {
4570 SMB_STRUCT_STAT sbuf;
4571 SMB_STRUCT_STAT lsbuf;
4572 pstring fname;
4573 pstring sharepath;
4574 pstring comment;
4575 fstring service_name;
4576 char **lines = NULL;
4577 int numlines = 0;
4578 int fd = -1;
4579 int iService = -1;
4580 TALLOC_CTX *ctx = NULL;
4581 SEC_DESC *psd = NULL;
4582 BOOL guest_ok = False;
4583
4584 /* Ensure share name doesn't contain invalid characters. */
4585 if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
4586 DEBUG(0,("process_usershare_file: share name %s contains "
4587 "invalid characters (any of %s)\n",
4588 file_name, INVALID_SHARENAME_CHARS ));
4589 return -1;
4590 }
4591
4592 fstrcpy(service_name, file_name);
4593
4594 pstrcpy(fname, dir_name);
4595 pstrcat(fname, "/");
4596 pstrcat(fname, file_name);
4597
4598 /* Minimize the race condition by doing an lstat before we
4599 open and fstat. Ensure this isn't a symlink link. */
4600
4601 if (sys_lstat(fname, &lsbuf) != 0) {
4602 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
4603 fname, strerror(errno) ));
4604 return -1;
4605 }
4606
4607 /* This must be a regular file, not a symlink, directory or
4608 other strange filetype. */
4609 if (!check_usershare_stat(fname, &lsbuf)) {
4610 return -1;
4611 }
4612
4613 /* See if there is already a servicenum for this name. */
4614 /* tdb_fetch_int32 returns -1 if not found. */
4615 iService = (int)tdb_fetch_int32(ServiceHash, canonicalize_servicename(service_name) );
4616
4617 if (iService != -1 && ServicePtrs[iService]->usershare_last_mod == lsbuf.st_mtime) {
4618 /* Nothing changed - Mark valid and return. */
4619 DEBUG(10,("process_usershare_file: service %s not changed.\n",
4620 service_name ));
4621 ServicePtrs[iService]->usershare = USERSHARE_VALID;
4622 return iService;
4623 }
4624
4625 /* Try and open the file read only - no symlinks allowed. */
4626 #ifdef O_NOFOLLOW
4627 fd = sys_open(fname, O_RDONLY|O_NOFOLLOW, 0);
4628 #else
4629 fd = sys_open(fname, O_RDONLY, 0);
4630 #endif
4631
4632 if (fd == -1) {
4633 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
4634 fname, strerror(errno) ));
4635 return -1;
4636 }
4637
4638 /* Now fstat to be *SURE* it's a regular file. */
4639 if (sys_fstat(fd, &sbuf) != 0) {
4640 close(fd);
4641 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
4642 fname, strerror(errno) ));
4643 return -1;
4644 }
4645
4646 /* Is it the same dev/inode as was lstated ? */
4647 if (lsbuf.st_dev != sbuf.st_dev || lsbuf.st_ino != sbuf.st_ino) {
4648 close(fd);
4649 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
4650 "Symlink spoofing going on ?\n", fname ));
4651 return -1;
4652 }
4653
4654 /* This must be a regular file, not a symlink, directory or
4655 other strange filetype. */
4656 if (!check_usershare_stat(fname, &sbuf)) {
4657 return -1;
4658 }
4659
4660 lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE);
4661
4662 close(fd);
4663 if (lines == NULL) {
4664 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
4665 fname, (unsigned int)sbuf.st_uid ));
4666 return -1;
4667 }
4668
4669 /* Should we allow printers to be shared... ? */
4670 ctx = talloc_init("usershare_sd_xctx");
4671 if (!ctx) {
4672 file_lines_free(lines);
4673 return 1;
4674 }
4675
4676 if (parse_usershare_file(ctx, &sbuf, service_name,
4677 iService, lines, numlines, sharepath,
4678 comment, &psd, &guest_ok) != USERSHARE_OK) {
4679 talloc_destroy(ctx);
4680 file_lines_free(lines);
4681 return -1;
4682 }
4683
4684 file_lines_free(lines);
4685
4686 /* Everything ok - add the service possibly using a template. */
4687 if (iService < 0) {
4688 const service *sp = &sDefault;
4689 if (snum_template != -1) {
4690 sp = ServicePtrs[snum_template];
4691 }
4692
4693 if ((iService = add_a_service(sp, service_name)) < 0) {
4694 DEBUG(0, ("process_usershare_file: Failed to add "
4695 "new service %s\n", service_name));
4696 talloc_destroy(ctx);
4697 return -1;
4698 }
4699
4700 /* Read only is controlled by usershare ACL below. */
4701 ServicePtrs[iService]->bRead_only = False;
4702 }
4703
4704 /* Write the ACL of the new/modified share. */
4705 if (!set_share_security(service_name, psd)) {
4706 DEBUG(0, ("process_usershare_file: Failed to set share "
4707 "security for user share %s\n",
4708 service_name ));
4709 lp_remove_service(iService);
4710 talloc_destroy(ctx);
4711 return -1;
4712 }
4713
4714 talloc_destroy(ctx);
4715
4716 /* If from a template it may be marked invalid. */
4717 ServicePtrs[iService]->valid = True;
4718
4719 /* Set the service as a valid usershare. */
4720 ServicePtrs[iService]->usershare = USERSHARE_VALID;
4721
4722 /* Set guest access. */
4723 if (lp_usershare_allow_guests()) {
4724 ServicePtrs[iService]->bGuest_ok = guest_ok;
4725 }
4726
4727 /* And note when it was loaded. */
4728 ServicePtrs[iService]->usershare_last_mod = sbuf.st_mtime;
4729 string_set(&ServicePtrs[iService]->szPath, sharepath);
4730 string_set(&ServicePtrs[iService]->comment, comment);
4731
4732 return iService;
4733 }
4734
4735 /***************************************************************************
4736 Checks if a usershare entry has been modified since last load.
4737 ***************************************************************************/
4738
4739 static BOOL usershare_exists(int iService, time_t *last_mod)
4740 {
4741 SMB_STRUCT_STAT lsbuf;
4742 const char *usersharepath = Globals.szUsersharePath;
4743 pstring fname;
4744
4745 pstrcpy(fname, usersharepath);
4746 pstrcat(fname, "/");
4747 pstrcat(fname, ServicePtrs[iService]->szService);
4748
4749 if (sys_lstat(fname, &lsbuf) != 0) {
4750 return False;
4751 }
4752
4753 if (!S_ISREG(lsbuf.st_mode)) {
4754 return False;
4755 }
4756
4757 *last_mod = lsbuf.st_mtime;
4758 return True;
4759 }
4760
4761 /***************************************************************************
4762 Load a usershare service by name. Returns a valid servicenumber or -1.
4763 ***************************************************************************/
4764
4765 int load_usershare_service(const char *servicename)
4766 {
4767 SMB_STRUCT_STAT sbuf;
4768 const char *usersharepath = Globals.szUsersharePath;
4769 int max_user_shares = Globals.iUsershareMaxShares;
4770 int snum_template = -1;
4771
4772 if (*usersharepath == 0 || max_user_shares == 0) {
4773 return -1;
4774 }
4775
4776 if (sys_stat(usersharepath, &sbuf) != 0) {
4777 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
4778 usersharepath, strerror(errno) ));
4779 return -1;
4780 }
4781
4782 if (!S_ISDIR(sbuf.st_mode)) {
4783 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
4784 usersharepath ));
4785 return -1;
4786 }
4787
4788 /*
4789 * This directory must be owned by root, and have the 't' bit set.
4790 * It also must not be writable by "other".
4791 */
4792
4793 #ifdef S_ISVTX
4794 if (sbuf.st_uid != 0 || !(sbuf.st_mode & S_ISVTX) || (sbuf.st_mode & S_IWOTH)) {
4795 #else
4796 if (sbuf.st_uid != 0 || (sbuf.st_mode & S_IWOTH)) {
4797 #endif
4798 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
4799 "or does not have the sticky bit 't' set or is writable by anyone.\n",
4800 usersharepath ));
4801 return -1;
4802 }
4803
4804 /* Ensure the template share exists if it's set. */
4805 if (Globals.szUsershareTemplateShare[0]) {
4806 /* We can't use lp_servicenumber here as we are recommending that
4807 template shares have -valid=False set. */
4808 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
4809 if (ServicePtrs[snum_template]->szService &&
4810 strequal(ServicePtrs[snum_template]->szService,
4811 Globals.szUsershareTemplateShare)) {
4812 break;
4813 }
4814 }
4815
4816 if (snum_template == -1) {
4817 DEBUG(0,("load_usershare_service: usershare template share %s "
4818 "does not exist.\n",
4819 Globals.szUsershareTemplateShare ));
4820 return -1;
4821 }
4822 }
4823
4824 return process_usershare_file(usersharepath, servicename, snum_template);
4825 }
4826
4827 /***************************************************************************
4828 Load all user defined shares from the user share directory.
4829 We only do this if we're enumerating the share list.
4830 This is the function that can delete usershares that have
4831 been removed.
4832 ***************************************************************************/
4833
4834 int load_usershare_shares(void)
4835 {
4836 SMB_STRUCT_DIR *dp;
4837 SMB_STRUCT_STAT sbuf;
4838 SMB_STRUCT_DIRENT *de;
4839 int num_usershares = 0;
4840 int max_user_shares = Globals.iUsershareMaxShares;
4841 unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
4842 unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
4843 unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
4844 int iService;
4845 int snum_template = -1;
4846 const char *usersharepath = Globals.szUsersharePath;
4847 int ret = lp_numservices();
4848
4849 if (max_user_shares == 0 || *usersharepath == '\0') {
4850 return lp_numservices();
4851 }
4852
4853 if (sys_stat(usersharepath, &sbuf) != 0) {
4854 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
4855 usersharepath, strerror(errno) ));
4856 return ret;
4857 }
4858
4859 /*
4860 * This directory must be owned by root, and have the 't' bit set.
4861 * It also must not be writable by "other".
4862 */
4863
4864 #ifdef S_ISVTX
4865 if (sbuf.st_uid != 0 || !(sbuf.st_mode & S_ISVTX) || (sbuf.st_mode & S_IWOTH)) {
4866 #else
4867 if (sbuf.st_uid != 0 || (sbuf.st_mode & S_IWOTH)) {
4868 #endif
4869 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
4870 "or does not have the sticky bit 't' set or is writable by anyone.\n",
4871 usersharepath ));
4872 return ret;
4873 }
4874
4875 /* Ensure the template share exists if it's set. */
4876 if (Globals.szUsershareTemplateShare[0]) {
4877 /* We can't use lp_servicenumber here as we are recommending that
4878 template shares have -valid=False set. */
4879 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
4880 if (ServicePtrs[snum_template]->szService &&
4881 strequal(ServicePtrs[snum_template]->szService,
4882 Globals.szUsershareTemplateShare)) {
4883 break;
4884 }
4885 }
4886
4887 if (snum_template == -1) {
4888 DEBUG(0,("load_usershare_shares: usershare template share %s "
4889 "does not exist.\n",
4890 Globals.szUsershareTemplateShare ));
4891 return ret;
4892 }
4893 }
4894
4895 /* Mark all existing usershares as pending delete. */
4896 for (iService = iNumServices - 1; iService >= 0; iService--) {
4897 if (VALID(iService) && ServicePtrs[iService]->usershare) {
4898 ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
4899 }
4900 }
4901
4902 dp = sys_opendir(usersharepath);
4903 if (!dp) {
4904 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
4905 usersharepath, strerror(errno) ));
4906 return ret;
4907 }
4908
4909 for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
4910 (de = sys_readdir(dp));
4911 num_dir_entries++ ) {
4912 int r;
4913 const char *n = de->d_name;
4914
4915 /* Ignore . and .. */
4916 if (*n == '.') {
4917 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
4918 continue;
4919 }
4920 }
4921
4922 if (n[0] == ':') {
4923 /* Temporary file used when creating a share. */
4924 num_tmp_dir_entries++;
4925 }
4926
4927 /* Allow 20% tmp entries. */
4928 if (num_tmp_dir_entries > allowed_tmp_entries) {
4929 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
4930 "in directory %s\n",
4931 num_tmp_dir_entries, usersharepath));
4932 break;
4933 }
4934
4935 r = process_usershare_file(usersharepath, n, snum_template);
4936 if (r == 0) {
4937 /* Update the services count. */
4938 num_usershares++;
4939 if (num_usershares >= max_user_shares) {
4940 DEBUG(0,("load_usershare_shares: max user shares reached "
4941 "on file %s in directory %s\n",
4942 n, usersharepath ));
4943 break;
4944 }
4945 } else if (r == -1) {
4946 num_bad_dir_entries++;
4947 }
4948
4949 /* Allow 20% bad entries. */
4950 if (num_bad_dir_entries > allowed_bad_entries) {
4951 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
4952 "in directory %s\n",
4953 num_bad_dir_entries, usersharepath));
4954 break;
4955 }
4956
4957 /* Allow 20% bad entries. */
4958 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
4959 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
4960 "in directory %s\n",
4961 num_dir_entries, usersharepath));
4962 break;
4963 }
4964 }
4965
4966 sys_closedir(dp);
4967
4968 /* Sweep through and delete any non-refreshed usershares that are
4969 not currently in use. */
4970 for (iService = iNumServices - 1; iService >= 0; iService--) {
4971 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
4972 if (conn_snum_used(iService)) {
4973 continue;
4974 }
4975 /* Remove from the share ACL db. */
4976 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
4977 lp_servicename(iService) ));
4978 delete_share_security(snum2params_static(iService));
4979 free_service_byindex(iService);
4980 }
4981 }
4982
4983 return lp_numservices();
4984 }
4985
4986 /********************************************************
4987 Destroy global resources allocated in this file
4988 ********************************************************/
4989
4990 void gfree_loadparm(void)
4991 {
4992 struct file_lists *f;
4993 struct file_lists *next;
4994 int i;
4995
4996 lp_TALLOC_FREE();
4997
4998 /* Free the file lists */
4999
5000 f = file_lists;
5001 while( f ) {
5002 next = f->next;
5003 SAFE_FREE( f->name );
5004 SAFE_FREE( f->subfname );
5005 SAFE_FREE( f );
5006 f = next;
5007 }
5008
5009 /* Free resources allocated to services */
5010
5011 for ( i = 0; i < iNumServices; i++ ) {
5012 if ( VALID(i) ) {
5013 free_service_byindex(i);
5014 }
5015 }
5016
5017 SAFE_FREE( ServicePtrs );
5018 iNumServices = 0;
5019
5020 /* Now release all resources allocated to global
5021 parameters and the default service */
5022
5023 for (i = 0; parm_table[i].label; i++)
5024 {
5025 if ( parm_table[i].type == P_STRING
5026 || parm_table[i].type == P_USTRING )
5027 {
5028 string_free( (char**)parm_table[i].ptr );
5029 }
5030 else if (parm_table[i].type == P_LIST) {
5031 str_list_free( (char***)parm_table[i].ptr );
5032 }
5033 }
5034 }
5035
5036 /***************************************************************************
5037 Load the services array from the services file. Return True on success,
5038 False on failure.
5039 ***************************************************************************/
5040
5041 BOOL lp_load(const char *pszFname,
5042 BOOL global_only,
5043 BOOL save_defaults,
5044 BOOL add_ipc,
5045 BOOL initialize_globals)
5046 {
5047 pstring n2;
5048 BOOL bRetval;
5049 param_opt_struct *data, *pdata;
5050
5051 pstrcpy(n2, pszFname);
5052
5053 standard_sub_basic( get_current_username(), current_user_info.domain,
5054 n2,sizeof(n2) );
5055
5056 add_to_file_list(pszFname, n2);
5057
5058 bRetval = False;
5059
5060 DEBUG(3, ("lp_load: refreshing parameters\n"));
5061
5062 bInGlobalSection = True;
5063 bGlobalOnly = global_only;
5064
5065 init_globals(! initialize_globals);
5066 debug_init();
5067
5068 if (save_defaults) {
5069 init_locals();
5070 lp_save_defaults();
5071 }
5072
5073 if (Globals.param_opt != NULL) {
5074 data = Globals.param_opt;
5075 while (data) {
5076 string_free(&data->key);
5077 string_free(&data->value);
5078 str_list_free(&data->list);
5079 pdata = data->next;
5080 SAFE_FREE(data);
5081 data = pdata;
5082 }
5083 Globals.param_opt = NULL;
5084 }
5085
5086 /* We get sections first, so have to start 'behind' to make up */
5087 iServiceIndex = -1;
5088 bRetval = pm_process(n2, do_section, do_parameter);
5089
5090 /* finish up the last section */
5091 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
5092 if (bRetval)
5093 if (iServiceIndex >= 0)
5094 bRetval = service_ok(iServiceIndex);
5095
5096 lp_add_auto_services(lp_auto_services());
5097
5098 if (add_ipc) {
5099 /* When 'restrict anonymous = 2' guest connections to ipc$
5100 are denied */
5101 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
5102 if ( lp_enable_asu_support() )
5103 lp_add_ipc("ADMIN$", False);
5104 }
5105
5106 set_server_role();
5107 set_default_server_announce_type();
5108 set_allowed_client_auth();
5109
5110 bLoaded = True;
5111
5112 /* Now we check bWINSsupport and set szWINSserver to 127.0.0.1 */
5113 /* if bWINSsupport is true and we are in the client */
5114 if (in_client && Globals.bWINSsupport) {
5115 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
5116 }
5117
5118 init_iconv();
5119
5120 return (bRetval);
5121 }
5122
5123 /***************************************************************************
5124 Reset the max number of services.
5125 ***************************************************************************/
5126
5127 void lp_resetnumservices(void)
5128 {
5129 iNumServices = 0;
5130 }
5131
5132 /***************************************************************************
5133 Return the max number of services.
5134 ***************************************************************************/
5135
5136 int lp_numservices(void)
5137 {
5138 return (iNumServices);
5139 }
5140
5141 /***************************************************************************
5142 Display the contents of the services array in human-readable form.
5143 ***************************************************************************/
5144
5145 void lp_dump(FILE *f, BOOL show_defaults, int maxtoprint)
5146 {
5147 int iService;
5148
5149 if (show_defaults)
5150 defaults_saved = False;
5151
5152 dump_globals(f);
5153
5154 dump_a_service(&sDefault, f);
5155
5156 for (iService = 0; iService < maxtoprint; iService++) {
5157 fprintf(f,"\n");
5158 lp_dump_one(f, show_defaults, iService);
5159 }
5160 }
5161
5162 /***************************************************************************
5163 Display the contents of one service in human-readable form.
5164 ***************************************************************************/
5165
5166 void lp_dump_one(FILE * f, BOOL show_defaults, int snum)
5167 {
5168 if (VALID(snum)) {
5169 if (ServicePtrs[snum]->szService[0] == '\0')
5170 return;
5171 dump_a_service(ServicePtrs[snum], f);
5172 }
5173 }
5174
5175 /***************************************************************************
5176 Return the number of the service with the given name, or -1 if it doesn't
5177 exist. Note that this is a DIFFERENT ANIMAL from the internal function
5178 getservicebyname()! This works ONLY if all services have been loaded, and
5179 does not copy the found service.
5180 ***************************************************************************/
5181
5182 int lp_servicenumber(const char *pszServiceName)
5183 {
5184 int iService;
5185 fstring serviceName;
5186
5187 if (!pszServiceName) {
5188 return GLOBAL_SECTION_SNUM;
5189 }
5190
5191 for (iService = iNumServices - 1; iService >= 0; iService--) {
5192 if (VALID(iService) && ServicePtrs[iService]->szService) {
5193 /*
5194 * The substitution here is used to support %U is
5195 * service names
5196 */
5197 fstrcpy(serviceName, ServicePtrs[iService]->szService);
5198 standard_sub_basic(get_current_username(),
5199 current_user_info.domain,
5200 serviceName,sizeof(serviceName));
5201 if (strequal(serviceName, pszServiceName)) {
5202 break;
5203 }
5204 }
5205 }
5206
5207 if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
5208 time_t last_mod;
5209
5210 if (!usershare_exists(iService, &last_mod)) {
5211 /* Remove the share security tdb entry for it. */
5212 delete_share_security(snum2params_static(iService));
5213 /* Remove it from the array. */
5214 free_service_byindex(iService);
5215 /* Doesn't exist anymore. */
5216 return GLOBAL_SECTION_SNUM;
5217 }
5218
5219 /* Has it been modified ? If so delete and reload. */
5220 if (ServicePtrs[iService]->usershare_last_mod < last_mod) {
5221 /* Remove it from the array. */
5222 free_service_byindex(iService);
5223 /* and now reload it. */
5224 iService = load_usershare_service(pszServiceName);
5225 }
5226 }
5227
5228 if (iService < 0) {
5229 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
5230 return GLOBAL_SECTION_SNUM;
5231 }
5232
5233 return (iService);
5234 }
5235
5236 BOOL share_defined(const char *service_name)
5237 {
5238 return (lp_servicenumber(service_name) != -1);
5239 }
5240
5241 struct share_params *get_share_params(TALLOC_CTX *mem_ctx,
5242 const char *sharename)
5243 {
5244 struct share_params *result;
5245 char *sname;
5246 int snum;
5247
5248 if (!(sname = SMB_STRDUP(sharename))) {
5249 return NULL;
5250 }
5251
5252 snum = find_service(sname);
5253 SAFE_FREE(sname);
5254
5255 if (snum < 0) {
5256 return NULL;
5257 }
5258
5259 if (!(result = TALLOC_P(mem_ctx, struct share_params))) {
5260 DEBUG(0, ("talloc failed\n"));
5261 return NULL;
5262 }
5263
5264 result->service = snum;
5265 return result;
5266 }
5267
5268 struct share_iterator *share_list_all(TALLOC_CTX *mem_ctx)
5269 {
5270 struct share_iterator *result;
5271
5272 if (!(result = TALLOC_P(mem_ctx, struct share_iterator))) {
5273 DEBUG(0, ("talloc failed\n"));
5274 return NULL;
5275 }
5276
5277 result->next_id = 0;
5278 return result;
5279 }
5280
5281 struct share_params *next_share(struct share_iterator *list)
5282 {
5283 struct share_params *result;
5284
5285 while (!lp_snum_ok(list->next_id) &&
5286 (list->next_id < lp_numservices())) {
5287 list->next_id += 1;
5288 }
5289
5290 if (list->next_id >= lp_numservices()) {
5291 return NULL;
5292 }
5293
5294 if (!(result = TALLOC_P(list, struct share_params))) {
5295 DEBUG(0, ("talloc failed\n"));
5296 return NULL;
5297 }
5298
5299 result->service = list->next_id;
5300 list->next_id += 1;
5301 return result;
5302 }
5303
5304 struct share_params *next_printer(struct share_iterator *list)
5305 {
5306 struct share_params *result;
5307
5308 while ((result = next_share(list)) != NULL) {
5309 if (lp_print_ok(result->service)) {
5310 break;
5311 }
5312 }
5313 return result;
5314 }
5315
5316 /*
5317 * This is a hack for a transition period until we transformed all code from
5318 * service numbers to struct share_params.
5319 */
5320
5321 struct share_params *snum2params_static(int snum)
5322 {
5323 static struct share_params result;
5324 result.service = snum;
5325 return &result;
5326 }
5327
5328 /*******************************************************************
5329 A useful volume label function.
5330 ********************************************************************/
5331
5332 const char *volume_label(int snum)
5333 {
5334 char *ret;
5335 const char *label = lp_volume(snum);
5336 if (!*label) {
5337 label = lp_servicename(snum);
5338 }
5339
5340 /* This returns a 33 byte guarenteed null terminated string. */
5341 ret = talloc_strndup(main_loop_talloc_get(), label, 32);
5342 if (!ret) {
5343 return "";
5344 }
5345 return ret;
5346 }
5347
5348 /*******************************************************************
5349 Set the server type we will announce as via nmbd.
5350 ********************************************************************/
5351
5352 static void set_default_server_announce_type(void)
5353 {
5354 default_server_announce = 0;
5355 default_server_announce |= SV_TYPE_WORKSTATION;
5356 default_server_announce |= SV_TYPE_SERVER;
5357 default_server_announce |= SV_TYPE_SERVER_UNIX;
5358
5359 /* note that the flag should be set only if we have a
5360 printer service but nmbd doesn't actually load the
5361 services so we can't tell --jerry */
5362
5363 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
5364
5365 switch (lp_announce_as()) {
5366 case ANNOUNCE_AS_NT_SERVER:
5367 default_server_announce |= SV_TYPE_SERVER_NT;
5368 /* fall through... */
5369 case ANNOUNCE_AS_NT_WORKSTATION:
5370 default_server_announce |= SV_TYPE_NT;
5371 break;
5372 case ANNOUNCE_AS_WIN95:
5373 default_server_announce |= SV_TYPE_WIN95_PLUS;
5374 break;
5375 case ANNOUNCE_AS_WFW:
5376 default_server_announce |= SV_TYPE_WFW;
5377 break;
5378 default:
5379 break;
5380 }
5381
5382 switch (lp_server_role()) {
5383 case ROLE_DOMAIN_MEMBER:
5384 default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
5385 break;
5386 case ROLE_DOMAIN_PDC:
5387 default_server_announce |= SV_TYPE_DOMAIN_CTRL;
5388 break;
5389 case ROLE_DOMAIN_BDC:
5390 default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
5391 break;
5392 case ROLE_STANDALONE:
5393 default:
5394 break;
5395 }
5396 if (lp_time_server())
5397 default_server_announce |= SV_TYPE_TIME_SOURCE;
5398
5399 if (lp_host_msdfs())
5400 default_server_announce |= SV_TYPE_DFS_SERVER;
5401 }
5402
5403 /***********************************************************
5404 returns role of Samba server
5405 ************************************************************/
5406
5407 int lp_server_role(void)
5408 {
5409 return server_role;
5410 }
5411
5412 /***********************************************************
5413 If we are PDC then prefer us as DMB
5414 ************************************************************/
5415
5416 BOOL lp_domain_master(void)
5417 {
5418 if (Globals.bDomainMaster == Auto)
5419 return (lp_server_role() == ROLE_DOMAIN_PDC);
5420
5421 return Globals.bDomainMaster;
5422 }
5423
5424 /***********************************************************
5425 If we are DMB then prefer us as LMB
5426 ************************************************************/
5427
5428 BOOL lp_preferred_master(void)
5429 {
5430 if (Globals.bPreferredMaster == Auto)
5431 return (lp_local_master() && lp_domain_master());
5432
5433 return Globals.bPreferredMaster;
5434 }
5435
5436 /*******************************************************************
5437 Remove a service.
5438 ********************************************************************/
5439
5440 void lp_remove_service(int snum)
5441 {
5442 ServicePtrs[snum]->valid = False;
5443 invalid_services[num_invalid_services++] = snum;
5444 }
5445
5446 /*******************************************************************
5447 Copy a service.
5448 ********************************************************************/
5449
5450 void lp_copy_service(int snum, const char *new_name)
5451 {
5452 do_section(new_name);
5453 if (snum >= 0) {
5454 snum = lp_servicenumber(new_name);
5455 if (snum >= 0)
5456 lp_do_parameter(snum, "copy", lp_servicename(snum));
5457 }
5458 }
5459
5460
5461 /*******************************************************************
5462 Get the default server type we will announce as via nmbd.
5463 ********************************************************************/
5464
5465 int lp_default_server_announce(void)
5466 {
5467 return default_server_announce;
5468 }
5469
5470 /*******************************************************************
5471 Split the announce version into major and minor numbers.
5472 ********************************************************************/
5473
5474 int lp_major_announce_version(void)
5475 {
5476 static BOOL got_major = False;
5477 static int major_version = DEFAULT_MAJOR_VERSION;
5478 char *vers;
5479 char *p;
5480
5481 if (got_major)
5482 return major_version;
5483
5484 got_major = True;
5485 if ((vers = lp_announce_version()) == NULL)
5486 return major_version;
5487
5488 if ((p = strchr_m(vers, '.')) == 0)
5489 return major_version;
5490
5491 *p = '\0';
5492 major_version = atoi(vers);
5493 return major_version;
5494 }
5495
5496 int lp_minor_announce_version(void)
5497 {
5498 static BOOL got_minor = False;
5499 static int minor_version = DEFAULT_MINOR_VERSION;
5500 char *vers;
5501 char *p;
5502
5503 if (got_minor)
5504 return minor_version;
5505
5506 got_minor = True;
5507 if ((vers = lp_announce_version()) == NULL)
5508 return minor_version;
5509
5510 if ((p = strchr_m(vers, '.')) == 0)
5511 return minor_version;
5512
5513 p++;
5514 minor_version = atoi(p);
5515 return minor_version;
5516 }
5517
5518 /***********************************************************
5519 Set the global name resolution order (used in smbclient).
5520 ************************************************************/
5521
5522 void lp_set_name_resolve_order(const char *new_order)
5523 {
5524 string_set(&Globals.szNameResolveOrder, new_order);
5525 }
5526
5527 const char *lp_printername(int snum)
5528 {
5529 const char *ret = _lp_printername(snum);
5530 if (ret == NULL || (ret != NULL && *ret == '\0'))
5531 ret = lp_const_servicename(snum);
5532
5533 return ret;
5534 }
5535
5536
5537 /***********************************************************
5538 Allow daemons such as winbindd to fix their logfile name.
5539 ************************************************************/
5540
5541 void lp_set_logfile(const char *name)
5542 {
5543 string_set(&Globals.szLogFile, name);
5544 pstrcpy(debugf, name);
5545 }
5546
5547 /*******************************************************************
5548 Return the max print jobs per queue.
5549 ********************************************************************/
5550
5551 int lp_maxprintjobs(int snum)
5552 {
5553 int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
5554 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
5555 maxjobs = PRINT_MAX_JOBID - 1;
5556
5557 return maxjobs;
5558 }
5559
5560 const char *lp_printcapname(void)
5561 {
5562 if ((Globals.szPrintcapname != NULL) &&
5563 (Globals.szPrintcapname[0] != '\0'))
5564 return Globals.szPrintcapname;
5565
5566 if (sDefault.iPrinting == PRINT_CUPS) {
5567 #ifdef HAVE_CUPS
5568 return "cups";
5569 #else
5570 return "lpstat";
5571 #endif
5572 }
5573
5574 if (sDefault.iPrinting == PRINT_BSD)
5575 return "/etc/printcap";
5576
5577 return PRINTCAP_NAME;
5578 }
5579
5580 /*******************************************************************
5581 Ensure we don't use sendfile if server smb signing is active.
5582 ********************************************************************/
5583
5584 static uint32 spoolss_state;
5585
5586 BOOL lp_disable_spoolss( void )
5587 {
5588 if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
5589 spoolss_state = _lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
5590
5591 return spoolss_state == SVCCTL_STOPPED ? True : False;
5592 }
5593
5594 void lp_set_spoolss_state( uint32 state )
5595 {
5596 SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
5597
5598 spoolss_state = state;
5599 }
5600
5601 uint32 lp_get_spoolss_state( void )
5602 {
5603 return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
5604 }
5605
5606 /*******************************************************************
5607 Ensure we don't use sendfile if server smb signing is active.
5608 ********************************************************************/
5609
5610 BOOL lp_use_sendfile(int snum)
5611 {
5612 /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
5613 if (Protocol < PROTOCOL_NT1) {
5614 return False;
5615 }
5616 return (_lp_use_sendfile(snum) && (get_remote_arch() != RA_WIN95) && !srv_is_signing_active());
5617 }
5618
5619 /*******************************************************************
5620 Turn off sendfile if we find the underlying OS doesn't support it.
5621 ********************************************************************/
5622
5623 void set_use_sendfile(int snum, BOOL val)
5624 {
5625 if (LP_SNUM_OK(snum))
5626 ServicePtrs[snum]->bUseSendfile = val;
5627 else
5628 sDefault.bUseSendfile = val;
5629 }
5630
5631 /*******************************************************************
5632 Turn off storing DOS attributes if this share doesn't support it.
5633 ********************************************************************/
5634
5635 void set_store_dos_attributes(int snum, BOOL val)
5636 {
5637 if (!LP_SNUM_OK(snum))
5638 return;
5639 ServicePtrs[(snum)]->bStoreDosAttributes = val;
5640 }
5641
5642 void lp_set_mangling_method(const char *new_method)
5643 {
5644 string_set(&Globals.szManglingMethod, new_method);
5645 }
5646
5647 /*******************************************************************
5648 Global state for POSIX pathname processing.
5649 ********************************************************************/
5650
5651 static BOOL posix_pathnames;
5652
5653 BOOL lp_posix_pathnames(void)
5654 {
5655 return posix_pathnames;
5656 }
5657
5658 /*******************************************************************
5659 Change everything needed to ensure POSIX pathname processing (currently
5660 not much).
5661 ********************************************************************/
5662
5663 void lp_set_posix_pathnames(void)
5664 {
5665 posix_pathnames = True;
5666 }
5667
5668 /*******************************************************************
5669 Global state for POSIX lock processing - CIFS unix extensions.
5670 ********************************************************************/
5671
5672 BOOL posix_default_lock_was_set;
5673 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
5674
5675 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
5676 {
5677 if (posix_default_lock_was_set) {
5678 return posix_cifsx_locktype;
5679 } else {
5680 return fsp->posix_open ? POSIX_LOCK : WINDOWS_LOCK;
5681 }
5682 }
5683
5684 /*******************************************************************
5685 ********************************************************************/
5686
5687 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
5688 {
5689 posix_default_lock_was_set = True;
5690 posix_cifsx_locktype = val;
5691 }
Samba GIT mirror