?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix bug #5729. Explicitly allow "-valid".
[Samba.git] / source / param / loadparm.c
blob0ac16d1c2a9e7e0ebc43efd33c1c607734e03adf
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_ON;
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 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
2659
2660 if (i < 0)
2661 return (False);
2662
2663 if (!(*(ServicePtrs[iDefaultService]->szPath))
2664 || strequal(ServicePtrs[iDefaultService]->szPath, lp_pathname(GLOBAL_SECTION_SNUM))) {
2665 pstrcpy(newHomedir, pszHomedir);
2666 string_set(&ServicePtrs[i]->szPath, newHomedir);
2667 }
2668
2669 if (!(*(ServicePtrs[i]->comment))) {
2670 pstring comment;
2671 slprintf(comment, sizeof(comment) - 1,
2672 "Home directory of %s", user);
2673 string_set(&ServicePtrs[i]->comment, comment);
2674 }
2675
2676 /* set the browseable flag from the global default */
2677
2678 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2679
2680 ServicePtrs[i]->autoloaded = True;
2681
2682 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
2683 user, ServicePtrs[i]->szPath ));
2684
2685 return (True);
2686 }
2687
2688 /***************************************************************************
2689 Add a new service, based on an old one.
2690 ***************************************************************************/
2691
2692 int lp_add_service(const char *pszService, int iDefaultService)
2693 {
2694 return (add_a_service(ServicePtrs[iDefaultService], pszService));
2695 }
2696
2697 /***************************************************************************
2698 Add the IPC service.
2699 ***************************************************************************/
2700
2701 static BOOL lp_add_ipc(const char *ipc_name, BOOL guest_ok)
2702 {
2703 pstring comment;
2704 int i = add_a_service(&sDefault, ipc_name);
2705
2706 if (i < 0)
2707 return (False);
2708
2709 slprintf(comment, sizeof(comment) - 1,
2710 "IPC Service (%s)", Globals.szServerString);
2711
2712 string_set(&ServicePtrs[i]->szPath, tmpdir());
2713 string_set(&ServicePtrs[i]->szUsername, "");
2714 string_set(&ServicePtrs[i]->comment, comment);
2715 string_set(&ServicePtrs[i]->fstype, "IPC");
2716 ServicePtrs[i]->iMaxConnections = 0;
2717 ServicePtrs[i]->bAvailable = True;
2718 ServicePtrs[i]->bRead_only = True;
2719 ServicePtrs[i]->bGuest_only = False;
2720 ServicePtrs[i]->bAdministrative_share = True;
2721 ServicePtrs[i]->bGuest_ok = guest_ok;
2722 ServicePtrs[i]->bPrint_ok = False;
2723 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2724
2725 DEBUG(3, ("adding IPC service\n"));
2726
2727 return (True);
2728 }
2729
2730 /***************************************************************************
2731 Add a new printer service, with defaults coming from service iFrom.
2732 ***************************************************************************/
2733
2734 BOOL lp_add_printer(const char *pszPrintername, int iDefaultService)
2735 {
2736 const char *comment = "From Printcap";
2737 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
2738
2739 if (i < 0)
2740 return (False);
2741
2742 /* note that we do NOT default the availability flag to True - */
2743 /* we take it from the default service passed. This allows all */
2744 /* dynamic printers to be disabled by disabling the [printers] */
2745 /* entry (if/when the 'available' keyword is implemented!). */
2746
2747 /* the printer name is set to the service name. */
2748 string_set(&ServicePtrs[i]->szPrintername, pszPrintername);
2749 string_set(&ServicePtrs[i]->comment, comment);
2750
2751 /* set the browseable flag from the gloabl default */
2752 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2753
2754 /* Printers cannot be read_only. */
2755 ServicePtrs[i]->bRead_only = False;
2756 /* No share modes on printer services. */
2757 ServicePtrs[i]->bShareModes = False;
2758 /* No oplocks on printer services. */
2759 ServicePtrs[i]->bOpLocks = False;
2760 /* Printer services must be printable. */
2761 ServicePtrs[i]->bPrint_ok = True;
2762
2763 DEBUG(3, ("adding printer service %s\n", pszPrintername));
2764
2765 return (True);
2766 }
2767
2768 /***************************************************************************
2769 Map a parameter's string representation to something we can use.
2770 Returns False if the parameter string is not recognised, else TRUE.
2771 ***************************************************************************/
2772
2773 static int map_parameter(const char *pszParmName)
2774 {
2775 int iIndex;
2776
2777 if (*pszParmName == '-' && !strequal(pszParmName, "-valid"))
2778 return (-1);
2779
2780 for (iIndex = 0; parm_table[iIndex].label; iIndex++)
2781 if (strwicmp(parm_table[iIndex].label, pszParmName) == 0)
2782 return (iIndex);
2783
2784 /* Warn only if it isn't parametric option */
2785 if (strchr(pszParmName, ':') == NULL)
2786 DEBUG(0, ("Unknown parameter encountered: \"%s\"\n", pszParmName));
2787 /* We do return 'fail' for parametric options as well because they are
2788 stored in different storage
2789 */
2790 return (-1);
2791 }
2792
2793 /***************************************************************************
2794 Show all parameter's name, type, [values,] and flags.
2795 ***************************************************************************/
2796
2797 void show_parameter_list(void)
2798 {
2799 int classIndex, parmIndex, enumIndex, flagIndex;
2800 BOOL hadFlag;
2801 const char *section_names[] = { "local", "global", NULL};
2802 const char *type[] = { "P_BOOL", "P_BOOLREV", "P_CHAR", "P_INTEGER",
2803 "P_OCTAL", "P_LIST", "P_STRING", "P_USTRING", "P_GSTRING",
2804 "P_UGSTRING", "P_ENUM", "P_SEP"};
2805 unsigned flags[] = { FLAG_BASIC, FLAG_SHARE, FLAG_PRINT, FLAG_GLOBAL,
2806 FLAG_WIZARD, FLAG_ADVANCED, FLAG_DEVELOPER, FLAG_DEPRECATED,
2807 FLAG_HIDE, FLAG_DOS_STRING};
2808 const char *flag_names[] = { "FLAG_BASIC", "FLAG_SHARE", "FLAG_PRINT",
2809 "FLAG_GLOBAL", "FLAG_WIZARD", "FLAG_ADVANCED", "FLAG_DEVELOPER",
2810 "FLAG_DEPRECATED", "FLAG_HIDE", "FLAG_DOS_STRING", NULL};
2811
2812 for ( classIndex=0; section_names[classIndex]; classIndex++) {
2813 printf("[%s]\n", section_names[classIndex]);
2814 for (parmIndex = 0; parm_table[parmIndex].label; parmIndex++) {
2815 if (parm_table[parmIndex].p_class == classIndex) {
2816 printf("%s=%s",
2817 parm_table[parmIndex].label,
2818 type[parm_table[parmIndex].type]);
2819 switch (parm_table[parmIndex].type) {
2820 case P_ENUM:
2821 printf(",");
2822 for (enumIndex=0; parm_table[parmIndex].enum_list[enumIndex].name; enumIndex++)
2823 printf("%s%s",
2824 enumIndex ? "|" : "",
2825 parm_table[parmIndex].enum_list[enumIndex].name);
2826 break;
2827 default:
2828 break;
2829 }
2830 printf(",");
2831 hadFlag = False;
2832 for ( flagIndex=0; flag_names[flagIndex]; flagIndex++ ) {
2833 if (parm_table[parmIndex].flags & flags[flagIndex]) {
2834 printf("%s%s",
2835 hadFlag ? "|" : "",
2836 flag_names[flagIndex]);
2837 hadFlag = True;
2838 }
2839 }
2840 printf("\n");
2841 }
2842 }
2843 }
2844 }
2845
2846 /***************************************************************************
2847 Set a boolean variable from the text value stored in the passed string.
2848 Returns True in success, False if the passed string does not correctly
2849 represent a boolean.
2850 ***************************************************************************/
2851
2852 static BOOL set_boolean(BOOL *pb, const char *pszParmValue)
2853 {
2854 BOOL bRetval;
2855
2856 bRetval = True;
2857 if (strwicmp(pszParmValue, "yes") == 0 ||
2858 strwicmp(pszParmValue, "true") == 0 ||
2859 strwicmp(pszParmValue, "1") == 0)
2860 *pb = True;
2861 else if (strwicmp(pszParmValue, "no") == 0 ||
2862 strwicmp(pszParmValue, "False") == 0 ||
2863 strwicmp(pszParmValue, "0") == 0)
2864 *pb = False;
2865 else {
2866 DEBUG(0,
2867 ("ERROR: Badly formed boolean in configuration file: \"%s\".\n",
2868 pszParmValue));
2869 bRetval = False;
2870 }
2871 return (bRetval);
2872 }
2873
2874 /***************************************************************************
2875 Find a service by name. Otherwise works like get_service.
2876 ***************************************************************************/
2877
2878 static int getservicebyname(const char *pszServiceName, service * pserviceDest)
2879 {
2880 int iService = -1;
2881 char *canon_name;
2882
2883 if (ServiceHash != NULL) {
2884 if ( !(canon_name = canonicalize_servicename( pszServiceName )) )
2885 return -1;
2886
2887 iService = tdb_fetch_int32(ServiceHash, canon_name );
2888
2889 if (LP_SNUM_OK(iService)) {
2890 if (pserviceDest != NULL) {
2891 copy_service(pserviceDest, ServicePtrs[iService], NULL);
2892 }
2893 } else {
2894 iService = -1;
2895 }
2896 }
2897
2898 return (iService);
2899 }
2900
2901 /***************************************************************************
2902 Copy a service structure to another.
2903 If pcopymapDest is NULL then copy all fields
2904 ***************************************************************************/
2905
2906 static void copy_service(service * pserviceDest, service * pserviceSource, BOOL *pcopymapDest)
2907 {
2908 int i;
2909 BOOL bcopyall = (pcopymapDest == NULL);
2910 param_opt_struct *data, *pdata, *paramo;
2911 BOOL not_added;
2912
2913 for (i = 0; parm_table[i].label; i++)
2914 if (parm_table[i].ptr && parm_table[i].p_class == P_LOCAL &&
2915 (bcopyall || pcopymapDest[i])) {
2916 void *def_ptr = parm_table[i].ptr;
2917 void *src_ptr =
2918 ((char *)pserviceSource) + PTR_DIFF(def_ptr,
2919 &sDefault);
2920 void *dest_ptr =
2921 ((char *)pserviceDest) + PTR_DIFF(def_ptr,
2922 &sDefault);
2923
2924 switch (parm_table[i].type) {
2925 case P_BOOL:
2926 case P_BOOLREV:
2927 *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
2928 break;
2929
2930 case P_INTEGER:
2931 case P_ENUM:
2932 case P_OCTAL:
2933 *(int *)dest_ptr = *(int *)src_ptr;
2934 break;
2935
2936 case P_CHAR:
2937 *(char *)dest_ptr = *(char *)src_ptr;
2938 break;
2939
2940 case P_STRING:
2941 string_set((char **)dest_ptr,
2942 *(char **)src_ptr);
2943 break;
2944
2945 case P_USTRING:
2946 string_set((char **)dest_ptr,
2947 *(char **)src_ptr);
2948 strupper_m(*(char **)dest_ptr);
2949 break;
2950 case P_LIST:
2951 str_list_free((char ***)dest_ptr);
2952 str_list_copy((char ***)dest_ptr, *(const char ***)src_ptr);
2953 break;
2954 default:
2955 break;
2956 }
2957 }
2958
2959 if (bcopyall) {
2960 init_copymap(pserviceDest);
2961 if (pserviceSource->copymap)
2962 memcpy((void *)pserviceDest->copymap,
2963 (void *)pserviceSource->copymap,
2964 sizeof(BOOL) * NUMPARAMETERS);
2965 }
2966
2967 data = pserviceSource->param_opt;
2968 while (data) {
2969 not_added = True;
2970 pdata = pserviceDest->param_opt;
2971 /* Traverse destination */
2972 while (pdata) {
2973 /* If we already have same option, override it */
2974 if (strcmp(pdata->key, data->key) == 0) {
2975 string_free(&pdata->value);
2976 str_list_free(&data->list);
2977 pdata->value = SMB_STRDUP(data->value);
2978 not_added = False;
2979 break;
2980 }
2981 pdata = pdata->next;
2982 }
2983 if (not_added) {
2984 paramo = SMB_XMALLOC_P(param_opt_struct);
2985 paramo->key = SMB_STRDUP(data->key);
2986 paramo->value = SMB_STRDUP(data->value);
2987 paramo->list = NULL;
2988 DLIST_ADD(pserviceDest->param_opt, paramo);
2989 }
2990 data = data->next;
2991 }
2992 }
2993
2994 /***************************************************************************
2995 Check a service for consistency. Return False if the service is in any way
2996 incomplete or faulty, else True.
2997 ***************************************************************************/
2998
2999 static BOOL service_ok(int iService)
3000 {
3001 BOOL bRetval;
3002
3003 bRetval = True;
3004 if (ServicePtrs[iService]->szService[0] == '\0') {
3005 DEBUG(0, ("The following message indicates an internal error:\n"));
3006 DEBUG(0, ("No service name in service entry.\n"));
3007 bRetval = False;
3008 }
3009
3010 /* The [printers] entry MUST be printable. I'm all for flexibility, but */
3011 /* I can't see why you'd want a non-printable printer service... */
3012 if (strwicmp(ServicePtrs[iService]->szService, PRINTERS_NAME) == 0) {
3013 if (!ServicePtrs[iService]->bPrint_ok) {
3014 DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
3015 ServicePtrs[iService]->szService));
3016 ServicePtrs[iService]->bPrint_ok = True;
3017 }
3018 /* [printers] service must also be non-browsable. */
3019 if (ServicePtrs[iService]->bBrowseable)
3020 ServicePtrs[iService]->bBrowseable = False;
3021 }
3022
3023 if (ServicePtrs[iService]->szPath[0] == '\0' &&
3024 strwicmp(ServicePtrs[iService]->szService, HOMES_NAME) != 0 &&
3025 ServicePtrs[iService]->szMSDfsProxy[0] == '\0'
3026 ) {
3027 DEBUG(0, ("WARNING: No path in service %s - making it unavailable!\n",
3028 ServicePtrs[iService]->szService));
3029 ServicePtrs[iService]->bAvailable = False;
3030 }
3031
3032 /* If a service is flagged unavailable, log the fact at level 0. */
3033 if (!ServicePtrs[iService]->bAvailable)
3034 DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
3035 ServicePtrs[iService]->szService));
3036
3037 return (bRetval);
3038 }
3039
3040 static struct file_lists {
3041 struct file_lists *next;
3042 char *name;
3043 char *subfname;
3044 time_t modtime;
3045 } *file_lists = NULL;
3046
3047 /*******************************************************************
3048 Keep a linked list of all config files so we know when one has changed
3049 it's date and needs to be reloaded.
3050 ********************************************************************/
3051
3052 static void add_to_file_list(const char *fname, const char *subfname)
3053 {
3054 struct file_lists *f = file_lists;
3055
3056 while (f) {
3057 if (f->name && !strcmp(f->name, fname))
3058 break;
3059 f = f->next;
3060 }
3061
3062 if (!f) {
3063 f = SMB_MALLOC_P(struct file_lists);
3064 if (!f)
3065 return;
3066 f->next = file_lists;
3067 f->name = SMB_STRDUP(fname);
3068 if (!f->name) {
3069 SAFE_FREE(f);
3070 return;
3071 }
3072 f->subfname = SMB_STRDUP(subfname);
3073 if (!f->subfname) {
3074 SAFE_FREE(f);
3075 return;
3076 }
3077 file_lists = f;
3078 f->modtime = file_modtime(subfname);
3079 } else {
3080 time_t t = file_modtime(subfname);
3081 if (t)
3082 f->modtime = t;
3083 }
3084 }
3085
3086 /*******************************************************************
3087 Check if a config file has changed date.
3088 ********************************************************************/
3089
3090 BOOL lp_file_list_changed(void)
3091 {
3092 struct file_lists *f = file_lists;
3093
3094 DEBUG(6, ("lp_file_list_changed()\n"));
3095
3096 while (f) {
3097 pstring n2;
3098 time_t mod_time;
3099
3100 pstrcpy(n2, f->name);
3101 standard_sub_basic( get_current_username(),
3102 current_user_info.domain,
3103 n2, sizeof(n2) );
3104
3105 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
3106 f->name, n2, ctime(&f->modtime)));
3107
3108 mod_time = file_modtime(n2);
3109
3110 if (mod_time && ((f->modtime != mod_time) || (f->subfname == NULL) || (strcmp(n2, f->subfname) != 0))) {
3111 DEBUGADD(6,
3112 ("file %s modified: %s\n", n2,
3113 ctime(&mod_time)));
3114 f->modtime = mod_time;
3115 SAFE_FREE(f->subfname);
3116 f->subfname = SMB_STRDUP(n2);
3117 return (True);
3118 }
3119 f = f->next;
3120 }
3121 return (False);
3122 }
3123
3124 /***************************************************************************
3125 Run standard_sub_basic on netbios name... needed because global_myname
3126 is not accessed through any lp_ macro.
3127 Note: We must *NOT* use string_set() here as ptr points to global_myname.
3128 ***************************************************************************/
3129
3130 static BOOL handle_netbios_name(int snum, const char *pszParmValue, char **ptr)
3131 {
3132 BOOL ret;
3133 pstring netbios_name;
3134
3135 pstrcpy(netbios_name, pszParmValue);
3136
3137 standard_sub_basic(get_current_username(), current_user_info.domain,
3138 netbios_name, sizeof(netbios_name));
3139
3140 ret = set_global_myname(netbios_name);
3141 string_set(&Globals.szNetbiosName,global_myname());
3142
3143 DEBUG(4, ("handle_netbios_name: set global_myname to: %s\n",
3144 global_myname()));
3145
3146 return ret;
3147 }
3148
3149 static BOOL handle_charset(int snum, const char *pszParmValue, char **ptr)
3150 {
3151 if (strcmp(*ptr, pszParmValue) != 0) {
3152 string_set(ptr, pszParmValue);
3153 init_iconv();
3154 }
3155 return True;
3156 }
3157
3158
3159
3160 static BOOL handle_workgroup(int snum, const char *pszParmValue, char **ptr)
3161 {
3162 BOOL ret;
3163
3164 ret = set_global_myworkgroup(pszParmValue);
3165 string_set(&Globals.szWorkgroup,lp_workgroup());
3166
3167 return ret;
3168 }
3169
3170 static BOOL handle_netbios_scope(int snum, const char *pszParmValue, char **ptr)
3171 {
3172 BOOL ret;
3173
3174 ret = set_global_scope(pszParmValue);
3175 string_set(&Globals.szNetbiosScope,global_scope());
3176
3177 return ret;
3178 }
3179
3180 static BOOL handle_netbios_aliases(int snum, const char *pszParmValue, char **ptr)
3181 {
3182 str_list_free(&Globals.szNetbiosAliases);
3183 Globals.szNetbiosAliases = str_list_make(pszParmValue, NULL);
3184 return set_netbios_aliases((const char **)Globals.szNetbiosAliases);
3185 }
3186
3187 /***************************************************************************
3188 Handle the include operation.
3189 ***************************************************************************/
3190
3191 static BOOL handle_include(int snum, const char *pszParmValue, char **ptr)
3192 {
3193 pstring fname;
3194 pstrcpy(fname, pszParmValue);
3195
3196 standard_sub_basic(get_current_username(), current_user_info.domain,
3197 fname,sizeof(fname));
3198
3199 add_to_file_list(pszParmValue, fname);
3200
3201 string_set(ptr, fname);
3202
3203 if (file_exist(fname, NULL))
3204 return (pm_process(fname, do_section, do_parameter));
3205
3206 DEBUG(2, ("Can't find include file %s\n", fname));
3207
3208 return (False);
3209 }
3210
3211 /***************************************************************************
3212 Handle the interpretation of the copy parameter.
3213 ***************************************************************************/
3214
3215 static BOOL handle_copy(int snum, const char *pszParmValue, char **ptr)
3216 {
3217 BOOL bRetval;
3218 int iTemp;
3219 service serviceTemp;
3220
3221 string_set(ptr, pszParmValue);
3222
3223 init_service(&serviceTemp);
3224
3225 bRetval = False;
3226
3227 DEBUG(3, ("Copying service from service %s\n", pszParmValue));
3228
3229 if ((iTemp = getservicebyname(pszParmValue, &serviceTemp)) >= 0) {
3230 if (iTemp == iServiceIndex) {
3231 DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
3232 } else {
3233 copy_service(ServicePtrs[iServiceIndex],
3234 &serviceTemp,
3235 ServicePtrs[iServiceIndex]->copymap);
3236 bRetval = True;
3237 }
3238 } else {
3239 DEBUG(0, ("Unable to copy service - source not found: %s\n", pszParmValue));
3240 bRetval = False;
3241 }
3242
3243 free_service(&serviceTemp);
3244 return (bRetval);
3245 }
3246
3247 static BOOL handle_ldap_debug_level(int snum, const char *pszParmValue, char **ptr)
3248 {
3249 Globals.ldap_debug_level = lp_int(pszParmValue);
3250 init_ldap_debugging();
3251 return True;
3252 }
3253
3254 /***************************************************************************
3255 Handle idmap/non unix account uid and gid allocation parameters. The format of these
3256 parameters is:
3257
3258 [global]
3259
3260 idmap uid = 1000-1999
3261 idmap gid = 700-899
3262
3263 We only do simple parsing checks here. The strings are parsed into useful
3264 structures in the idmap daemon code.
3265
3266 ***************************************************************************/
3267
3268 /* Some lp_ routines to return idmap [ug]id information */
3269
3270 static uid_t idmap_uid_low, idmap_uid_high;
3271 static gid_t idmap_gid_low, idmap_gid_high;
3272
3273 BOOL lp_idmap_uid(uid_t *low, uid_t *high)
3274 {
3275 if (idmap_uid_low == 0 || idmap_uid_high == 0)
3276 return False;
3277
3278 if (low)
3279 *low = idmap_uid_low;
3280
3281 if (high)
3282 *high = idmap_uid_high;
3283
3284 return True;
3285 }
3286
3287 BOOL lp_idmap_gid(gid_t *low, gid_t *high)
3288 {
3289 if (idmap_gid_low == 0 || idmap_gid_high == 0)
3290 return False;
3291
3292 if (low)
3293 *low = idmap_gid_low;
3294
3295 if (high)
3296 *high = idmap_gid_high;
3297
3298 return True;
3299 }
3300
3301 /* Do some simple checks on "idmap [ug]id" parameter values */
3302
3303 static BOOL handle_idmap_uid(int snum, const char *pszParmValue, char **ptr)
3304 {
3305 uint32 low, high;
3306
3307 if (sscanf(pszParmValue, "%u - %u", &low, &high) != 2 || high < low)
3308 return False;
3309
3310 /* Parse OK */
3311
3312 string_set(ptr, pszParmValue);
3313
3314 idmap_uid_low = low;
3315 idmap_uid_high = high;
3316
3317 return True;
3318 }
3319
3320 static BOOL handle_idmap_gid(int snum, const char *pszParmValue, char **ptr)
3321 {
3322 uint32 low, high;
3323
3324 if (sscanf(pszParmValue, "%u - %u", &low, &high) != 2 || high < low)
3325 return False;
3326
3327 /* Parse OK */
3328
3329 string_set(ptr, pszParmValue);
3330
3331 idmap_gid_low = low;
3332 idmap_gid_high = high;
3333
3334 return True;
3335 }
3336
3337 /***************************************************************************
3338 Handle the DEBUG level list.
3339 ***************************************************************************/
3340
3341 static BOOL handle_debug_list( int snum, const char *pszParmValueIn, char **ptr )
3342 {
3343 pstring pszParmValue;
3344
3345 pstrcpy(pszParmValue, pszParmValueIn);
3346 string_set(ptr, pszParmValueIn);
3347 return debug_parse_levels( pszParmValue );
3348 }
3349
3350 /***************************************************************************
3351 Handle ldap suffixes - default to ldapsuffix if sub-suffixes are not defined.
3352 ***************************************************************************/
3353
3354 static const char *append_ldap_suffix( const char *str )
3355 {
3356 const char *suffix_string;
3357
3358
3359 if (!lp_talloc)
3360 lp_talloc = talloc_init("lp_talloc");
3361
3362 suffix_string = talloc_asprintf( lp_talloc, "%s,%s", str, Globals.szLdapSuffix );
3363 if ( !suffix_string ) {
3364 DEBUG(0,("append_ldap_suffix: talloc_asprintf() failed!\n"));
3365 return "";
3366 }
3367
3368 return suffix_string;
3369 }
3370
3371 const char *lp_ldap_machine_suffix(void)
3372 {
3373 if (Globals.szLdapMachineSuffix[0])
3374 return append_ldap_suffix(Globals.szLdapMachineSuffix);
3375
3376 return lp_string(Globals.szLdapSuffix);
3377 }
3378
3379 const char *lp_ldap_user_suffix(void)
3380 {
3381 if (Globals.szLdapUserSuffix[0])
3382 return append_ldap_suffix(Globals.szLdapUserSuffix);
3383
3384 return lp_string(Globals.szLdapSuffix);
3385 }
3386
3387 const char *lp_ldap_group_suffix(void)
3388 {
3389 if (Globals.szLdapGroupSuffix[0])
3390 return append_ldap_suffix(Globals.szLdapGroupSuffix);
3391
3392 return lp_string(Globals.szLdapSuffix);
3393 }
3394
3395 const char *lp_ldap_idmap_suffix(void)
3396 {
3397 if (Globals.szLdapIdmapSuffix[0])
3398 return append_ldap_suffix(Globals.szLdapIdmapSuffix);
3399
3400 return lp_string(Globals.szLdapSuffix);
3401 }
3402
3403 /****************************************************************************
3404 set the value for a P_ENUM
3405 ***************************************************************************/
3406
3407 static void lp_set_enum_parm( struct parm_struct *parm, const char *pszParmValue,
3408 int *ptr )
3409 {
3410 int i;
3411
3412 for (i = 0; parm->enum_list[i].name; i++) {
3413 if ( strequal(pszParmValue, parm->enum_list[i].name)) {
3414 *ptr = parm->enum_list[i].value;
3415 break;
3416 }
3417 }
3418 }
3419
3420 /***************************************************************************
3421 ***************************************************************************/
3422
3423 static BOOL handle_printing(int snum, const char *pszParmValue, char **ptr)
3424 {
3425 static int parm_num = -1;
3426 service *s;
3427
3428 if ( parm_num == -1 )
3429 parm_num = map_parameter( "printing" );
3430
3431 lp_set_enum_parm( &parm_table[parm_num], pszParmValue, (int*)ptr );
3432
3433 if ( snum < 0 )
3434 s = &sDefault;
3435 else
3436 s = ServicePtrs[snum];
3437
3438 init_printer_values( s );
3439
3440 return True;
3441 }
3442
3443
3444 /***************************************************************************
3445 Initialise a copymap.
3446 ***************************************************************************/
3447
3448 static void init_copymap(service * pservice)
3449 {
3450 int i;
3451 SAFE_FREE(pservice->copymap);
3452 pservice->copymap = SMB_MALLOC_ARRAY(BOOL,NUMPARAMETERS);
3453 if (!pservice->copymap)
3454 DEBUG(0,
3455 ("Couldn't allocate copymap!! (size %d)\n",
3456 (int)NUMPARAMETERS));
3457 else
3458 for (i = 0; i < NUMPARAMETERS; i++)
3459 pservice->copymap[i] = True;
3460 }
3461
3462 /***************************************************************************
3463 Return the local pointer to a parameter given the service number and the
3464 pointer into the default structure.
3465 ***************************************************************************/
3466
3467 void *lp_local_ptr(int snum, void *ptr)
3468 {
3469 return (void *)(((char *)ServicePtrs[snum]) + PTR_DIFF(ptr, &sDefault));
3470 }
3471
3472 /***************************************************************************
3473 Process a parameter for a particular service number. If snum < 0
3474 then assume we are in the globals.
3475 ***************************************************************************/
3476
3477 BOOL lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
3478 {
3479 int parmnum, i, slen;
3480 void *parm_ptr = NULL; /* where we are going to store the result */
3481 void *def_ptr = NULL;
3482 pstring param_key;
3483 char *sep;
3484 param_opt_struct *paramo, *data;
3485 BOOL not_added;
3486
3487 parmnum = map_parameter(pszParmName);
3488
3489 if (parmnum < 0) {
3490 if ((sep=strchr(pszParmName, ':')) != NULL) {
3491 *sep = '\0';
3492 ZERO_STRUCT(param_key);
3493 pstr_sprintf(param_key, "%s:", pszParmName);
3494 slen = strlen(param_key);
3495 pstrcat(param_key, sep+1);
3496 trim_char(param_key+slen, ' ', ' ');
3497 not_added = True;
3498 data = (snum < 0) ? Globals.param_opt :
3499 ServicePtrs[snum]->param_opt;
3500 /* Traverse destination */
3501 while (data) {
3502 /* If we already have same option, override it */
3503 if (strcmp(data->key, param_key) == 0) {
3504 string_free(&data->value);
3505 str_list_free(&data->list);
3506 data->value = SMB_STRDUP(pszParmValue);
3507 not_added = False;
3508 break;
3509 }
3510 data = data->next;
3511 }
3512 if (not_added) {
3513 paramo = SMB_XMALLOC_P(param_opt_struct);
3514 paramo->key = SMB_STRDUP(param_key);
3515 paramo->value = SMB_STRDUP(pszParmValue);
3516 paramo->list = NULL;
3517 if (snum < 0) {
3518 DLIST_ADD(Globals.param_opt, paramo);
3519 } else {
3520 DLIST_ADD(ServicePtrs[snum]->param_opt, paramo);
3521 }
3522 }
3523
3524 *sep = ':';
3525 return (True);
3526 }
3527 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
3528 return (True);
3529 }
3530
3531 if (parm_table[parmnum].flags & FLAG_DEPRECATED) {
3532 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
3533 pszParmName));
3534 }
3535
3536 def_ptr = parm_table[parmnum].ptr;
3537
3538 /* we might point at a service, the default service or a global */
3539 if (snum < 0) {
3540 parm_ptr = def_ptr;
3541 } else {
3542 if (parm_table[parmnum].p_class == P_GLOBAL) {
3543 DEBUG(0,
3544 ("Global parameter %s found in service section!\n",
3545 pszParmName));
3546 return (True);
3547 }
3548 parm_ptr =
3549 ((char *)ServicePtrs[snum]) + PTR_DIFF(def_ptr,
3550 &sDefault);
3551 }
3552
3553 if (snum >= 0) {
3554 if (!ServicePtrs[snum]->copymap)
3555 init_copymap(ServicePtrs[snum]);
3556
3557 /* this handles the aliases - set the copymap for other entries with
3558 the same data pointer */
3559 for (i = 0; parm_table[i].label; i++)
3560 if (parm_table[i].ptr == parm_table[parmnum].ptr)
3561 ServicePtrs[snum]->copymap[i] = False;
3562 }
3563
3564 /* if it is a special case then go ahead */
3565 if (parm_table[parmnum].special) {
3566 parm_table[parmnum].special(snum, pszParmValue, (char **)parm_ptr);
3567 return (True);
3568 }
3569
3570 /* now switch on the type of variable it is */
3571 switch (parm_table[parmnum].type)
3572 {
3573 case P_BOOL:
3574 *(BOOL *)parm_ptr = lp_bool(pszParmValue);
3575 break;
3576
3577 case P_BOOLREV:
3578 *(BOOL *)parm_ptr = !lp_bool(pszParmValue);
3579 break;
3580
3581 case P_INTEGER:
3582 *(int *)parm_ptr = lp_int(pszParmValue);
3583 break;
3584
3585 case P_CHAR:
3586 *(char *)parm_ptr = *pszParmValue;
3587 break;
3588
3589 case P_OCTAL:
3590 i = sscanf(pszParmValue, "%o", (int *)parm_ptr);
3591 if ( i != 1 ) {
3592 DEBUG ( 0, ("Invalid octal number %s\n", pszParmName ));
3593 }
3594 break;
3595
3596 case P_LIST:
3597 str_list_free((char ***)parm_ptr);
3598 *(char ***)parm_ptr = str_list_make(pszParmValue, NULL);
3599 break;
3600
3601 case P_STRING:
3602 string_set((char **)parm_ptr, pszParmValue);
3603 break;
3604
3605 case P_USTRING:
3606 string_set((char **)parm_ptr, pszParmValue);
3607 strupper_m(*(char **)parm_ptr);
3608 break;
3609
3610 case P_GSTRING:
3611 pstrcpy((char *)parm_ptr, pszParmValue);
3612 break;
3613
3614 case P_UGSTRING:
3615 pstrcpy((char *)parm_ptr, pszParmValue);
3616 strupper_m((char *)parm_ptr);
3617 break;
3618
3619 case P_ENUM:
3620 lp_set_enum_parm( &parm_table[parmnum], pszParmValue, (int*)parm_ptr );
3621 break;
3622 case P_SEP:
3623 break;
3624 }
3625
3626 return (True);
3627 }
3628
3629 /***************************************************************************
3630 Process a parameter.
3631 ***************************************************************************/
3632
3633 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue)
3634 {
3635 if (!bInGlobalSection && bGlobalOnly)
3636 return (True);
3637
3638 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
3639
3640 return (lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
3641 pszParmName, pszParmValue));
3642 }
3643
3644 /***************************************************************************
3645 Print a parameter of the specified type.
3646 ***************************************************************************/
3647
3648 static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
3649 {
3650 int i;
3651 switch (p->type)
3652 {
3653 case P_ENUM:
3654 for (i = 0; p->enum_list[i].name; i++) {
3655 if (*(int *)ptr == p->enum_list[i].value) {
3656 fprintf(f, "%s",
3657 p->enum_list[i].name);
3658 break;
3659 }
3660 }
3661 break;
3662
3663 case P_BOOL:
3664 fprintf(f, "%s", BOOLSTR(*(BOOL *)ptr));
3665 break;
3666
3667 case P_BOOLREV:
3668 fprintf(f, "%s", BOOLSTR(!*(BOOL *)ptr));
3669 break;
3670
3671 case P_INTEGER:
3672 fprintf(f, "%d", *(int *)ptr);
3673 break;
3674
3675 case P_CHAR:
3676 fprintf(f, "%c", *(char *)ptr);
3677 break;
3678
3679 case P_OCTAL:
3680 fprintf(f, "%s", octal_string(*(int *)ptr));
3681 break;
3682
3683 case P_LIST:
3684 if ((char ***)ptr && *(char ***)ptr) {
3685 char **list = *(char ***)ptr;
3686
3687 for (; *list; list++) {
3688 /* surround strings with whitespace in double quotes */
3689 if ( strchr_m( *list, ' ' ) )
3690 fprintf(f, "\"%s\"%s", *list, ((*(list+1))?", ":""));
3691 else
3692 fprintf(f, "%s%s", *list, ((*(list+1))?", ":""));
3693 }
3694 }
3695 break;
3696
3697 case P_GSTRING:
3698 case P_UGSTRING:
3699 if ((char *)ptr) {
3700 fprintf(f, "%s", (char *)ptr);
3701 }
3702 break;
3703
3704 case P_STRING:
3705 case P_USTRING:
3706 if (*(char **)ptr) {
3707 fprintf(f, "%s", *(char **)ptr);
3708 }
3709 break;
3710 case P_SEP:
3711 break;
3712 }
3713 }
3714
3715 /***************************************************************************
3716 Check if two parameters are equal.
3717 ***************************************************************************/
3718
3719 static BOOL equal_parameter(parm_type type, void *ptr1, void *ptr2)
3720 {
3721 switch (type) {
3722 case P_BOOL:
3723 case P_BOOLREV:
3724 return (*((BOOL *)ptr1) == *((BOOL *)ptr2));
3725
3726 case P_INTEGER:
3727 case P_ENUM:
3728 case P_OCTAL:
3729 return (*((int *)ptr1) == *((int *)ptr2));
3730
3731 case P_CHAR:
3732 return (*((char *)ptr1) == *((char *)ptr2));
3733
3734 case P_LIST:
3735 return str_list_compare(*(char ***)ptr1, *(char ***)ptr2);
3736
3737 case P_GSTRING:
3738 case P_UGSTRING:
3739 {
3740 char *p1 = (char *)ptr1, *p2 = (char *)ptr2;
3741 if (p1 && !*p1)
3742 p1 = NULL;
3743 if (p2 && !*p2)
3744 p2 = NULL;
3745 return (p1 == p2 || strequal(p1, p2));
3746 }
3747 case P_STRING:
3748 case P_USTRING:
3749 {
3750 char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
3751 if (p1 && !*p1)
3752 p1 = NULL;
3753 if (p2 && !*p2)
3754 p2 = NULL;
3755 return (p1 == p2 || strequal(p1, p2));
3756 }
3757 case P_SEP:
3758 break;
3759 }
3760 return (False);
3761 }
3762
3763 /***************************************************************************
3764 Initialize any local varients in the sDefault table.
3765 ***************************************************************************/
3766
3767 void init_locals(void)
3768 {
3769 /* None as yet. */
3770 }
3771
3772 /***************************************************************************
3773 Process a new section (service). At this stage all sections are services.
3774 Later we'll have special sections that permit server parameters to be set.
3775 Returns True on success, False on failure.
3776 ***************************************************************************/
3777
3778 static BOOL do_section(const char *pszSectionName)
3779 {
3780 BOOL bRetval;
3781 BOOL isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
3782 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
3783 bRetval = False;
3784
3785 /* if we were in a global section then do the local inits */
3786 if (bInGlobalSection && !isglobal)
3787 init_locals();
3788
3789 /* if we've just struck a global section, note the fact. */
3790 bInGlobalSection = isglobal;
3791
3792 /* check for multiple global sections */
3793 if (bInGlobalSection) {
3794 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
3795 return (True);
3796 }
3797
3798 if (!bInGlobalSection && bGlobalOnly)
3799 return (True);
3800
3801 /* if we have a current service, tidy it up before moving on */
3802 bRetval = True;
3803
3804 if (iServiceIndex >= 0)
3805 bRetval = service_ok(iServiceIndex);
3806
3807 /* if all is still well, move to the next record in the services array */
3808 if (bRetval) {
3809 /* We put this here to avoid an odd message order if messages are */
3810 /* issued by the post-processing of a previous section. */
3811 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
3812
3813 if ((iServiceIndex = add_a_service(&sDefault, pszSectionName))
3814 < 0) {
3815 DEBUG(0, ("Failed to add a new service\n"));
3816 return (False);
3817 }
3818 }
3819
3820 return (bRetval);
3821 }
3822
3823
3824 /***************************************************************************
3825 Determine if a partcular base parameter is currentl set to the default value.
3826 ***************************************************************************/
3827
3828 static BOOL is_default(int i)
3829 {
3830 if (!defaults_saved)
3831 return False;
3832 switch (parm_table[i].type) {
3833 case P_LIST:
3834 return str_list_compare (parm_table[i].def.lvalue,
3835 *(char ***)parm_table[i].ptr);
3836 case P_STRING:
3837 case P_USTRING:
3838 return strequal(parm_table[i].def.svalue,
3839 *(char **)parm_table[i].ptr);
3840 case P_GSTRING:
3841 case P_UGSTRING:
3842 return strequal(parm_table[i].def.svalue,
3843 (char *)parm_table[i].ptr);
3844 case P_BOOL:
3845 case P_BOOLREV:
3846 return parm_table[i].def.bvalue ==
3847 *(BOOL *)parm_table[i].ptr;
3848 case P_CHAR:
3849 return parm_table[i].def.cvalue ==
3850 *(char *)parm_table[i].ptr;
3851 case P_INTEGER:
3852 case P_OCTAL:
3853 case P_ENUM:
3854 return parm_table[i].def.ivalue ==
3855 *(int *)parm_table[i].ptr;
3856 case P_SEP:
3857 break;
3858 }
3859 return False;
3860 }
3861
3862 /***************************************************************************
3863 Display the contents of the global structure.
3864 ***************************************************************************/
3865
3866 static void dump_globals(FILE *f)
3867 {
3868 int i;
3869 param_opt_struct *data;
3870
3871 fprintf(f, "[global]\n");
3872
3873 for (i = 0; parm_table[i].label; i++)
3874 if (parm_table[i].p_class == P_GLOBAL &&
3875 parm_table[i].ptr &&
3876 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
3877 if (defaults_saved && is_default(i))
3878 continue;
3879 fprintf(f, "\t%s = ", parm_table[i].label);
3880 print_parameter(&parm_table[i], parm_table[i].ptr, f);
3881 fprintf(f, "\n");
3882 }
3883 if (Globals.param_opt != NULL) {
3884 data = Globals.param_opt;
3885 while(data) {
3886 fprintf(f, "\t%s = %s\n", data->key, data->value);
3887 data = data->next;
3888 }
3889 }
3890
3891 }
3892
3893 /***************************************************************************
3894 Return True if a local parameter is currently set to the global default.
3895 ***************************************************************************/
3896
3897 BOOL lp_is_default(int snum, struct parm_struct *parm)
3898 {
3899 int pdiff = PTR_DIFF(parm->ptr, &sDefault);
3900
3901 return equal_parameter(parm->type,
3902 ((char *)ServicePtrs[snum]) + pdiff,
3903 ((char *)&sDefault) + pdiff);
3904 }
3905
3906 /***************************************************************************
3907 Display the contents of a single services record.
3908 ***************************************************************************/
3909
3910 static void dump_a_service(service * pService, FILE * f)
3911 {
3912 int i;
3913 param_opt_struct *data;
3914
3915 if (pService != &sDefault)
3916 fprintf(f, "[%s]\n", pService->szService);
3917
3918 for (i = 0; parm_table[i].label; i++) {
3919
3920 if (parm_table[i].p_class == P_LOCAL &&
3921 parm_table[i].ptr &&
3922 (*parm_table[i].label != '-') &&
3923 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
3924 {
3925
3926 int pdiff = PTR_DIFF(parm_table[i].ptr, &sDefault);
3927
3928 if (pService == &sDefault) {
3929 if (defaults_saved && is_default(i))
3930 continue;
3931 } else {
3932 if (equal_parameter(parm_table[i].type,
3933 ((char *)pService) +
3934 pdiff,
3935 ((char *)&sDefault) +
3936 pdiff))
3937 continue;
3938 }
3939
3940 fprintf(f, "\t%s = ", parm_table[i].label);
3941 print_parameter(&parm_table[i],
3942 ((char *)pService) + pdiff, f);
3943 fprintf(f, "\n");
3944 }
3945 }
3946
3947 if (pService->param_opt != NULL) {
3948 data = pService->param_opt;
3949 while(data) {
3950 fprintf(f, "\t%s = %s\n", data->key, data->value);
3951 data = data->next;
3952 }
3953 }
3954 }
3955
3956 /***************************************************************************
3957 Display the contents of a parameter of a single services record.
3958 ***************************************************************************/
3959
3960 BOOL dump_a_parameter(int snum, char *parm_name, FILE * f, BOOL isGlobal)
3961 {
3962 int i;
3963 BOOL result = False;
3964 parm_class p_class;
3965 unsigned flag = 0;
3966 fstring local_parm_name;
3967 char *parm_opt;
3968 const char *parm_opt_value;
3969
3970 /* check for parametrical option */
3971 fstrcpy( local_parm_name, parm_name);
3972 parm_opt = strchr( local_parm_name, ':');
3973
3974 if (parm_opt) {
3975 *parm_opt = '\0';
3976 parm_opt++;
3977 if (strlen(parm_opt)) {
3978 parm_opt_value = lp_parm_const_string( snum,
3979 local_parm_name, parm_opt, NULL);
3980 if (parm_opt_value) {
3981 printf( "%s\n", parm_opt_value);
3982 result = True;
3983 }
3984 }
3985 return result;
3986 }
3987
3988 /* check for a key and print the value */
3989 if (isGlobal) {
3990 p_class = P_GLOBAL;
3991 flag = FLAG_GLOBAL;
3992 } else
3993 p_class = P_LOCAL;
3994
3995 for (i = 0; parm_table[i].label; i++) {
3996 if (strwicmp(parm_table[i].label, parm_name) == 0 &&
3997 (parm_table[i].p_class == p_class || parm_table[i].flags & flag) &&
3998 parm_table[i].ptr &&
3999 (*parm_table[i].label != '-') &&
4000 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
4001 {
4002 void *ptr;
4003
4004 if (isGlobal) {
4005 ptr = parm_table[i].ptr;
4006 } else {
4007 service * pService = ServicePtrs[snum];
4008 ptr = ((char *)pService) +
4009 PTR_DIFF(parm_table[i].ptr, &sDefault);
4010 }
4011
4012 print_parameter(&parm_table[i],
4013 ptr, f);
4014 fprintf(f, "\n");
4015 result = True;
4016 break;
4017 }
4018 }
4019
4020 return result;
4021 }
4022
4023 /***************************************************************************
4024 Return info about the next service in a service. snum==GLOBAL_SECTION_SNUM gives the globals.
4025 Return NULL when out of parameters.
4026 ***************************************************************************/
4027
4028 struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters)
4029 {
4030 if (snum < 0) {
4031 /* do the globals */
4032 for (; parm_table[*i].label; (*i)++) {
4033 if (parm_table[*i].p_class == P_SEPARATOR)
4034 return &parm_table[(*i)++];
4035
4036 if (!parm_table[*i].ptr
4037 || (*parm_table[*i].label == '-'))
4038 continue;
4039
4040 if ((*i) > 0
4041 && (parm_table[*i].ptr ==
4042 parm_table[(*i) - 1].ptr))
4043 continue;
4044
4045 return &parm_table[(*i)++];
4046 }
4047 } else {
4048 service *pService = ServicePtrs[snum];
4049
4050 for (; parm_table[*i].label; (*i)++) {
4051 if (parm_table[*i].p_class == P_SEPARATOR)
4052 return &parm_table[(*i)++];
4053
4054 if (parm_table[*i].p_class == P_LOCAL &&
4055 parm_table[*i].ptr &&
4056 (*parm_table[*i].label != '-') &&
4057 ((*i) == 0 ||
4058 (parm_table[*i].ptr !=
4059 parm_table[(*i) - 1].ptr)))
4060 {
4061 int pdiff =
4062 PTR_DIFF(parm_table[*i].ptr,
4063 &sDefault);
4064
4065 if (allparameters ||
4066 !equal_parameter(parm_table[*i].type,
4067 ((char *)pService) +
4068 pdiff,
4069 ((char *)&sDefault) +
4070 pdiff))
4071 {
4072 return &parm_table[(*i)++];
4073 }
4074 }
4075 }
4076 }
4077
4078 return NULL;
4079 }
4080
4081
4082 #if 0
4083 /***************************************************************************
4084 Display the contents of a single copy structure.
4085 ***************************************************************************/
4086 static void dump_copy_map(BOOL *pcopymap)
4087 {
4088 int i;
4089 if (!pcopymap)
4090 return;
4091
4092 printf("\n\tNon-Copied parameters:\n");
4093
4094 for (i = 0; parm_table[i].label; i++)
4095 if (parm_table[i].p_class == P_LOCAL &&
4096 parm_table[i].ptr && !pcopymap[i] &&
4097 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
4098 {
4099 printf("\t\t%s\n", parm_table[i].label);
4100 }
4101 }
4102 #endif
4103
4104 /***************************************************************************
4105 Return TRUE if the passed service number is within range.
4106 ***************************************************************************/
4107
4108 BOOL lp_snum_ok(int iService)
4109 {
4110 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
4111 }
4112
4113 /***************************************************************************
4114 Auto-load some home services.
4115 ***************************************************************************/
4116
4117 static void lp_add_auto_services(char *str)
4118 {
4119 char *s;
4120 char *p;
4121 int homes;
4122
4123 if (!str)
4124 return;
4125
4126 s = SMB_STRDUP(str);
4127 if (!s)
4128 return;
4129
4130 homes = lp_servicenumber(HOMES_NAME);
4131
4132 for (p = strtok(s, LIST_SEP); p; p = strtok(NULL, LIST_SEP)) {
4133 char *home = get_user_home_dir(p);
4134
4135 if (lp_servicenumber(p) >= 0)
4136 continue;
4137
4138 if (home && homes >= 0)
4139 lp_add_home(p, homes, p, home);
4140 }
4141 SAFE_FREE(s);
4142 }
4143
4144 /***************************************************************************
4145 Auto-load one printer.
4146 ***************************************************************************/
4147
4148 void lp_add_one_printer(char *name, char *comment)
4149 {
4150 int printers = lp_servicenumber(PRINTERS_NAME);
4151 int i;
4152
4153 if (lp_servicenumber(name) < 0) {
4154 lp_add_printer(name, printers);
4155 if ((i = lp_servicenumber(name)) >= 0) {
4156 string_set(&ServicePtrs[i]->comment, comment);
4157 ServicePtrs[i]->autoloaded = True;
4158 }
4159 }
4160 }
4161
4162 /***************************************************************************
4163 Have we loaded a services file yet?
4164 ***************************************************************************/
4165
4166 BOOL lp_loaded(void)
4167 {
4168 return (bLoaded);
4169 }
4170
4171 /***************************************************************************
4172 Unload unused services.
4173 ***************************************************************************/
4174
4175 void lp_killunused(BOOL (*snumused) (int))
4176 {
4177 int i;
4178 for (i = 0; i < iNumServices; i++) {
4179 if (!VALID(i))
4180 continue;
4181
4182 /* don't kill autoloaded or usershare services */
4183 if ( ServicePtrs[i]->autoloaded ||
4184 ServicePtrs[i]->usershare == USERSHARE_VALID) {
4185 continue;
4186 }
4187
4188 if (!snumused || !snumused(i)) {
4189 free_service_byindex(i);
4190 }
4191 }
4192 }
4193
4194 /***************************************************************************
4195 Unload a service.
4196 ***************************************************************************/
4197
4198 void lp_killservice(int iServiceIn)
4199 {
4200 if (VALID(iServiceIn)) {
4201 free_service_byindex(iServiceIn);
4202 }
4203 }
4204
4205 /***************************************************************************
4206 Save the curent values of all global and sDefault parameters into the
4207 defaults union. This allows swat and testparm to show only the
4208 changed (ie. non-default) parameters.
4209 ***************************************************************************/
4210
4211 static void lp_save_defaults(void)
4212 {
4213 int i;
4214 for (i = 0; parm_table[i].label; i++) {
4215 if (i > 0 && parm_table[i].ptr == parm_table[i - 1].ptr)
4216 continue;
4217 switch (parm_table[i].type) {
4218 case P_LIST:
4219 str_list_copy(&(parm_table[i].def.lvalue),
4220 *(const char ***)parm_table[i].ptr);
4221 break;
4222 case P_STRING:
4223 case P_USTRING:
4224 if (parm_table[i].ptr) {
4225 parm_table[i].def.svalue = SMB_STRDUP(*(char **)parm_table[i].ptr);
4226 } else {
4227 parm_table[i].def.svalue = NULL;
4228 }
4229 break;
4230 case P_GSTRING:
4231 case P_UGSTRING:
4232 if (parm_table[i].ptr) {
4233 parm_table[i].def.svalue = SMB_STRDUP((char *)parm_table[i].ptr);
4234 } else {
4235 parm_table[i].def.svalue = NULL;
4236 }
4237 break;
4238 case P_BOOL:
4239 case P_BOOLREV:
4240 parm_table[i].def.bvalue =
4241 *(BOOL *)parm_table[i].ptr;
4242 break;
4243 case P_CHAR:
4244 parm_table[i].def.cvalue =
4245 *(char *)parm_table[i].ptr;
4246 break;
4247 case P_INTEGER:
4248 case P_OCTAL:
4249 case P_ENUM:
4250 parm_table[i].def.ivalue =
4251 *(int *)parm_table[i].ptr;
4252 break;
4253 case P_SEP:
4254 break;
4255 }
4256 }
4257 defaults_saved = True;
4258 }
4259
4260 /*******************************************************************
4261 Set the server type we will announce as via nmbd.
4262 ********************************************************************/
4263
4264 static const struct srv_role_tab {
4265 uint32 role;
4266 const char *role_str;
4267 } srv_role_tab [] = {
4268 { ROLE_STANDALONE, "ROLE_STANDALONE" },
4269 { ROLE_DOMAIN_MEMBER, "ROLE_DOMAIN_MEMBER" },
4270 { ROLE_DOMAIN_BDC, "ROLE_DOMAIN_BDC" },
4271 { ROLE_DOMAIN_PDC, "ROLE_DOMAIN_PDC" },
4272 { 0, NULL }
4273 };
4274
4275 const char* server_role_str(uint32 role)
4276 {
4277 int i = 0;
4278 for (i=0; srv_role_tab[i].role_str; i++) {
4279 if (role == srv_role_tab[i].role) {
4280 return srv_role_tab[i].role_str;
4281 }
4282 }
4283 return NULL;
4284 }
4285
4286 static void set_server_role(void)
4287 {
4288 server_role = ROLE_STANDALONE;
4289
4290 switch (lp_security()) {
4291 case SEC_SHARE:
4292 if (lp_domain_logons())
4293 DEBUG(0, ("Server's Role (logon server) conflicts with share-level security\n"));
4294 break;
4295 case SEC_SERVER:
4296 if (lp_domain_logons())
4297 DEBUG(0, ("Server's Role (logon server) conflicts with server-level security\n"));
4298 /* this used to be considered ROLE_DOMAIN_MEMBER but that's just wrong */
4299 server_role = ROLE_STANDALONE;
4300 break;
4301 case SEC_DOMAIN:
4302 if (lp_domain_logons()) {
4303 DEBUG(1, ("Server's Role (logon server) NOT ADVISED with domain-level security\n"));
4304 server_role = ROLE_DOMAIN_BDC;
4305 break;
4306 }
4307 server_role = ROLE_DOMAIN_MEMBER;
4308 break;
4309 case SEC_ADS:
4310 if (lp_domain_logons()) {
4311 server_role = ROLE_DOMAIN_PDC;
4312 break;
4313 }
4314 server_role = ROLE_DOMAIN_MEMBER;
4315 break;
4316 case SEC_USER:
4317 if (lp_domain_logons()) {
4318
4319 if (Globals.bDomainMaster) /* auto or yes */
4320 server_role = ROLE_DOMAIN_PDC;
4321 else
4322 server_role = ROLE_DOMAIN_BDC;
4323 }
4324 break;
4325 default:
4326 DEBUG(0, ("Server's Role undefined due to unknown security mode\n"));
4327 break;
4328 }
4329
4330 DEBUG(10, ("set_server_role: role = %s\n", server_role_str(server_role)));
4331 }
4332
4333 /***********************************************************
4334 If we should send plaintext/LANMAN passwords in the clinet
4335 ************************************************************/
4336
4337 static void set_allowed_client_auth(void)
4338 {
4339 if (Globals.bClientNTLMv2Auth) {
4340 Globals.bClientLanManAuth = False;
4341 }
4342 if (!Globals.bClientLanManAuth) {
4343 Globals.bClientPlaintextAuth = False;
4344 }
4345 }
4346
4347 /***************************************************************************
4348 JRA.
4349 The following code allows smbd to read a user defined share file.
4350 Yes, this is my intent. Yes, I'm comfortable with that...
4351
4352 THE FOLLOWING IS SECURITY CRITICAL CODE.
4353
4354 It washes your clothes, it cleans your house, it guards you while you sleep...
4355 Do not f%^k with it....
4356 ***************************************************************************/
4357
4358 #define MAX_USERSHARE_FILE_SIZE (10*1024)
4359
4360 /***************************************************************************
4361 Check allowed stat state of a usershare file.
4362 Ensure we print out who is dicking with us so the admin can
4363 get their sorry ass fired.
4364 ***************************************************************************/
4365
4366 static BOOL check_usershare_stat(const char *fname, SMB_STRUCT_STAT *psbuf)
4367 {
4368 if (!S_ISREG(psbuf->st_mode)) {
4369 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
4370 "not a regular file\n",
4371 fname, (unsigned int)psbuf->st_uid ));
4372 return False;
4373 }
4374
4375 /* Ensure this doesn't have the other write bit set. */
4376 if (psbuf->st_mode & S_IWOTH) {
4377 DEBUG(0,("check_usershare_stat: file %s owned by uid %u allows "
4378 "public write. Refusing to allow as a usershare file.\n",
4379 fname, (unsigned int)psbuf->st_uid ));
4380 return False;
4381 }
4382
4383 /* Should be 10k or less. */
4384 if (psbuf->st_size > MAX_USERSHARE_FILE_SIZE) {
4385 DEBUG(0,("check_usershare_stat: file %s owned by uid %u is "
4386 "too large (%u) to be a user share file.\n",
4387 fname, (unsigned int)psbuf->st_uid,
4388 (unsigned int)psbuf->st_size ));
4389 return False;
4390 }
4391
4392 return True;
4393 }
4394
4395 /***************************************************************************
4396 Parse the contents of a usershare file.
4397 ***************************************************************************/
4398
4399 enum usershare_err parse_usershare_file(TALLOC_CTX *ctx,
4400 SMB_STRUCT_STAT *psbuf,
4401 const char *servicename,
4402 int snum,
4403 char **lines,
4404 int numlines,
4405 pstring sharepath,
4406 pstring comment,
4407 SEC_DESC **ppsd,
4408 BOOL *pallow_guest)
4409 {
4410 const char **prefixallowlist = lp_usershare_prefix_allow_list();
4411 const char **prefixdenylist = lp_usershare_prefix_deny_list();
4412 int us_vers;
4413 SMB_STRUCT_DIR *dp;
4414 SMB_STRUCT_STAT sbuf;
4415
4416 *pallow_guest = False;
4417
4418 if (numlines < 4) {
4419 return USERSHARE_MALFORMED_FILE;
4420 }
4421
4422 if (strcmp(lines[0], "#VERSION 1") == 0) {
4423 us_vers = 1;
4424 } else if (strcmp(lines[0], "#VERSION 2") == 0) {
4425 us_vers = 2;
4426 if (numlines < 5) {
4427 return USERSHARE_MALFORMED_FILE;
4428 }
4429 } else {
4430 return USERSHARE_BAD_VERSION;
4431 }
4432
4433 if (strncmp(lines[1], "path=", 5) != 0) {
4434 return USERSHARE_MALFORMED_PATH;
4435 }
4436
4437 pstrcpy(sharepath, &lines[1][5]);
4438 trim_string(sharepath, " ", " ");
4439
4440 if (strncmp(lines[2], "comment=", 8) != 0) {
4441 return USERSHARE_MALFORMED_COMMENT_DEF;
4442 }
4443
4444 pstrcpy(comment, &lines[2][8]);
4445 trim_string(comment, " ", " ");
4446 trim_char(comment, '"', '"');
4447
4448 if (strncmp(lines[3], "usershare_acl=", 14) != 0) {
4449 return USERSHARE_MALFORMED_ACL_DEF;
4450 }
4451
4452 if (!parse_usershare_acl(ctx, &lines[3][14], ppsd)) {
4453 return USERSHARE_ACL_ERR;
4454 }
4455
4456 if (us_vers == 2) {
4457 if (strncmp(lines[4], "guest_ok=", 9) != 0) {
4458 return USERSHARE_MALFORMED_ACL_DEF;
4459 }
4460 if (lines[4][9] == 'y') {
4461 *pallow_guest = True;
4462 }
4463 }
4464
4465 if (snum != -1 && (strcmp(sharepath, ServicePtrs[snum]->szPath) == 0)) {
4466 /* Path didn't change, no checks needed. */
4467 return USERSHARE_OK;
4468 }
4469
4470 /* The path *must* be absolute. */
4471 if (sharepath[0] != '/') {
4472 DEBUG(2,("parse_usershare_file: share %s: path %s is not an absolute path.\n",
4473 servicename, sharepath));
4474 return USERSHARE_PATH_NOT_ABSOLUTE;
4475 }
4476
4477 /* If there is a usershare prefix deny list ensure one of these paths
4478 doesn't match the start of the user given path. */
4479 if (prefixdenylist) {
4480 int i;
4481 for ( i=0; prefixdenylist[i]; i++ ) {
4482 DEBUG(10,("parse_usershare_file: share %s : checking prefixdenylist[%d]='%s' against %s\n",
4483 servicename, i, prefixdenylist[i], sharepath ));
4484 if (memcmp( sharepath, prefixdenylist[i], strlen(prefixdenylist[i])) == 0) {
4485 DEBUG(2,("parse_usershare_file: share %s path %s starts with one of the "
4486 "usershare prefix deny list entries.\n",
4487 servicename, sharepath));
4488 return USERSHARE_PATH_IS_DENIED;
4489 }
4490 }
4491 }
4492
4493 /* If there is a usershare prefix allow list ensure one of these paths
4494 does match the start of the user given path. */
4495
4496 if (prefixallowlist) {
4497 int i;
4498 for ( i=0; prefixallowlist[i]; i++ ) {
4499 DEBUG(10,("parse_usershare_file: share %s checking prefixallowlist[%d]='%s' against %s\n",
4500 servicename, i, prefixallowlist[i], sharepath ));
4501 if (memcmp( sharepath, prefixallowlist[i], strlen(prefixallowlist[i])) == 0) {
4502 break;
4503 }
4504 }
4505 if (prefixallowlist[i] == NULL) {
4506 DEBUG(2,("parse_usershare_file: share %s path %s doesn't start with one of the "
4507 "usershare prefix allow list entries.\n",
4508 servicename, sharepath));
4509 return USERSHARE_PATH_NOT_ALLOWED;
4510 }
4511 }
4512
4513 /* Ensure this is pointing to a directory. */
4514 dp = sys_opendir(sharepath);
4515
4516 if (!dp) {
4517 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
4518 servicename, sharepath));
4519 return USERSHARE_PATH_NOT_DIRECTORY;
4520 }
4521
4522 /* Ensure the owner of the usershare file has permission to share
4523 this directory. */
4524
4525 if (sys_stat(sharepath, &sbuf) == -1) {
4526 DEBUG(2,("parse_usershare_file: share %s : stat failed on path %s. %s\n",
4527 servicename, sharepath, strerror(errno) ));
4528 sys_closedir(dp);
4529 return USERSHARE_POSIX_ERR;
4530 }
4531
4532 sys_closedir(dp);
4533
4534 if (!S_ISDIR(sbuf.st_mode)) {
4535 DEBUG(2,("parse_usershare_file: share %s path %s is not a directory.\n",
4536 servicename, sharepath ));
4537 return USERSHARE_PATH_NOT_DIRECTORY;
4538 }
4539
4540 /* Check if sharing is restricted to owner-only. */
4541 /* psbuf is the stat of the usershare definition file,
4542 sbuf is the stat of the target directory to be shared. */
4543
4544 if (lp_usershare_owner_only()) {
4545 /* root can share anything. */
4546 if ((psbuf->st_uid != 0) && (sbuf.st_uid != psbuf->st_uid)) {
4547 return USERSHARE_PATH_NOT_ALLOWED;
4548 }
4549 }
4550
4551 return USERSHARE_OK;
4552 }
4553
4554 /***************************************************************************
4555 Deal with a usershare file.
4556 Returns:
4557 >= 0 - snum
4558 -1 - Bad name, invalid contents.
4559 - service name already existed and not a usershare, problem
4560 with permissions to share directory etc.
4561 ***************************************************************************/
4562
4563 static int process_usershare_file(const char *dir_name, const char *file_name, int snum_template)
4564 {
4565 SMB_STRUCT_STAT sbuf;
4566 SMB_STRUCT_STAT lsbuf;
4567 pstring fname;
4568 pstring sharepath;
4569 pstring comment;
4570 fstring service_name;
4571 char **lines = NULL;
4572 int numlines = 0;
4573 int fd = -1;
4574 int iService = -1;
4575 TALLOC_CTX *ctx = NULL;
4576 SEC_DESC *psd = NULL;
4577 BOOL guest_ok = False;
4578
4579 /* Ensure share name doesn't contain invalid characters. */
4580 if (!validate_net_name(file_name, INVALID_SHARENAME_CHARS, strlen(file_name))) {
4581 DEBUG(0,("process_usershare_file: share name %s contains "
4582 "invalid characters (any of %s)\n",
4583 file_name, INVALID_SHARENAME_CHARS ));
4584 return -1;
4585 }
4586
4587 fstrcpy(service_name, file_name);
4588
4589 pstrcpy(fname, dir_name);
4590 pstrcat(fname, "/");
4591 pstrcat(fname, file_name);
4592
4593 /* Minimize the race condition by doing an lstat before we
4594 open and fstat. Ensure this isn't a symlink link. */
4595
4596 if (sys_lstat(fname, &lsbuf) != 0) {
4597 DEBUG(0,("process_usershare_file: stat of %s failed. %s\n",
4598 fname, strerror(errno) ));
4599 return -1;
4600 }
4601
4602 /* This must be a regular file, not a symlink, directory or
4603 other strange filetype. */
4604 if (!check_usershare_stat(fname, &lsbuf)) {
4605 return -1;
4606 }
4607
4608 /* See if there is already a servicenum for this name. */
4609 /* tdb_fetch_int32 returns -1 if not found. */
4610 iService = (int)tdb_fetch_int32(ServiceHash, canonicalize_servicename(service_name) );
4611
4612 if (iService != -1 && ServicePtrs[iService]->usershare_last_mod == lsbuf.st_mtime) {
4613 /* Nothing changed - Mark valid and return. */
4614 DEBUG(10,("process_usershare_file: service %s not changed.\n",
4615 service_name ));
4616 ServicePtrs[iService]->usershare = USERSHARE_VALID;
4617 return iService;
4618 }
4619
4620 /* Try and open the file read only - no symlinks allowed. */
4621 #ifdef O_NOFOLLOW
4622 fd = sys_open(fname, O_RDONLY|O_NOFOLLOW, 0);
4623 #else
4624 fd = sys_open(fname, O_RDONLY, 0);
4625 #endif
4626
4627 if (fd == -1) {
4628 DEBUG(0,("process_usershare_file: unable to open %s. %s\n",
4629 fname, strerror(errno) ));
4630 return -1;
4631 }
4632
4633 /* Now fstat to be *SURE* it's a regular file. */
4634 if (sys_fstat(fd, &sbuf) != 0) {
4635 close(fd);
4636 DEBUG(0,("process_usershare_file: fstat of %s failed. %s\n",
4637 fname, strerror(errno) ));
4638 return -1;
4639 }
4640
4641 /* Is it the same dev/inode as was lstated ? */
4642 if (lsbuf.st_dev != sbuf.st_dev || lsbuf.st_ino != sbuf.st_ino) {
4643 close(fd);
4644 DEBUG(0,("process_usershare_file: fstat of %s is a different file from lstat. "
4645 "Symlink spoofing going on ?\n", fname ));
4646 return -1;
4647 }
4648
4649 /* This must be a regular file, not a symlink, directory or
4650 other strange filetype. */
4651 if (!check_usershare_stat(fname, &sbuf)) {
4652 return -1;
4653 }
4654
4655 lines = fd_lines_load(fd, &numlines, MAX_USERSHARE_FILE_SIZE);
4656
4657 close(fd);
4658 if (lines == NULL) {
4659 DEBUG(0,("process_usershare_file: loading file %s owned by %u failed.\n",
4660 fname, (unsigned int)sbuf.st_uid ));
4661 return -1;
4662 }
4663
4664 /* Should we allow printers to be shared... ? */
4665 ctx = talloc_init("usershare_sd_xctx");
4666 if (!ctx) {
4667 file_lines_free(lines);
4668 return 1;
4669 }
4670
4671 if (parse_usershare_file(ctx, &sbuf, service_name,
4672 iService, lines, numlines, sharepath,
4673 comment, &psd, &guest_ok) != USERSHARE_OK) {
4674 talloc_destroy(ctx);
4675 file_lines_free(lines);
4676 return -1;
4677 }
4678
4679 file_lines_free(lines);
4680
4681 /* Everything ok - add the service possibly using a template. */
4682 if (iService < 0) {
4683 const service *sp = &sDefault;
4684 if (snum_template != -1) {
4685 sp = ServicePtrs[snum_template];
4686 }
4687
4688 if ((iService = add_a_service(sp, service_name)) < 0) {
4689 DEBUG(0, ("process_usershare_file: Failed to add "
4690 "new service %s\n", service_name));
4691 talloc_destroy(ctx);
4692 return -1;
4693 }
4694
4695 /* Read only is controlled by usershare ACL below. */
4696 ServicePtrs[iService]->bRead_only = False;
4697 }
4698
4699 /* Write the ACL of the new/modified share. */
4700 if (!set_share_security(service_name, psd)) {
4701 DEBUG(0, ("process_usershare_file: Failed to set share "
4702 "security for user share %s\n",
4703 service_name ));
4704 lp_remove_service(iService);
4705 talloc_destroy(ctx);
4706 return -1;
4707 }
4708
4709 talloc_destroy(ctx);
4710
4711 /* If from a template it may be marked invalid. */
4712 ServicePtrs[iService]->valid = True;
4713
4714 /* Set the service as a valid usershare. */
4715 ServicePtrs[iService]->usershare = USERSHARE_VALID;
4716
4717 /* Set guest access. */
4718 if (lp_usershare_allow_guests()) {
4719 ServicePtrs[iService]->bGuest_ok = guest_ok;
4720 }
4721
4722 /* And note when it was loaded. */
4723 ServicePtrs[iService]->usershare_last_mod = sbuf.st_mtime;
4724 string_set(&ServicePtrs[iService]->szPath, sharepath);
4725 string_set(&ServicePtrs[iService]->comment, comment);
4726
4727 return iService;
4728 }
4729
4730 /***************************************************************************
4731 Checks if a usershare entry has been modified since last load.
4732 ***************************************************************************/
4733
4734 static BOOL usershare_exists(int iService, time_t *last_mod)
4735 {
4736 SMB_STRUCT_STAT lsbuf;
4737 const char *usersharepath = Globals.szUsersharePath;
4738 pstring fname;
4739
4740 pstrcpy(fname, usersharepath);
4741 pstrcat(fname, "/");
4742 pstrcat(fname, ServicePtrs[iService]->szService);
4743
4744 if (sys_lstat(fname, &lsbuf) != 0) {
4745 return False;
4746 }
4747
4748 if (!S_ISREG(lsbuf.st_mode)) {
4749 return False;
4750 }
4751
4752 *last_mod = lsbuf.st_mtime;
4753 return True;
4754 }
4755
4756 /***************************************************************************
4757 Load a usershare service by name. Returns a valid servicenumber or -1.
4758 ***************************************************************************/
4759
4760 int load_usershare_service(const char *servicename)
4761 {
4762 SMB_STRUCT_STAT sbuf;
4763 const char *usersharepath = Globals.szUsersharePath;
4764 int max_user_shares = Globals.iUsershareMaxShares;
4765 int snum_template = -1;
4766
4767 if (*usersharepath == 0 || max_user_shares == 0) {
4768 return -1;
4769 }
4770
4771 if (sys_stat(usersharepath, &sbuf) != 0) {
4772 DEBUG(0,("load_usershare_service: stat of %s failed. %s\n",
4773 usersharepath, strerror(errno) ));
4774 return -1;
4775 }
4776
4777 if (!S_ISDIR(sbuf.st_mode)) {
4778 DEBUG(0,("load_usershare_service: %s is not a directory.\n",
4779 usersharepath ));
4780 return -1;
4781 }
4782
4783 /*
4784 * This directory must be owned by root, and have the 't' bit set.
4785 * It also must not be writable by "other".
4786 */
4787
4788 #ifdef S_ISVTX
4789 if (sbuf.st_uid != 0 || !(sbuf.st_mode & S_ISVTX) || (sbuf.st_mode & S_IWOTH)) {
4790 #else
4791 if (sbuf.st_uid != 0 || (sbuf.st_mode & S_IWOTH)) {
4792 #endif
4793 DEBUG(0,("load_usershare_service: directory %s is not owned by root "
4794 "or does not have the sticky bit 't' set or is writable by anyone.\n",
4795 usersharepath ));
4796 return -1;
4797 }
4798
4799 /* Ensure the template share exists if it's set. */
4800 if (Globals.szUsershareTemplateShare[0]) {
4801 /* We can't use lp_servicenumber here as we are recommending that
4802 template shares have -valid=False set. */
4803 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
4804 if (ServicePtrs[snum_template]->szService &&
4805 strequal(ServicePtrs[snum_template]->szService,
4806 Globals.szUsershareTemplateShare)) {
4807 break;
4808 }
4809 }
4810
4811 if (snum_template == -1) {
4812 DEBUG(0,("load_usershare_service: usershare template share %s "
4813 "does not exist.\n",
4814 Globals.szUsershareTemplateShare ));
4815 return -1;
4816 }
4817 }
4818
4819 return process_usershare_file(usersharepath, servicename, snum_template);
4820 }
4821
4822 /***************************************************************************
4823 Load all user defined shares from the user share directory.
4824 We only do this if we're enumerating the share list.
4825 This is the function that can delete usershares that have
4826 been removed.
4827 ***************************************************************************/
4828
4829 int load_usershare_shares(void)
4830 {
4831 SMB_STRUCT_DIR *dp;
4832 SMB_STRUCT_STAT sbuf;
4833 SMB_STRUCT_DIRENT *de;
4834 int num_usershares = 0;
4835 int max_user_shares = Globals.iUsershareMaxShares;
4836 unsigned int num_dir_entries, num_bad_dir_entries, num_tmp_dir_entries;
4837 unsigned int allowed_bad_entries = ((2*max_user_shares)/10);
4838 unsigned int allowed_tmp_entries = ((2*max_user_shares)/10);
4839 int iService;
4840 int snum_template = -1;
4841 const char *usersharepath = Globals.szUsersharePath;
4842 int ret = lp_numservices();
4843
4844 if (max_user_shares == 0 || *usersharepath == '\0') {
4845 return lp_numservices();
4846 }
4847
4848 if (sys_stat(usersharepath, &sbuf) != 0) {
4849 DEBUG(0,("load_usershare_shares: stat of %s failed. %s\n",
4850 usersharepath, strerror(errno) ));
4851 return ret;
4852 }
4853
4854 /*
4855 * This directory must be owned by root, and have the 't' bit set.
4856 * It also must not be writable by "other".
4857 */
4858
4859 #ifdef S_ISVTX
4860 if (sbuf.st_uid != 0 || !(sbuf.st_mode & S_ISVTX) || (sbuf.st_mode & S_IWOTH)) {
4861 #else
4862 if (sbuf.st_uid != 0 || (sbuf.st_mode & S_IWOTH)) {
4863 #endif
4864 DEBUG(0,("load_usershare_shares: directory %s is not owned by root "
4865 "or does not have the sticky bit 't' set or is writable by anyone.\n",
4866 usersharepath ));
4867 return ret;
4868 }
4869
4870 /* Ensure the template share exists if it's set. */
4871 if (Globals.szUsershareTemplateShare[0]) {
4872 /* We can't use lp_servicenumber here as we are recommending that
4873 template shares have -valid=False set. */
4874 for (snum_template = iNumServices - 1; snum_template >= 0; snum_template--) {
4875 if (ServicePtrs[snum_template]->szService &&
4876 strequal(ServicePtrs[snum_template]->szService,
4877 Globals.szUsershareTemplateShare)) {
4878 break;
4879 }
4880 }
4881
4882 if (snum_template == -1) {
4883 DEBUG(0,("load_usershare_shares: usershare template share %s "
4884 "does not exist.\n",
4885 Globals.szUsershareTemplateShare ));
4886 return ret;
4887 }
4888 }
4889
4890 /* Mark all existing usershares as pending delete. */
4891 for (iService = iNumServices - 1; iService >= 0; iService--) {
4892 if (VALID(iService) && ServicePtrs[iService]->usershare) {
4893 ServicePtrs[iService]->usershare = USERSHARE_PENDING_DELETE;
4894 }
4895 }
4896
4897 dp = sys_opendir(usersharepath);
4898 if (!dp) {
4899 DEBUG(0,("load_usershare_shares:: failed to open directory %s. %s\n",
4900 usersharepath, strerror(errno) ));
4901 return ret;
4902 }
4903
4904 for (num_dir_entries = 0, num_bad_dir_entries = 0, num_tmp_dir_entries = 0;
4905 (de = sys_readdir(dp));
4906 num_dir_entries++ ) {
4907 int r;
4908 const char *n = de->d_name;
4909
4910 /* Ignore . and .. */
4911 if (*n == '.') {
4912 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
4913 continue;
4914 }
4915 }
4916
4917 if (n[0] == ':') {
4918 /* Temporary file used when creating a share. */
4919 num_tmp_dir_entries++;
4920 }
4921
4922 /* Allow 20% tmp entries. */
4923 if (num_tmp_dir_entries > allowed_tmp_entries) {
4924 DEBUG(0,("load_usershare_shares: too many temp entries (%u) "
4925 "in directory %s\n",
4926 num_tmp_dir_entries, usersharepath));
4927 break;
4928 }
4929
4930 r = process_usershare_file(usersharepath, n, snum_template);
4931 if (r == 0) {
4932 /* Update the services count. */
4933 num_usershares++;
4934 if (num_usershares >= max_user_shares) {
4935 DEBUG(0,("load_usershare_shares: max user shares reached "
4936 "on file %s in directory %s\n",
4937 n, usersharepath ));
4938 break;
4939 }
4940 } else if (r == -1) {
4941 num_bad_dir_entries++;
4942 }
4943
4944 /* Allow 20% bad entries. */
4945 if (num_bad_dir_entries > allowed_bad_entries) {
4946 DEBUG(0,("load_usershare_shares: too many bad entries (%u) "
4947 "in directory %s\n",
4948 num_bad_dir_entries, usersharepath));
4949 break;
4950 }
4951
4952 /* Allow 20% bad entries. */
4953 if (num_dir_entries > max_user_shares + allowed_bad_entries) {
4954 DEBUG(0,("load_usershare_shares: too many total entries (%u) "
4955 "in directory %s\n",
4956 num_dir_entries, usersharepath));
4957 break;
4958 }
4959 }
4960
4961 sys_closedir(dp);
4962
4963 /* Sweep through and delete any non-refreshed usershares that are
4964 not currently in use. */
4965 for (iService = iNumServices - 1; iService >= 0; iService--) {
4966 if (VALID(iService) && (ServicePtrs[iService]->usershare == USERSHARE_PENDING_DELETE)) {
4967 if (conn_snum_used(iService)) {
4968 continue;
4969 }
4970 /* Remove from the share ACL db. */
4971 DEBUG(10,("load_usershare_shares: Removing deleted usershare %s\n",
4972 lp_servicename(iService) ));
4973 delete_share_security(snum2params_static(iService));
4974 free_service_byindex(iService);
4975 }
4976 }
4977
4978 return lp_numservices();
4979 }
4980
4981 /********************************************************
4982 Destroy global resources allocated in this file
4983 ********************************************************/
4984
4985 void gfree_loadparm(void)
4986 {
4987 struct file_lists *f;
4988 struct file_lists *next;
4989 int i;
4990
4991 lp_TALLOC_FREE();
4992
4993 /* Free the file lists */
4994
4995 f = file_lists;
4996 while( f ) {
4997 next = f->next;
4998 SAFE_FREE( f->name );
4999 SAFE_FREE( f->subfname );
5000 SAFE_FREE( f );
5001 f = next;
5002 }
5003
5004 /* Free resources allocated to services */
5005
5006 for ( i = 0; i < iNumServices; i++ ) {
5007 if ( VALID(i) ) {
5008 free_service_byindex(i);
5009 }
5010 }
5011
5012 SAFE_FREE( ServicePtrs );
5013 iNumServices = 0;
5014
5015 /* Now release all resources allocated to global
5016 parameters and the default service */
5017
5018 for (i = 0; parm_table[i].label; i++)
5019 {
5020 if ( parm_table[i].type == P_STRING
5021 || parm_table[i].type == P_USTRING )
5022 {
5023 string_free( (char**)parm_table[i].ptr );
5024 }
5025 else if (parm_table[i].type == P_LIST) {
5026 str_list_free( (char***)parm_table[i].ptr );
5027 }
5028 }
5029 }
5030
5031 /***************************************************************************
5032 Load the services array from the services file. Return True on success,
5033 False on failure.
5034 ***************************************************************************/
5035
5036 BOOL lp_load(const char *pszFname,
5037 BOOL global_only,
5038 BOOL save_defaults,
5039 BOOL add_ipc,
5040 BOOL initialize_globals)
5041 {
5042 pstring n2;
5043 BOOL bRetval;
5044 param_opt_struct *data, *pdata;
5045
5046 pstrcpy(n2, pszFname);
5047
5048 standard_sub_basic( get_current_username(), current_user_info.domain,
5049 n2,sizeof(n2) );
5050
5051 add_to_file_list(pszFname, n2);
5052
5053 bRetval = False;
5054
5055 DEBUG(3, ("lp_load: refreshing parameters\n"));
5056
5057 bInGlobalSection = True;
5058 bGlobalOnly = global_only;
5059
5060 init_globals(! initialize_globals);
5061 debug_init();
5062
5063 if (save_defaults) {
5064 init_locals();
5065 lp_save_defaults();
5066 }
5067
5068 if (Globals.param_opt != NULL) {
5069 data = Globals.param_opt;
5070 while (data) {
5071 string_free(&data->key);
5072 string_free(&data->value);
5073 str_list_free(&data->list);
5074 pdata = data->next;
5075 SAFE_FREE(data);
5076 data = pdata;
5077 }
5078 Globals.param_opt = NULL;
5079 }
5080
5081 /* We get sections first, so have to start 'behind' to make up */
5082 iServiceIndex = -1;
5083 bRetval = pm_process(n2, do_section, do_parameter);
5084
5085 /* finish up the last section */
5086 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
5087 if (bRetval)
5088 if (iServiceIndex >= 0)
5089 bRetval = service_ok(iServiceIndex);
5090
5091 lp_add_auto_services(lp_auto_services());
5092
5093 if (add_ipc) {
5094 /* When 'restrict anonymous = 2' guest connections to ipc$
5095 are denied */
5096 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
5097 if ( lp_enable_asu_support() )
5098 lp_add_ipc("ADMIN$", False);
5099 }
5100
5101 set_server_role();
5102 set_default_server_announce_type();
5103 set_allowed_client_auth();
5104
5105 bLoaded = True;
5106
5107 /* Now we check bWINSsupport and set szWINSserver to 127.0.0.1 */
5108 /* if bWINSsupport is true and we are in the client */
5109 if (in_client && Globals.bWINSsupport) {
5110 lp_do_parameter(GLOBAL_SECTION_SNUM, "wins server", "127.0.0.1");
5111 }
5112
5113 init_iconv();
5114
5115 return (bRetval);
5116 }
5117
5118 /***************************************************************************
5119 Reset the max number of services.
5120 ***************************************************************************/
5121
5122 void lp_resetnumservices(void)
5123 {
5124 iNumServices = 0;
5125 }
5126
5127 /***************************************************************************
5128 Return the max number of services.
5129 ***************************************************************************/
5130
5131 int lp_numservices(void)
5132 {
5133 return (iNumServices);
5134 }
5135
5136 /***************************************************************************
5137 Display the contents of the services array in human-readable form.
5138 ***************************************************************************/
5139
5140 void lp_dump(FILE *f, BOOL show_defaults, int maxtoprint)
5141 {
5142 int iService;
5143
5144 if (show_defaults)
5145 defaults_saved = False;
5146
5147 dump_globals(f);
5148
5149 dump_a_service(&sDefault, f);
5150
5151 for (iService = 0; iService < maxtoprint; iService++) {
5152 fprintf(f,"\n");
5153 lp_dump_one(f, show_defaults, iService);
5154 }
5155 }
5156
5157 /***************************************************************************
5158 Display the contents of one service in human-readable form.
5159 ***************************************************************************/
5160
5161 void lp_dump_one(FILE * f, BOOL show_defaults, int snum)
5162 {
5163 if (VALID(snum)) {
5164 if (ServicePtrs[snum]->szService[0] == '\0')
5165 return;
5166 dump_a_service(ServicePtrs[snum], f);
5167 }
5168 }
5169
5170 /***************************************************************************
5171 Return the number of the service with the given name, or -1 if it doesn't
5172 exist. Note that this is a DIFFERENT ANIMAL from the internal function
5173 getservicebyname()! This works ONLY if all services have been loaded, and
5174 does not copy the found service.
5175 ***************************************************************************/
5176
5177 int lp_servicenumber(const char *pszServiceName)
5178 {
5179 int iService;
5180 fstring serviceName;
5181
5182 if (!pszServiceName) {
5183 return GLOBAL_SECTION_SNUM;
5184 }
5185
5186 for (iService = iNumServices - 1; iService >= 0; iService--) {
5187 if (VALID(iService) && ServicePtrs[iService]->szService) {
5188 /*
5189 * The substitution here is used to support %U is
5190 * service names
5191 */
5192 fstrcpy(serviceName, ServicePtrs[iService]->szService);
5193 standard_sub_basic(get_current_username(),
5194 current_user_info.domain,
5195 serviceName,sizeof(serviceName));
5196 if (strequal(serviceName, pszServiceName)) {
5197 break;
5198 }
5199 }
5200 }
5201
5202 if (iService >= 0 && ServicePtrs[iService]->usershare == USERSHARE_VALID) {
5203 time_t last_mod;
5204
5205 if (!usershare_exists(iService, &last_mod)) {
5206 /* Remove the share security tdb entry for it. */
5207 delete_share_security(snum2params_static(iService));
5208 /* Remove it from the array. */
5209 free_service_byindex(iService);
5210 /* Doesn't exist anymore. */
5211 return GLOBAL_SECTION_SNUM;
5212 }
5213
5214 /* Has it been modified ? If so delete and reload. */
5215 if (ServicePtrs[iService]->usershare_last_mod < last_mod) {
5216 /* Remove it from the array. */
5217 free_service_byindex(iService);
5218 /* and now reload it. */
5219 iService = load_usershare_service(pszServiceName);
5220 }
5221 }
5222
5223 if (iService < 0) {
5224 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
5225 return GLOBAL_SECTION_SNUM;
5226 }
5227
5228 return (iService);
5229 }
5230
5231 BOOL share_defined(const char *service_name)
5232 {
5233 return (lp_servicenumber(service_name) != -1);
5234 }
5235
5236 struct share_params *get_share_params(TALLOC_CTX *mem_ctx,
5237 const char *sharename)
5238 {
5239 struct share_params *result;
5240 char *sname;
5241 int snum;
5242
5243 if (!(sname = SMB_STRDUP(sharename))) {
5244 return NULL;
5245 }
5246
5247 snum = find_service(sname);
5248 SAFE_FREE(sname);
5249
5250 if (snum < 0) {
5251 return NULL;
5252 }
5253
5254 if (!(result = TALLOC_P(mem_ctx, struct share_params))) {
5255 DEBUG(0, ("talloc failed\n"));
5256 return NULL;
5257 }
5258
5259 result->service = snum;
5260 return result;
5261 }
5262
5263 struct share_iterator *share_list_all(TALLOC_CTX *mem_ctx)
5264 {
5265 struct share_iterator *result;
5266
5267 if (!(result = TALLOC_P(mem_ctx, struct share_iterator))) {
5268 DEBUG(0, ("talloc failed\n"));
5269 return NULL;
5270 }
5271
5272 result->next_id = 0;
5273 return result;
5274 }
5275
5276 struct share_params *next_share(struct share_iterator *list)
5277 {
5278 struct share_params *result;
5279
5280 while (!lp_snum_ok(list->next_id) &&
5281 (list->next_id < lp_numservices())) {
5282 list->next_id += 1;
5283 }
5284
5285 if (list->next_id >= lp_numservices()) {
5286 return NULL;
5287 }
5288
5289 if (!(result = TALLOC_P(list, struct share_params))) {
5290 DEBUG(0, ("talloc failed\n"));
5291 return NULL;
5292 }
5293
5294 result->service = list->next_id;
5295 list->next_id += 1;
5296 return result;
5297 }
5298
5299 struct share_params *next_printer(struct share_iterator *list)
5300 {
5301 struct share_params *result;
5302
5303 while ((result = next_share(list)) != NULL) {
5304 if (lp_print_ok(result->service)) {
5305 break;
5306 }
5307 }
5308 return result;
5309 }
5310
5311 /*
5312 * This is a hack for a transition period until we transformed all code from
5313 * service numbers to struct share_params.
5314 */
5315
5316 struct share_params *snum2params_static(int snum)
5317 {
5318 static struct share_params result;
5319 result.service = snum;
5320 return &result;
5321 }
5322
5323 /*******************************************************************
5324 A useful volume label function.
5325 ********************************************************************/
5326
5327 const char *volume_label(int snum)
5328 {
5329 char *ret;
5330 const char *label = lp_volume(snum);
5331 if (!*label) {
5332 label = lp_servicename(snum);
5333 }
5334
5335 /* This returns a 33 byte guarenteed null terminated string. */
5336 ret = talloc_strndup(main_loop_talloc_get(), label, 32);
5337 if (!ret) {
5338 return "";
5339 }
5340 return ret;
5341 }
5342
5343 /*******************************************************************
5344 Set the server type we will announce as via nmbd.
5345 ********************************************************************/
5346
5347 static void set_default_server_announce_type(void)
5348 {
5349 default_server_announce = 0;
5350 default_server_announce |= SV_TYPE_WORKSTATION;
5351 default_server_announce |= SV_TYPE_SERVER;
5352 default_server_announce |= SV_TYPE_SERVER_UNIX;
5353
5354 /* note that the flag should be set only if we have a
5355 printer service but nmbd doesn't actually load the
5356 services so we can't tell --jerry */
5357
5358 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
5359
5360 switch (lp_announce_as()) {
5361 case ANNOUNCE_AS_NT_SERVER:
5362 default_server_announce |= SV_TYPE_SERVER_NT;
5363 /* fall through... */
5364 case ANNOUNCE_AS_NT_WORKSTATION:
5365 default_server_announce |= SV_TYPE_NT;
5366 break;
5367 case ANNOUNCE_AS_WIN95:
5368 default_server_announce |= SV_TYPE_WIN95_PLUS;
5369 break;
5370 case ANNOUNCE_AS_WFW:
5371 default_server_announce |= SV_TYPE_WFW;
5372 break;
5373 default:
5374 break;
5375 }
5376
5377 switch (lp_server_role()) {
5378 case ROLE_DOMAIN_MEMBER:
5379 default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
5380 break;
5381 case ROLE_DOMAIN_PDC:
5382 default_server_announce |= SV_TYPE_DOMAIN_CTRL;
5383 break;
5384 case ROLE_DOMAIN_BDC:
5385 default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
5386 break;
5387 case ROLE_STANDALONE:
5388 default:
5389 break;
5390 }
5391 if (lp_time_server())
5392 default_server_announce |= SV_TYPE_TIME_SOURCE;
5393
5394 if (lp_host_msdfs())
5395 default_server_announce |= SV_TYPE_DFS_SERVER;
5396 }
5397
5398 /***********************************************************
5399 returns role of Samba server
5400 ************************************************************/
5401
5402 int lp_server_role(void)
5403 {
5404 return server_role;
5405 }
5406
5407 /***********************************************************
5408 If we are PDC then prefer us as DMB
5409 ************************************************************/
5410
5411 BOOL lp_domain_master(void)
5412 {
5413 if (Globals.bDomainMaster == Auto)
5414 return (lp_server_role() == ROLE_DOMAIN_PDC);
5415
5416 return Globals.bDomainMaster;
5417 }
5418
5419 /***********************************************************
5420 If we are DMB then prefer us as LMB
5421 ************************************************************/
5422
5423 BOOL lp_preferred_master(void)
5424 {
5425 if (Globals.bPreferredMaster == Auto)
5426 return (lp_local_master() && lp_domain_master());
5427
5428 return Globals.bPreferredMaster;
5429 }
5430
5431 /*******************************************************************
5432 Remove a service.
5433 ********************************************************************/
5434
5435 void lp_remove_service(int snum)
5436 {
5437 ServicePtrs[snum]->valid = False;
5438 invalid_services[num_invalid_services++] = snum;
5439 }
5440
5441 /*******************************************************************
5442 Copy a service.
5443 ********************************************************************/
5444
5445 void lp_copy_service(int snum, const char *new_name)
5446 {
5447 do_section(new_name);
5448 if (snum >= 0) {
5449 snum = lp_servicenumber(new_name);
5450 if (snum >= 0)
5451 lp_do_parameter(snum, "copy", lp_servicename(snum));
5452 }
5453 }
5454
5455
5456 /*******************************************************************
5457 Get the default server type we will announce as via nmbd.
5458 ********************************************************************/
5459
5460 int lp_default_server_announce(void)
5461 {
5462 return default_server_announce;
5463 }
5464
5465 /*******************************************************************
5466 Split the announce version into major and minor numbers.
5467 ********************************************************************/
5468
5469 int lp_major_announce_version(void)
5470 {
5471 static BOOL got_major = False;
5472 static int major_version = DEFAULT_MAJOR_VERSION;
5473 char *vers;
5474 char *p;
5475
5476 if (got_major)
5477 return major_version;
5478
5479 got_major = True;
5480 if ((vers = lp_announce_version()) == NULL)
5481 return major_version;
5482
5483 if ((p = strchr_m(vers, '.')) == 0)
5484 return major_version;
5485
5486 *p = '\0';
5487 major_version = atoi(vers);
5488 return major_version;
5489 }
5490
5491 int lp_minor_announce_version(void)
5492 {
5493 static BOOL got_minor = False;
5494 static int minor_version = DEFAULT_MINOR_VERSION;
5495 char *vers;
5496 char *p;
5497
5498 if (got_minor)
5499 return minor_version;
5500
5501 got_minor = True;
5502 if ((vers = lp_announce_version()) == NULL)
5503 return minor_version;
5504
5505 if ((p = strchr_m(vers, '.')) == 0)
5506 return minor_version;
5507
5508 p++;
5509 minor_version = atoi(p);
5510 return minor_version;
5511 }
5512
5513 /***********************************************************
5514 Set the global name resolution order (used in smbclient).
5515 ************************************************************/
5516
5517 void lp_set_name_resolve_order(const char *new_order)
5518 {
5519 string_set(&Globals.szNameResolveOrder, new_order);
5520 }
5521
5522 const char *lp_printername(int snum)
5523 {
5524 const char *ret = _lp_printername(snum);
5525 if (ret == NULL || (ret != NULL && *ret == '\0'))
5526 ret = lp_const_servicename(snum);
5527
5528 return ret;
5529 }
5530
5531
5532 /***********************************************************
5533 Allow daemons such as winbindd to fix their logfile name.
5534 ************************************************************/
5535
5536 void lp_set_logfile(const char *name)
5537 {
5538 string_set(&Globals.szLogFile, name);
5539 pstrcpy(debugf, name);
5540 }
5541
5542 /*******************************************************************
5543 Return the max print jobs per queue.
5544 ********************************************************************/
5545
5546 int lp_maxprintjobs(int snum)
5547 {
5548 int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
5549 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
5550 maxjobs = PRINT_MAX_JOBID - 1;
5551
5552 return maxjobs;
5553 }
5554
5555 const char *lp_printcapname(void)
5556 {
5557 if ((Globals.szPrintcapname != NULL) &&
5558 (Globals.szPrintcapname[0] != '\0'))
5559 return Globals.szPrintcapname;
5560
5561 if (sDefault.iPrinting == PRINT_CUPS) {
5562 #ifdef HAVE_CUPS
5563 return "cups";
5564 #else
5565 return "lpstat";
5566 #endif
5567 }
5568
5569 if (sDefault.iPrinting == PRINT_BSD)
5570 return "/etc/printcap";
5571
5572 return PRINTCAP_NAME;
5573 }
5574
5575 /*******************************************************************
5576 Ensure we don't use sendfile if server smb signing is active.
5577 ********************************************************************/
5578
5579 static uint32 spoolss_state;
5580
5581 BOOL lp_disable_spoolss( void )
5582 {
5583 if ( spoolss_state == SVCCTL_STATE_UNKNOWN )
5584 spoolss_state = _lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
5585
5586 return spoolss_state == SVCCTL_STOPPED ? True : False;
5587 }
5588
5589 void lp_set_spoolss_state( uint32 state )
5590 {
5591 SMB_ASSERT( (state == SVCCTL_STOPPED) || (state == SVCCTL_RUNNING) );
5592
5593 spoolss_state = state;
5594 }
5595
5596 uint32 lp_get_spoolss_state( void )
5597 {
5598 return lp_disable_spoolss() ? SVCCTL_STOPPED : SVCCTL_RUNNING;
5599 }
5600
5601 /*******************************************************************
5602 Ensure we don't use sendfile if server smb signing is active.
5603 ********************************************************************/
5604
5605 BOOL lp_use_sendfile(int snum)
5606 {
5607 /* Using sendfile blows the brains out of any DOS or Win9x TCP stack... JRA. */
5608 if (Protocol < PROTOCOL_NT1) {
5609 return False;
5610 }
5611 return (_lp_use_sendfile(snum) && (get_remote_arch() != RA_WIN95) && !srv_is_signing_active());
5612 }
5613
5614 /*******************************************************************
5615 Turn off sendfile if we find the underlying OS doesn't support it.
5616 ********************************************************************/
5617
5618 void set_use_sendfile(int snum, BOOL val)
5619 {
5620 if (LP_SNUM_OK(snum))
5621 ServicePtrs[snum]->bUseSendfile = val;
5622 else
5623 sDefault.bUseSendfile = val;
5624 }
5625
5626 /*******************************************************************
5627 Turn off storing DOS attributes if this share doesn't support it.
5628 ********************************************************************/
5629
5630 void set_store_dos_attributes(int snum, BOOL val)
5631 {
5632 if (!LP_SNUM_OK(snum))
5633 return;
5634 ServicePtrs[(snum)]->bStoreDosAttributes = val;
5635 }
5636
5637 void lp_set_mangling_method(const char *new_method)
5638 {
5639 string_set(&Globals.szManglingMethod, new_method);
5640 }
5641
5642 /*******************************************************************
5643 Global state for POSIX pathname processing.
5644 ********************************************************************/
5645
5646 static BOOL posix_pathnames;
5647
5648 BOOL lp_posix_pathnames(void)
5649 {
5650 return posix_pathnames;
5651 }
5652
5653 /*******************************************************************
5654 Change everything needed to ensure POSIX pathname processing (currently
5655 not much).
5656 ********************************************************************/
5657
5658 void lp_set_posix_pathnames(void)
5659 {
5660 posix_pathnames = True;
5661 }
5662
5663 /*******************************************************************
5664 Global state for POSIX lock processing - CIFS unix extensions.
5665 ********************************************************************/
5666
5667 BOOL posix_default_lock_was_set;
5668 static enum brl_flavour posix_cifsx_locktype; /* By default 0 == WINDOWS_LOCK */
5669
5670 enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp)
5671 {
5672 if (posix_default_lock_was_set) {
5673 return posix_cifsx_locktype;
5674 } else {
5675 return fsp->posix_open ? POSIX_LOCK : WINDOWS_LOCK;
5676 }
5677 }
5678
5679 /*******************************************************************
5680 ********************************************************************/
5681
5682 void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val)
5683 {
5684 posix_default_lock_was_set = True;
5685 posix_cifsx_locktype = val;
5686 }
Samba GIT mirror