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