?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
This is a merge of the NETLOGON schannel server code from Samba
[Samba/wip.git] / source3 / param / loadparm.c
blobdc922906cb35999f86993be0b74adf6ef4860652
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) Anthony Liguori 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 userdom_struct current_user_info;
60 extern pstring user_socket_options;
61
62 #ifndef GLOBAL_NAME
63 #define GLOBAL_NAME "global"
64 #endif
65
66 #ifndef PRINTERS_NAME
67 #define PRINTERS_NAME "printers"
68 #endif
69
70 #ifndef HOMES_NAME
71 #define HOMES_NAME "homes"
72 #endif
73
74 /* some helpful bits */
75 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && ServicePtrs[(i)]->valid)
76 #define VALID(i) ServicePtrs[i]->valid
77
78 int keepalive = DEFAULT_KEEPALIVE;
79 BOOL use_getwd_cache = True;
80
81 extern int extra_time_offset;
82
83 static BOOL defaults_saved = False;
84
85 typedef struct _param_opt_struct param_opt_struct;
86 struct _param_opt_struct {
87 param_opt_struct *prev, *next;
88 char *key;
89 char *value;
90 };
91
92 /*
93 * This structure describes global (ie., server-wide) parameters.
94 */
95 typedef struct
96 {
97 char *smb_ports;
98 char *dos_charset;
99 char *unix_charset;
100 char *display_charset;
101 char *szPrintcapname;
102 char *szEnumPortsCommand;
103 char *szAddPrinterCommand;
104 char *szDeletePrinterCommand;
105 char *szOs2DriverMap;
106 char *szLockDir;
107 char *szPidDir;
108 char *szRootdir;
109 char *szDefaultService;
110 char *szDfree;
111 char *szMsgCommand;
112 char *szHostsEquiv;
113 char *szServerString;
114 char *szAutoServices;
115 char *szPasswdProgram;
116 char *szPasswdChat;
117 char *szLogFile;
118 char *szConfigFile;
119 char *szSMBPasswdFile;
120 char *szPrivateDir;
121 char **szPassdbBackend;
122 char **szSamBackend;
123 char **szPreloadModules;
124 char *szPasswordServer;
125 char *szSocketOptions;
126 char *szRealm;
127 char *szADSserver;
128 char *szUsernameMap;
129 char *szLogonScript;
130 char *szLogonPath;
131 char *szLogonDrive;
132 char *szLogonHome;
133 char **szWINSservers;
134 char **szInterfaces;
135 char *szRemoteAnnounce;
136 char *szRemoteBrowseSync;
137 char *szSocketAddress;
138 char *szNISHomeMapName;
139 char *szAnnounceVersion; /* This is initialised in init_globals */
140 char *szWorkgroup;
141 char *szNetbiosName;
142 char **szNetbiosAliases;
143 char *szNetbiosScope;
144 char *szDomainOtherSIDs;
145 char *szNameResolveOrder;
146 char *szPanicAction;
147 char *szAddUserScript;
148 char *szDelUserScript;
149 char *szAddGroupScript;
150 char *szDelGroupScript;
151 char *szAddUserToGroupScript;
152 char *szDelUserFromGroupScript;
153 char *szSetPrimaryGroupScript;
154 char *szAddMachineScript;
155 char *szShutdownScript;
156 char *szAbortShutdownScript;
157 char *szWINSHook;
158 char *szWINSPartners;
159 #ifdef WITH_UTMP
160 char *szUtmpDir;
161 char *szWtmpDir;
162 BOOL bUtmp;
163 #endif
164 char *szSourceEnv;
165 char *szIdmapUID;
166 char *szIdmapGID;
167 char *szNonUnixAccountRange;
168 int AlgorithmicRidBase;
169 char *szTemplateHomedir;
170 char *szTemplateShell;
171 char *szWinbindSeparator;
172 BOOL bWinbindEnumUsers;
173 BOOL bWinbindEnumGroups;
174 BOOL bWinbindUseDefaultDomain;
175 char *szWinbindBackend;
176 char *szIdmapBackend;
177 char *szAddShareCommand;
178 char *szChangeShareCommand;
179 char *szDeleteShareCommand;
180 char *szGuestaccount;
181 char *szManglingMethod;
182 int mangle_prefix;
183 int max_log_size;
184 char *szLogLevel;
185 int mangled_stack;
186 int max_xmit;
187 int max_mux;
188 int max_open_files;
189 int pwordlevel;
190 int unamelevel;
191 int deadtime;
192 int maxprotocol;
193 int minprotocol;
194 int security;
195 char **AuthMethods;
196 BOOL paranoid_server_security;
197 int maxdisksize;
198 int lpqcachetime;
199 int iMaxSmbdProcesses;
200 BOOL bDisableSpoolss;
201 int iTotalPrintJobs;
202 int syslog;
203 int os_level;
204 int enhanced_browsing;
205 int max_ttl;
206 int max_wins_ttl;
207 int min_wins_ttl;
208 int ReadSize;
209 int lm_announce;
210 int lm_interval;
211 int announce_as; /* This is initialised in init_globals */
212 int machine_password_timeout;
213 int change_notify_timeout;
214 int stat_cache_size;
215 int map_to_guest;
216 int min_passwd_length;
217 int oplock_break_wait_time;
218 int winbind_cache_time;
219 int iLockSpinCount;
220 int iLockSpinTime;
221 char *szLdapMachineSuffix;
222 char *szLdapUserSuffix;
223 #ifdef WITH_LDAP_SAMCONFIG
224 int ldap_port;
225 char *szLdapServer;
226 #endif
227 int ldap_ssl;
228 char *szLdapSuffix;
229 char *szLdapFilter;
230 char *szLdapAdminDn;
231 BOOL ldap_trust_ids;
232 char *szAclCompat;
233 int ldap_passwd_sync;
234 BOOL ldap_delete_dn;
235 BOOL bMsAddPrinterWizard;
236 BOOL bDNSproxy;
237 BOOL bWINSsupport;
238 BOOL bWINSproxy;
239 BOOL bLocalMaster;
240 BOOL bPreferredMaster;
241 BOOL bDomainMaster;
242 BOOL bDomainLogons;
243 BOOL bEncryptPasswords;
244 BOOL bUpdateEncrypt;
245 int serverSchannel;
246 BOOL bStripDot;
247 BOOL bNullPasswords;
248 BOOL bObeyPamRestrictions;
249 BOOL bLoadPrinters;
250 BOOL bLargeReadwrite;
251 BOOL bReadRaw;
252 BOOL bWriteRaw;
253 BOOL bReadPrediction;
254 BOOL bReadbmpx;
255 BOOL bSyslogOnly;
256 BOOL bBrowseList;
257 BOOL bNISHomeMap;
258 BOOL bTimeServer;
259 BOOL bBindInterfacesOnly;
260 BOOL bPamPasswordChange;
261 BOOL bUnixPasswdSync;
262 BOOL bPasswdChatDebug;
263 BOOL bTimestampLogs;
264 BOOL bNTSmbSupport;
265 BOOL bNTPipeSupport;
266 BOOL bNTStatusSupport;
267 BOOL bStatCache;
268 BOOL bKernelOplocks;
269 BOOL bAllowTrustedDomains;
270 BOOL bLanmanAuth;
271 BOOL bNTLMAuth;
272 BOOL bUseSpnego;
273 BOOL bClientLanManAuth;
274 BOOL bClientNTLMv2Auth;
275 BOOL bClientUseSpnego;
276 BOOL bDebugHiresTimestamp;
277 BOOL bDebugPid;
278 BOOL bDebugUid;
279 BOOL bHostMSDfs;
280 BOOL bHideLocalUsers;
281 BOOL bUnicode;
282 BOOL bUseMmap;
283 BOOL bHostnameLookups;
284 BOOL bUnixExtensions;
285 BOOL bDisableNetbios;
286 BOOL bKernelChangeNotify;
287 int restrict_anonymous;
288 int name_cache_timeout;
289 BOOL client_signing;
290 param_opt_struct *param_opt;
291 }
292 global;
293
294 static global Globals;
295
296 /*
297 * This structure describes a single service.
298 */
299 typedef struct
300 {
301 BOOL valid;
302 BOOL autoloaded;
303 char *szService;
304 char *szPath;
305 char *szUsername;
306 char **szInvalidUsers;
307 char **szValidUsers;
308 char **szAdminUsers;
309 char *szCopy;
310 char *szInclude;
311 char *szPreExec;
312 char *szPostExec;
313 char *szRootPreExec;
314 char *szRootPostExec;
315 char *szPrintcommand;
316 char *szLpqcommand;
317 char *szLprmcommand;
318 char *szLppausecommand;
319 char *szLpresumecommand;
320 char *szQueuepausecommand;
321 char *szQueueresumecommand;
322 char *szPrintername;
323 char *szDontdescend;
324 char **szHostsallow;
325 char **szHostsdeny;
326 char *szMagicScript;
327 char *szMagicOutput;
328 char *szMangledMap;
329 char *szVetoFiles;
330 char *szHideFiles;
331 char *szVetoOplockFiles;
332 char *comment;
333 char *force_user;
334 char *force_group;
335 char **readlist;
336 char **writelist;
337 char **printer_admin;
338 char *volume;
339 char *fstype;
340 char *szVfsObjectFile;
341 char *szVfsOptions;
342 char *szVfsPath;
343 char *szMSDfsProxy;
344 int iMinPrintSpace;
345 int iMaxPrintJobs;
346 int iMaxReportedPrintJobs;
347 int iWriteCacheSize;
348 int iCreate_mask;
349 int iCreate_force_mode;
350 int iSecurity_mask;
351 int iSecurity_force_mode;
352 int iDir_mask;
353 int iDir_force_mode;
354 int iDir_Security_mask;
355 int iDir_Security_force_mode;
356 int iMaxConnections;
357 int iDefaultCase;
358 int iPrinting;
359 int iOplockContentionLimit;
360 int iCSCPolicy;
361 int iBlock_size;
362 BOOL bPreexecClose;
363 BOOL bRootpreexecClose;
364 BOOL bCaseSensitive;
365 BOOL bCasePreserve;
366 BOOL bShortCasePreserve;
367 BOOL bCaseMangle;
368 BOOL bHideDotFiles;
369 BOOL bHideSpecialFiles;
370 BOOL bHideUnReadable;
371 BOOL bHideUnWriteableFiles;
372 BOOL bBrowseable;
373 BOOL bAvailable;
374 BOOL bRead_only;
375 BOOL bNo_set_dir;
376 BOOL bGuest_only;
377 BOOL bGuest_ok;
378 BOOL bPrint_ok;
379 BOOL bMap_system;
380 BOOL bMap_hidden;
381 BOOL bMap_archive;
382 BOOL bLocking;
383 BOOL bStrictLocking;
384 BOOL bPosixLocking;
385 BOOL bShareModes;
386 BOOL bOpLocks;
387 BOOL bLevel2OpLocks;
388 BOOL bOnlyUser;
389 BOOL bMangledNames;
390 BOOL bWidelinks;
391 BOOL bSymlinks;
392 BOOL bSyncAlways;
393 BOOL bStrictAllocate;
394 BOOL bStrictSync;
395 char magic_char;
396 BOOL *copymap;
397 BOOL bDeleteReadonly;
398 BOOL bFakeOplocks;
399 BOOL bDeleteVetoFiles;
400 BOOL bDosFilemode;
401 BOOL bDosFiletimes;
402 BOOL bDosFiletimeResolution;
403 BOOL bFakeDirCreateTimes;
404 BOOL bBlockingLocks;
405 BOOL bInheritPerms;
406 BOOL bInheritACLS;
407 BOOL bMSDfsRoot;
408 BOOL bUseClientDriver;
409 BOOL bDefaultDevmode;
410 BOOL bNTAclSupport;
411 BOOL bUseSendfile;
412 BOOL bProfileAcls;
413 param_opt_struct *param_opt;
414
415 char dummy[3]; /* for alignment */
416 }
417 service;
418
419
420 /* This is a default service used to prime a services structure */
421 static service sDefault = {
422 True, /* valid */
423 False, /* not autoloaded */
424 NULL, /* szService */
425 NULL, /* szPath */
426 NULL, /* szUsername */
427 NULL, /* szInvalidUsers */
428 NULL, /* szValidUsers */
429 NULL, /* szAdminUsers */
430 NULL, /* szCopy */
431 NULL, /* szInclude */
432 NULL, /* szPreExec */
433 NULL, /* szPostExec */
434 NULL, /* szRootPreExec */
435 NULL, /* szRootPostExec */
436 NULL, /* szPrintcommand */
437 NULL, /* szLpqcommand */
438 NULL, /* szLprmcommand */
439 NULL, /* szLppausecommand */
440 NULL, /* szLpresumecommand */
441 NULL, /* szQueuepausecommand */
442 NULL, /* szQueueresumecommand */
443 NULL, /* szPrintername */
444 NULL, /* szDontdescend */
445 NULL, /* szHostsallow */
446 NULL, /* szHostsdeny */
447 NULL, /* szMagicScript */
448 NULL, /* szMagicOutput */
449 NULL, /* szMangledMap */
450 NULL, /* szVetoFiles */
451 NULL, /* szHideFiles */
452 NULL, /* szVetoOplockFiles */
453 NULL, /* comment */
454 NULL, /* force user */
455 NULL, /* force group */
456 NULL, /* readlist */
457 NULL, /* writelist */
458 NULL, /* printer admin */
459 NULL, /* volume */
460 NULL, /* fstype */
461 NULL, /* vfs object */
462 NULL, /* vfs options */
463 NULL, /* vfs path */
464 NULL, /* szMSDfsProxy */
465 0, /* iMinPrintSpace */
466 1000, /* iMaxPrintJobs */
467 0, /* iMaxReportedPrintJobs */
468 0, /* iWriteCacheSize */
469 0744, /* iCreate_mask */
470 0000, /* iCreate_force_mode */
471 0777, /* iSecurity_mask */
472 0, /* iSecurity_force_mode */
473 0755, /* iDir_mask */
474 0000, /* iDir_force_mode */
475 0777, /* iDir_Security_mask */
476 0, /* iDir_Security_force_mode */
477 0, /* iMaxConnections */
478 CASE_LOWER, /* iDefaultCase */
479 DEFAULT_PRINTING, /* iPrinting */
480 2, /* iOplockContentionLimit */
481 0, /* iCSCPolicy */
482 1024, /* iBlock_size */
483 False, /* bPreexecClose */
484 False, /* bRootpreexecClose */
485 False, /* case sensitive */
486 True, /* case preserve */
487 True, /* short case preserve */
488 False, /* case mangle */
489 True, /* bHideDotFiles */
490 False, /* bHideSpecialFiles */
491 False, /* bHideUnReadable */
492 False, /* bHideUnWriteableFiles */
493 True, /* bBrowseable */
494 True, /* bAvailable */
495 True, /* bRead_only */
496 True, /* bNo_set_dir */
497 False, /* bGuest_only */
498 False, /* bGuest_ok */
499 False, /* bPrint_ok */
500 False, /* bMap_system */
501 False, /* bMap_hidden */
502 True, /* bMap_archive */
503 True, /* bLocking */
504 True, /* bStrictLocking */
505 True, /* bPosixLocking */
506 True, /* bShareModes */
507 True, /* bOpLocks */
508 True, /* bLevel2OpLocks */
509 False, /* bOnlyUser */
510 True, /* bMangledNames */
511 True, /* bWidelinks */
512 True, /* bSymlinks */
513 False, /* bSyncAlways */
514 False, /* bStrictAllocate */
515 False, /* bStrictSync */
516 '~', /* magic char */
517 NULL, /* copymap */
518 False, /* bDeleteReadonly */
519 False, /* bFakeOplocks */
520 False, /* bDeleteVetoFiles */
521 False, /* bDosFilemode */
522 False, /* bDosFiletimes */
523 False, /* bDosFiletimeResolution */
524 False, /* bFakeDirCreateTimes */
525 True, /* bBlockingLocks */
526 False, /* bInheritPerms */
527 False, /* bInheritACLS */
528 False, /* bMSDfsRoot */
529 False, /* bUseClientDriver */
530 False, /* bDefaultDevmode */
531 True, /* bNTAclSupport */
532 False, /* bUseSendfile */
533 False, /* bProfileAcls */
534
535 NULL, /* Parametric options */
536
537 "" /* dummy */
538 };
539
540 /* local variables */
541 static service **ServicePtrs = NULL;
542 static int iNumServices = 0;
543 static int iServiceIndex = 0;
544 static BOOL bInGlobalSection = True;
545 static BOOL bGlobalOnly = False;
546 static int server_role;
547 static int default_server_announce;
548
549 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
550
551 /* prototypes for the special type handlers */
552 static BOOL handle_include(const char *pszParmValue, char **ptr);
553 static BOOL handle_copy(const char *pszParmValue, char **ptr);
554 static BOOL handle_source_env(const char *pszParmValue, char **ptr);
555 static BOOL handle_netbios_name(const char *pszParmValue, char **ptr);
556 static BOOL handle_idmap_uid(const char *pszParmValue, char **ptr);
557 static BOOL handle_idmap_gid(const char *pszParmValue, char **ptr);
558 static BOOL handle_non_unix_account_range(const char *pszParmValue, char **ptr);
559 static BOOL handle_debug_list( const char *pszParmValue, char **ptr );
560 static BOOL handle_workgroup( const char *pszParmValue, char **ptr );
561 static BOOL handle_netbios_aliases( const char *pszParmValue, char **ptr );
562 static BOOL handle_netbios_scope( const char *pszParmValue, char **ptr );
563
564 static BOOL handle_ldap_machine_suffix ( const char *pszParmValue, char **ptr );
565 static BOOL handle_ldap_user_suffix ( const char *pszParmValue, char **ptr );
566 static BOOL handle_ldap_suffix ( const char *pszParmValue, char **ptr );
567
568 static BOOL handle_acl_compatibility(const char *pszParmValue, char **ptr);
569
570 static void set_server_role(void);
571 static void set_default_server_announce_type(void);
572
573 static const struct enum_list enum_protocol[] = {
574 {PROTOCOL_NT1, "NT1"},
575 {PROTOCOL_LANMAN2, "LANMAN2"},
576 {PROTOCOL_LANMAN1, "LANMAN1"},
577 {PROTOCOL_CORE, "CORE"},
578 {PROTOCOL_COREPLUS, "COREPLUS"},
579 {PROTOCOL_COREPLUS, "CORE+"},
580 {-1, NULL}
581 };
582
583 static const struct enum_list enum_security[] = {
584 {SEC_SHARE, "SHARE"},
585 {SEC_USER, "USER"},
586 {SEC_SERVER, "SERVER"},
587 {SEC_DOMAIN, "DOMAIN"},
588 #ifdef HAVE_ADS
589 {SEC_ADS, "ADS"},
590 #endif
591 {-1, NULL}
592 };
593
594 static const struct enum_list enum_printing[] = {
595 {PRINT_SYSV, "sysv"},
596 {PRINT_AIX, "aix"},
597 {PRINT_HPUX, "hpux"},
598 {PRINT_BSD, "bsd"},
599 {PRINT_QNX, "qnx"},
600 {PRINT_PLP, "plp"},
601 {PRINT_LPRNG, "lprng"},
602 {PRINT_SOFTQ, "softq"},
603 {PRINT_CUPS, "cups"},
604 {PRINT_LPRNT, "nt"},
605 {PRINT_LPROS2, "os2"},
606 #ifdef DEVELOPER
607 {PRINT_TEST, "test"},
608 {PRINT_VLP, "vlp"},
609 #endif /* DEVELOPER */
610 {-1, NULL}
611 };
612
613 static const struct enum_list enum_ldap_ssl[] = {
614 #ifdef WITH_LDAP_SAMCONFIG
615 {LDAP_SSL_ON, "Yes"},
616 {LDAP_SSL_ON, "yes"},
617 {LDAP_SSL_ON, "on"},
618 {LDAP_SSL_ON, "On"},
619 #endif
620 {LDAP_SSL_OFF, "no"},
621 {LDAP_SSL_OFF, "No"},
622 {LDAP_SSL_OFF, "off"},
623 {LDAP_SSL_OFF, "Off"},
624 {LDAP_SSL_START_TLS, "start tls"},
625 {LDAP_SSL_START_TLS, "Start_tls"},
626 {-1, NULL}
627 };
628
629 static const struct enum_list enum_ldap_passwd_sync[] = {
630 {LDAP_PASSWD_SYNC_ON, "Yes"},
631 {LDAP_PASSWD_SYNC_ON, "yes"},
632 {LDAP_PASSWD_SYNC_ON, "on"},
633 {LDAP_PASSWD_SYNC_ON, "On"},
634 {LDAP_PASSWD_SYNC_OFF, "no"},
635 {LDAP_PASSWD_SYNC_OFF, "No"},
636 {LDAP_PASSWD_SYNC_OFF, "off"},
637 {LDAP_PASSWD_SYNC_OFF, "Off"},
638 #ifdef LDAP_EXOP_X_MODIFY_PASSWD
639 {LDAP_PASSWD_SYNC_ONLY, "Only"},
640 {LDAP_PASSWD_SYNC_ONLY, "only"},
641 #endif /* LDAP_EXOP_X_MODIFY_PASSWD */
642 {-1, NULL}
643 };
644
645 /* Types of machine we can announce as. */
646 #define ANNOUNCE_AS_NT_SERVER 1
647 #define ANNOUNCE_AS_WIN95 2
648 #define ANNOUNCE_AS_WFW 3
649 #define ANNOUNCE_AS_NT_WORKSTATION 4
650
651 static const struct enum_list enum_announce_as[] = {
652 {ANNOUNCE_AS_NT_SERVER, "NT"},
653 {ANNOUNCE_AS_NT_SERVER, "NT Server"},
654 {ANNOUNCE_AS_NT_WORKSTATION, "NT Workstation"},
655 {ANNOUNCE_AS_WIN95, "win95"},
656 {ANNOUNCE_AS_WFW, "WfW"},
657 {-1, NULL}
658 };
659
660 static const struct enum_list enum_case[] = {
661 {CASE_LOWER, "lower"},
662 {CASE_UPPER, "upper"},
663 {-1, NULL}
664 };
665
666 static const struct enum_list enum_bool_auto[] = {
667 {False, "No"},
668 {False, "False"},
669 {False, "0"},
670 {True, "Yes"},
671 {True, "True"},
672 {True, "1"},
673 {Auto, "Auto"},
674 {-1, NULL}
675 };
676
677 /* Client-side offline caching policy types */
678 #define CSC_POLICY_MANUAL 0
679 #define CSC_POLICY_DOCUMENTS 1
680 #define CSC_POLICY_PROGRAMS 2
681 #define CSC_POLICY_DISABLE 3
682
683 static const struct enum_list enum_csc_policy[] = {
684 {CSC_POLICY_MANUAL, "manual"},
685 {CSC_POLICY_DOCUMENTS, "documents"},
686 {CSC_POLICY_PROGRAMS, "programs"},
687 {CSC_POLICY_DISABLE, "disable"},
688 {-1, NULL}
689 };
690
691 /*
692 Do you want session setups at user level security with a invalid
693 password to be rejected or allowed in as guest? WinNT rejects them
694 but it can be a pain as it means "net view" needs to use a password
695
696 You have 3 choices in the setting of map_to_guest:
697
698 "Never" means session setups with an invalid password
699 are rejected. This is the default.
700
701 "Bad User" means session setups with an invalid password
702 are rejected, unless the username does not exist, in which case it
703 is treated as a guest login
704
705 "Bad Password" means session setups with an invalid password
706 are treated as a guest login
707
708 Note that map_to_guest only has an effect in user or server
709 level security.
710 */
711
712 static const struct enum_list enum_map_to_guest[] = {
713 {NEVER_MAP_TO_GUEST, "Never"},
714 {MAP_TO_GUEST_ON_BAD_USER, "Bad User"},
715 {MAP_TO_GUEST_ON_BAD_PASSWORD, "Bad Password"},
716 {-1, NULL}
717 };
718
719 /* Note: We do not initialise the defaults union - it is not allowed in ANSI C
720 *
721 * Note: We have a flag called FLAG_DEVELOPER but is not used at this time, it
722 * is implied in current control logic. This may change at some later time. A
723 * flag value of 0 means - show as development option only.
724 *
725 * The FLAG_HIDE is explicit. Paramters set this way do NOT appear in any edit
726 * screen in SWAT. This is used to exclude parameters as well as to squash all
727 * parameters that have been duplicated by pseudonyms.
728 */
729 static struct parm_struct parm_table[] = {
730 {"Base Options", P_SEP, P_SEPARATOR},
731
732 {"dos charset", P_STRING, P_GLOBAL, &Globals.dos_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
733 {"unix charset", P_STRING, P_GLOBAL, &Globals.unix_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
734 {"display charset", P_STRING, P_GLOBAL, &Globals.display_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
735 {"comment", P_STRING, P_LOCAL, &sDefault.comment, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
736 {"path", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
737 {"directory", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_HIDE},
738 {"workgroup", P_USTRING, P_GLOBAL, &Globals.szWorkgroup, handle_workgroup, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
739 {"realm", P_USTRING, P_GLOBAL, &Globals.szRealm, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
740 {"ADS server", P_STRING, P_GLOBAL, &Globals.szADSserver, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
741 {"netbios name", P_USTRING, P_GLOBAL, &Globals.szNetbiosName, handle_netbios_name, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
742 {"netbios aliases", P_LIST, P_GLOBAL, &Globals.szNetbiosAliases, handle_netbios_aliases, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
743 {"netbios scope", P_USTRING, P_GLOBAL, &Globals.szNetbiosScope, handle_netbios_scope, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
744 {"server string", P_STRING, P_GLOBAL, &Globals.szServerString, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
745 {"interfaces", P_LIST, P_GLOBAL, &Globals.szInterfaces, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
746 {"bind interfaces only", P_BOOL, P_GLOBAL, &Globals.bBindInterfacesOnly, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
747
748 {"Security Options", P_SEP, P_SEPARATOR},
749
750 {"security", P_ENUM, P_GLOBAL, &Globals.security, NULL, enum_security, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
751 {"auth methods", P_LIST, P_GLOBAL, &Globals.AuthMethods, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
752 {"encrypt passwords", P_BOOL, P_GLOBAL, &Globals.bEncryptPasswords, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
753 {"update encrypted", P_BOOL, P_GLOBAL, &Globals.bUpdateEncrypt, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
754 {"server schannel", P_ENUM, P_GLOBAL, &Globals.serverSchannel, NULL, enum_bool_auto, FLAG_BASIC},
755 {"allow trusted domains", P_BOOL, P_GLOBAL, &Globals.bAllowTrustedDomains, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
756 {"hosts equiv", P_STRING, P_GLOBAL, &Globals.szHostsEquiv, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
757 {"idmap backend", P_STRING, P_GLOBAL, &Globals.szIdmapBackend, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
758 {"min passwd length", P_INTEGER, P_GLOBAL, &Globals.min_passwd_length, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
759 {"min password length", P_INTEGER, P_GLOBAL, &Globals.min_passwd_length, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
760 {"map to guest", P_ENUM, P_GLOBAL, &Globals.map_to_guest, NULL, enum_map_to_guest, FLAG_ADVANCED | FLAG_DEVELOPER},
761 {"null passwords", P_BOOL, P_GLOBAL, &Globals.bNullPasswords, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
762 {"obey pam restrictions", P_BOOL, P_GLOBAL, &Globals.bObeyPamRestrictions, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
763 {"password server", P_STRING, P_GLOBAL, &Globals.szPasswordServer, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
764 {"smb passwd file", P_STRING, P_GLOBAL, &Globals.szSMBPasswdFile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
765 {"private dir", P_STRING, P_GLOBAL, &Globals.szPrivateDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
766 {"passdb backend", P_LIST, P_GLOBAL, &Globals.szPassdbBackend, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
767 {"sam backend", P_LIST, P_GLOBAL, &Globals.szSamBackend, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
768 {"non unix account range", P_STRING, P_GLOBAL, &Globals.szNonUnixAccountRange, handle_non_unix_account_range, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
769 {"algorithmic rid base", P_INTEGER, P_GLOBAL, &Globals.AlgorithmicRidBase, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
770 {"root directory", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
771 {"root dir", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
772 {"root", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_HIDE | FLAG_DEVELOPER},
773 {"guest account", P_STRING, P_GLOBAL, &Globals.szGuestaccount, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
774
775 {"pam password change", P_BOOL, P_GLOBAL, &Globals.bPamPasswordChange, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
776 {"passwd program", P_STRING, P_GLOBAL, &Globals.szPasswdProgram, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
777 {"passwd chat", P_STRING, P_GLOBAL, &Globals.szPasswdChat, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
778 {"passwd chat debug", P_BOOL, P_GLOBAL, &Globals.bPasswdChatDebug, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
779 {"username map", P_STRING, P_GLOBAL, &Globals.szUsernameMap, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER | FLAG_DEVELOPER},
780 {"password level", P_INTEGER, P_GLOBAL, &Globals.pwordlevel, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
781 {"username level", P_INTEGER, P_GLOBAL, &Globals.unamelevel, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
782 {"unix password sync", P_BOOL, P_GLOBAL, &Globals.bUnixPasswdSync, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
783 {"restrict anonymous", P_INTEGER, P_GLOBAL, &Globals.restrict_anonymous, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
784 {"lanman auth", P_BOOL, P_GLOBAL, &Globals.bLanmanAuth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
785 {"ntlm auth", P_BOOL, P_GLOBAL, &Globals.bNTLMAuth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
786 {"client NTLMv2 auth", P_BOOL, P_GLOBAL, &Globals.bClientNTLMv2Auth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
787 {"client lanman auth", P_BOOL, P_GLOBAL, &Globals.bClientLanManAuth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
788
789 {"username", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
790 {"user", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_HIDE},
791 {"users", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_HIDE},
792
793 {"invalid users", P_LIST, P_LOCAL, &sDefault.szInvalidUsers, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
794 {"valid users", P_LIST, P_LOCAL, &sDefault.szValidUsers, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
795 {"admin users", P_LIST, P_LOCAL, &sDefault.szAdminUsers, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
796 {"read list", P_LIST, P_LOCAL, &sDefault.readlist, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
797 {"write list", P_LIST, P_LOCAL, &sDefault.writelist, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
798 {"printer admin", P_LIST, P_LOCAL, &sDefault.printer_admin, NULL, NULL, FLAG_GLOBAL | FLAG_PRINT},
799 {"force user", P_STRING, P_LOCAL, &sDefault.force_user, NULL, NULL, FLAG_SHARE},
800 {"force group", P_STRING, P_LOCAL, &sDefault.force_group, NULL, NULL, FLAG_SHARE},
801 {"group", P_STRING, P_LOCAL, &sDefault.force_group, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
802
803 {"read only", P_BOOL, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE},
804 {"write ok", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
805 {"writeable", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
806 {"writable", P_BOOLREV, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_HIDE},
807
808 {"create mask", P_OCTAL, P_LOCAL, &sDefault.iCreate_mask, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
809 {"create mode", P_OCTAL, P_LOCAL, &sDefault.iCreate_mask, NULL, NULL, FLAG_GLOBAL},
810 {"force create mode", P_OCTAL, P_LOCAL, &sDefault.iCreate_force_mode, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
811 {"security mask", P_OCTAL, P_LOCAL, &sDefault.iSecurity_mask, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
812 {"force security mode", P_OCTAL, P_LOCAL, &sDefault.iSecurity_force_mode, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
813 {"directory mask", P_OCTAL, P_LOCAL, &sDefault.iDir_mask, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
814 {"directory mode", P_OCTAL, P_LOCAL, &sDefault.iDir_mask, NULL, NULL, FLAG_GLOBAL},
815 {"force directory mode", P_OCTAL, P_LOCAL, &sDefault.iDir_force_mode, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
816 {"directory security mask", P_OCTAL, P_LOCAL, &sDefault.iDir_Security_mask, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
817 {"force directory security mode", P_OCTAL, P_LOCAL, &sDefault.iDir_Security_force_mode, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
818 {"inherit permissions", P_BOOL, P_LOCAL, &sDefault.bInheritPerms, NULL, NULL, FLAG_SHARE},
819 {"inherit acls", P_BOOL, P_LOCAL, &sDefault.bInheritACLS, NULL, NULL, FLAG_SHARE},
820 {"guest only", P_BOOL, P_LOCAL, &sDefault.bGuest_only, NULL, NULL, FLAG_SHARE},
821 {"only guest", P_BOOL, P_LOCAL, &sDefault.bGuest_only, NULL, NULL, FLAG_HIDE},
822
823 {"guest ok", P_BOOL, P_LOCAL, &sDefault.bGuest_ok, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
824 {"public", P_BOOL, P_LOCAL, &sDefault.bGuest_ok, NULL, NULL, FLAG_HIDE},
825
826 {"only user", P_BOOL, P_LOCAL, &sDefault.bOnlyUser, NULL, NULL, FLAG_SHARE},
827 {"hosts allow", P_LIST, P_LOCAL, &sDefault.szHostsallow, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
828 {"allow hosts", P_LIST, P_LOCAL, &sDefault.szHostsallow, NULL, NULL, FLAG_HIDE},
829 {"hosts deny", P_LIST, P_LOCAL, &sDefault.szHostsdeny, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
830 {"deny hosts", P_LIST, P_LOCAL, &sDefault.szHostsdeny, NULL, NULL, FLAG_HIDE},
831 {"preload modules", P_LIST, P_GLOBAL, &Globals.szPreloadModules, NULL, NULL, FLAG_BASIC | FLAG_GLOBAL},
832
833 {"Logging Options", P_SEP, P_SEPARATOR},
834
835 {"log level", P_STRING, P_GLOBAL, &Globals.szLogLevel, handle_debug_list, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
836 {"debuglevel", P_STRING, P_GLOBAL, &Globals.szLogLevel, handle_debug_list, NULL, FLAG_HIDE},
837 {"syslog", P_INTEGER, P_GLOBAL, &Globals.syslog, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
838 {"syslog only", P_BOOL, P_GLOBAL, &Globals.bSyslogOnly, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
839 {"log file", P_STRING, P_GLOBAL, &Globals.szLogFile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
840
841 {"max log size", P_INTEGER, P_GLOBAL, &Globals.max_log_size, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
842 {"timestamp logs", P_BOOL, P_GLOBAL, &Globals.bTimestampLogs, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
843 {"debug timestamp", P_BOOL, P_GLOBAL, &Globals.bTimestampLogs, NULL, NULL, FLAG_DEVELOPER},
844 {"debug hires timestamp", P_BOOL, P_GLOBAL, &Globals.bDebugHiresTimestamp, NULL, NULL, FLAG_DEVELOPER},
845 {"debug pid", P_BOOL, P_GLOBAL, &Globals.bDebugPid, NULL, NULL, FLAG_DEVELOPER},
846 {"debug uid", P_BOOL, P_GLOBAL, &Globals.bDebugUid, NULL, NULL, FLAG_DEVELOPER},
847
848 {"Protocol Options", P_SEP, P_SEPARATOR},
849
850 {"smb ports", P_STRING, P_GLOBAL, &Globals.smb_ports, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
851 {"protocol", P_ENUM, P_GLOBAL, &Globals.maxprotocol, NULL, enum_protocol, FLAG_ADVANCED | FLAG_DEVELOPER},
852 {"large readwrite", P_BOOL, P_GLOBAL, &Globals.bLargeReadwrite, NULL, NULL, FLAG_DEVELOPER},
853 {"max protocol", P_ENUM, P_GLOBAL, &Globals.maxprotocol, NULL, enum_protocol, FLAG_DEVELOPER},
854 {"min protocol", P_ENUM, P_GLOBAL, &Globals.minprotocol, NULL, enum_protocol, FLAG_DEVELOPER},
855 {"unicode", P_BOOL, P_GLOBAL, &Globals.bUnicode, NULL, NULL, FLAG_DEVELOPER},
856 {"read bmpx", P_BOOL, P_GLOBAL, &Globals.bReadbmpx, NULL, NULL, FLAG_DEVELOPER},
857 {"read raw", P_BOOL, P_GLOBAL, &Globals.bReadRaw, NULL, NULL, FLAG_DEVELOPER},
858 {"write raw", P_BOOL, P_GLOBAL, &Globals.bWriteRaw, NULL, NULL, FLAG_DEVELOPER},
859 {"disable netbios", P_BOOL, P_GLOBAL, &Globals.bDisableNetbios, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
860
861 {"acl compatibility", P_STRING, P_GLOBAL, &Globals.szAclCompat, handle_acl_compatibility, NULL, FLAG_SHARE | FLAG_GLOBAL | FLAG_ADVANCED},
862 {"nt acl support", P_BOOL, P_LOCAL, &sDefault.bNTAclSupport, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE | FLAG_ADVANCED | FLAG_WIZARD},
863 {"nt pipe support", P_BOOL, P_GLOBAL, &Globals.bNTPipeSupport, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
864 {"nt status support", P_BOOL, P_GLOBAL, &Globals.bNTStatusSupport, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
865 {"profile acls", P_BOOL, P_LOCAL, &sDefault.bProfileAcls, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE | FLAG_ADVANCED | FLAG_WIZARD},
866
867 {"announce version", P_STRING, P_GLOBAL, &Globals.szAnnounceVersion, NULL, NULL, FLAG_DEVELOPER},
868 {"announce as", P_ENUM, P_GLOBAL, &Globals.announce_as, NULL, enum_announce_as, FLAG_DEVELOPER},
869 {"max mux", P_INTEGER, P_GLOBAL, &Globals.max_mux, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
870 {"max xmit", P_INTEGER, P_GLOBAL, &Globals.max_xmit, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
871
872 {"name resolve order", P_STRING, P_GLOBAL, &Globals.szNameResolveOrder, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
873 {"max ttl", P_INTEGER, P_GLOBAL, &Globals.max_ttl, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
874 {"max wins ttl", P_INTEGER, P_GLOBAL, &Globals.max_wins_ttl, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
875 {"min wins ttl", P_INTEGER, P_GLOBAL, &Globals.min_wins_ttl, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
876 {"time server", P_BOOL, P_GLOBAL, &Globals.bTimeServer, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
877 {"unix extensions", P_BOOL, P_GLOBAL, &Globals.bUnixExtensions, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
878 {"use spnego", P_BOOL, P_GLOBAL, &Globals.bUseSpnego, NULL, NULL, FLAG_DEVELOPER},
879 {"client signing", P_BOOL, P_GLOBAL, &Globals.client_signing, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
880 {"client use spnego", P_BOOL, P_GLOBAL, &Globals.bClientUseSpnego, NULL, NULL, FLAG_DEVELOPER},
881
882 {"Tuning Options", P_SEP, P_SEPARATOR},
883
884 {"block size", P_INTEGER, P_LOCAL, &sDefault.iBlock_size, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
885 {"change notify timeout", P_INTEGER, P_GLOBAL, &Globals.change_notify_timeout, NULL, NULL, FLAG_DEVELOPER},
886 {"deadtime", P_INTEGER, P_GLOBAL, &Globals.deadtime, NULL, NULL, FLAG_DEVELOPER},
887 {"getwd cache", P_BOOL, P_GLOBAL, &use_getwd_cache, NULL, NULL, FLAG_DEVELOPER},
888 {"keepalive", P_INTEGER, P_GLOBAL, &keepalive, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
889 {"kernel change notify", P_BOOL, P_GLOBAL, &Globals.bKernelChangeNotify, NULL, NULL, FLAG_DEVELOPER},
890
891 {"lpq cache time", P_INTEGER, P_GLOBAL, &Globals.lpqcachetime, NULL, NULL, FLAG_DEVELOPER},
892 {"max smbd processes", P_INTEGER, P_GLOBAL, &Globals.iMaxSmbdProcesses, NULL, NULL, FLAG_DEVELOPER},
893 {"max connections", P_INTEGER, P_LOCAL, &sDefault.iMaxConnections, NULL, NULL, FLAG_SHARE},
894 {"paranoid server security", P_BOOL, P_GLOBAL, &Globals.paranoid_server_security, NULL, NULL, FLAG_DEVELOPER},
895 {"max disk size", P_INTEGER, P_GLOBAL, &Globals.maxdisksize, NULL, NULL, FLAG_DEVELOPER},
896 {"max open files", P_INTEGER, P_GLOBAL, &Globals.max_open_files, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
897 {"min print space", P_INTEGER, P_LOCAL, &sDefault.iMinPrintSpace, NULL, NULL, FLAG_PRINT},
898 {"read size", P_INTEGER, P_GLOBAL, &Globals.ReadSize, NULL, NULL, FLAG_DEVELOPER},
899
900 {"socket options", P_GSTRING, P_GLOBAL, user_socket_options, NULL, NULL, FLAG_DEVELOPER},
901 {"stat cache size", P_INTEGER, P_GLOBAL, &Globals.stat_cache_size, NULL, NULL, FLAG_DEVELOPER},
902 {"strict allocate", P_BOOL, P_LOCAL, &sDefault.bStrictAllocate, NULL, NULL, FLAG_SHARE},
903 {"strict sync", P_BOOL, P_LOCAL, &sDefault.bStrictSync, NULL, NULL, FLAG_SHARE},
904 {"sync always", P_BOOL, P_LOCAL, &sDefault.bSyncAlways, NULL, NULL, FLAG_SHARE},
905 {"use mmap", P_BOOL, P_GLOBAL, &Globals.bUseMmap, NULL, NULL, FLAG_DEVELOPER},
906 {"use sendfile", P_BOOL, P_LOCAL, &sDefault.bUseSendfile, NULL, NULL, FLAG_SHARE},
907 {"hostname lookups", P_BOOL, P_GLOBAL, &Globals.bHostnameLookups, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
908 {"write cache size", P_INTEGER, P_LOCAL, &sDefault.iWriteCacheSize, NULL, NULL, FLAG_SHARE},
909
910 {"name cache timeout", P_INTEGER, P_GLOBAL, &Globals.name_cache_timeout, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
911
912 {"Printing Options", P_SEP, P_SEPARATOR},
913
914 {"total print jobs", P_INTEGER, P_GLOBAL, &Globals.iTotalPrintJobs, NULL, NULL, FLAG_PRINT},
915 {"max reported print jobs", P_INTEGER, P_LOCAL, &sDefault.iMaxReportedPrintJobs, NULL, NULL, FLAG_PRINT},
916 {"max print jobs", P_INTEGER, P_LOCAL, &sDefault.iMaxPrintJobs, NULL, NULL, FLAG_PRINT},
917 {"load printers", P_BOOL, P_GLOBAL, &Globals.bLoadPrinters, NULL, NULL, FLAG_PRINT},
918 {"printcap name", P_STRING, P_GLOBAL, &Globals.szPrintcapname, NULL, NULL, FLAG_PRINT | FLAG_DEVELOPER},
919 {"printcap", P_STRING, P_GLOBAL, &Globals.szPrintcapname, NULL, NULL, FLAG_HIDE},
920 {"printable", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_PRINT},
921 {"print ok", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_HIDE},
922 {"printing", P_ENUM, P_LOCAL, &sDefault.iPrinting, NULL, enum_printing, FLAG_PRINT | FLAG_GLOBAL},
923 {"print command", P_STRING, P_LOCAL, &sDefault.szPrintcommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
924 {"disable spoolss", P_BOOL, P_GLOBAL, &Globals.bDisableSpoolss, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
925 {"lpq command", P_STRING, P_LOCAL, &sDefault.szLpqcommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
926 {"lprm command", P_STRING, P_LOCAL, &sDefault.szLprmcommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
927 {"lppause command", P_STRING, P_LOCAL, &sDefault.szLppausecommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
928 {"lpresume command", P_STRING, P_LOCAL, &sDefault.szLpresumecommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
929 {"queuepause command", P_STRING, P_LOCAL, &sDefault.szQueuepausecommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
930 {"queueresume command", P_STRING, P_LOCAL, &sDefault.szQueueresumecommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
931
932 {"enumports command", P_STRING, P_GLOBAL, &Globals.szEnumPortsCommand, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
933 {"addprinter command", P_STRING, P_GLOBAL, &Globals.szAddPrinterCommand, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
934 {"deleteprinter command", P_STRING, P_GLOBAL, &Globals.szDeletePrinterCommand, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
935 {"show add printer wizard", P_BOOL, P_GLOBAL, &Globals.bMsAddPrinterWizard, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
936 {"os2 driver map", P_STRING, P_GLOBAL, &Globals.szOs2DriverMap, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
937
938 {"printer name", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_PRINT},
939 {"printer", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_HIDE},
940 {"use client driver", P_BOOL, P_LOCAL, &sDefault.bUseClientDriver, NULL, NULL, FLAG_PRINT},
941 {"default devmode", P_BOOL, P_LOCAL, &sDefault.bDefaultDevmode, NULL, NULL, FLAG_PRINT},
942
943 {"Filename Handling", P_SEP, P_SEPARATOR},
944 {"strip dot", P_BOOL, P_GLOBAL, &Globals.bStripDot, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
945 {"mangling method", P_STRING, P_GLOBAL, &Globals.szManglingMethod, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
946 {"mangle prefix", P_INTEGER, P_GLOBAL, &Globals.mangle_prefix, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
947
948 {"mangled stack", P_INTEGER, P_GLOBAL, &Globals.mangled_stack, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
949 {"default case", P_ENUM, P_LOCAL, &sDefault.iDefaultCase, NULL, enum_case, FLAG_SHARE},
950 {"case sensitive", P_BOOL, P_LOCAL, &sDefault.bCaseSensitive, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
951 {"casesignames", P_BOOL, P_LOCAL, &sDefault.bCaseSensitive, NULL, NULL, FLAG_HIDE},
952 {"preserve case", P_BOOL, P_LOCAL, &sDefault.bCasePreserve, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
953 {"short preserve case", P_BOOL, P_LOCAL, &sDefault.bShortCasePreserve, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
954 {"mangle case", P_BOOL, P_LOCAL, &sDefault.bCaseMangle, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
955 {"mangling char", P_CHAR, P_LOCAL, &sDefault.magic_char, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
956 {"hide dot files", P_BOOL, P_LOCAL, &sDefault.bHideDotFiles, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
957 {"hide special files", P_BOOL, P_LOCAL, &sDefault.bHideSpecialFiles, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
958 {"hide unreadable", P_BOOL, P_LOCAL, &sDefault.bHideUnReadable, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
959 {"hide unwriteable files", P_BOOL, P_LOCAL, &sDefault.bHideUnWriteableFiles, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
960 {"delete veto files", P_BOOL, P_LOCAL, &sDefault.bDeleteVetoFiles, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
961 {"veto files", P_STRING, P_LOCAL, &sDefault.szVetoFiles, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL },
962 {"hide files", P_STRING, P_LOCAL, &sDefault.szHideFiles, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL },
963 {"veto oplock files", P_STRING, P_LOCAL, &sDefault.szVetoOplockFiles, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL },
964 {"map system", P_BOOL, P_LOCAL, &sDefault.bMap_system, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
965 {"map hidden", P_BOOL, P_LOCAL, &sDefault.bMap_hidden, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
966 {"map archive", P_BOOL, P_LOCAL, &sDefault.bMap_archive, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
967 {"mangled names", P_BOOL, P_LOCAL, &sDefault.bMangledNames, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
968 {"mangled map", P_STRING, P_LOCAL, &sDefault.szMangledMap, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
969 {"stat cache", P_BOOL, P_GLOBAL, &Globals.bStatCache, NULL, NULL, FLAG_DEVELOPER},
970
971 {"Domain Options", P_SEP, P_SEPARATOR},
972
973 {"machine password timeout", P_INTEGER, P_GLOBAL, &Globals.machine_password_timeout, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
974
975 {"Logon Options", P_SEP, P_SEPARATOR},
976
977 {"add user script", P_STRING, P_GLOBAL, &Globals.szAddUserScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
978 {"delete user script", P_STRING, P_GLOBAL, &Globals.szDelUserScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
979 {"add group script", P_STRING, P_GLOBAL, &Globals.szAddGroupScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
980 {"delete group script", P_STRING, P_GLOBAL, &Globals.szDelGroupScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
981 {"add user to group script", P_STRING, P_GLOBAL, &Globals.szAddUserToGroupScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
982 {"delete user from group script", P_STRING, P_GLOBAL, &Globals.szDelUserFromGroupScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
983 {"set primary group script", P_STRING, P_GLOBAL, &Globals.szSetPrimaryGroupScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
984 {"add machine script", P_STRING, P_GLOBAL, &Globals.szAddMachineScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
985 {"shutdown script", P_STRING, P_GLOBAL, &Globals.szShutdownScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
986 {"abort shutdown script", P_STRING, P_GLOBAL, &Globals.szAbortShutdownScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
987
988 {"logon script", P_STRING, P_GLOBAL, &Globals.szLogonScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
989 {"logon path", P_STRING, P_GLOBAL, &Globals.szLogonPath, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
990 {"logon drive", P_STRING, P_GLOBAL, &Globals.szLogonDrive, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
991 {"logon home", P_STRING, P_GLOBAL, &Globals.szLogonHome, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
992 {"domain logons", P_BOOL, P_GLOBAL, &Globals.bDomainLogons, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
993
994 {"Browse Options", P_SEP, P_SEPARATOR},
995
996 {"os level", P_INTEGER, P_GLOBAL, &Globals.os_level, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
997 {"lm announce", P_ENUM, P_GLOBAL, &Globals.lm_announce, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_DEVELOPER},
998 {"lm interval", P_INTEGER, P_GLOBAL, &Globals.lm_interval, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
999 {"preferred master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
1000 {"prefered master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_HIDE},
1001 {"local master", P_BOOL, P_GLOBAL, &Globals.bLocalMaster, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
1002 {"domain master", P_ENUM, P_GLOBAL, &Globals.bDomainMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
1003 {"browse list", P_BOOL, P_GLOBAL, &Globals.bBrowseList, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1004 {"browseable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
1005 {"browsable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_HIDE},
1006 {"enhanced browsing", P_BOOL, P_GLOBAL, &Globals.enhanced_browsing, NULL, NULL, FLAG_DEVELOPER | FLAG_ADVANCED},
1007
1008 {"WINS Options", P_SEP, P_SEPARATOR},
1009 {"dns proxy", P_BOOL, P_GLOBAL, &Globals.bDNSproxy, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1010 {"wins proxy", P_BOOL, P_GLOBAL, &Globals.bWINSproxy, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1011
1012 {"wins server", P_LIST, P_GLOBAL, &Globals.szWINSservers, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
1013 {"wins support", P_BOOL, P_GLOBAL, &Globals.bWINSsupport, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
1014 {"wins hook", P_STRING, P_GLOBAL, &Globals.szWINSHook, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1015 {"wins partners", P_STRING, P_GLOBAL, &Globals.szWINSPartners, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
1016
1017 {"Locking Options", P_SEP, P_SEPARATOR},
1018
1019 {"blocking locks", P_BOOL, P_LOCAL, &sDefault.bBlockingLocks, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1020 {"csc policy", P_ENUM, P_LOCAL, &sDefault.iCSCPolicy, NULL, enum_csc_policy, FLAG_SHARE | FLAG_GLOBAL},
1021 {"fake oplocks", P_BOOL, P_LOCAL, &sDefault.bFakeOplocks, NULL, NULL, FLAG_SHARE},
1022 {"kernel oplocks", P_BOOL, P_GLOBAL, &Globals.bKernelOplocks, NULL, NULL, FLAG_GLOBAL},
1023 {"locking", P_BOOL, P_LOCAL, &sDefault.bLocking, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1024 {"lock spin count", P_INTEGER, P_GLOBAL, &Globals.iLockSpinCount, NULL, NULL, FLAG_GLOBAL},
1025 {"lock spin time", P_INTEGER, P_GLOBAL, &Globals.iLockSpinTime, NULL, NULL, FLAG_GLOBAL},
1026
1027 {"oplocks", P_BOOL, P_LOCAL, &sDefault.bOpLocks, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1028 {"level2 oplocks", P_BOOL, P_LOCAL, &sDefault.bLevel2OpLocks, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1029 {"oplock break wait time", P_INTEGER, P_GLOBAL, &Globals.oplock_break_wait_time, NULL, NULL, FLAG_GLOBAL},
1030 {"oplock contention limit", P_INTEGER, P_LOCAL, &sDefault.iOplockContentionLimit, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1031 {"posix locking", P_BOOL, P_LOCAL, &sDefault.bPosixLocking, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1032 {"strict locking", P_BOOL, P_LOCAL, &sDefault.bStrictLocking, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1033 {"share modes", P_BOOL, P_LOCAL, &sDefault.bShareModes, NULL, NULL, FLAG_SHARE|FLAG_GLOBAL},
1034
1035 {"Ldap Options", P_SEP, P_SEPARATOR},
1036
1037 #ifdef WITH_LDAP_SAMCONFIG
1038 {"ldap server", P_STRING, P_GLOBAL, &Globals.szLdapServer, NULL, NULL, 0},
1039 {"ldap port", P_INTEGER, P_GLOBAL, &Globals.ldap_port, NULL, NULL, 0},
1040 #endif
1041 {"ldap suffix", P_STRING, P_GLOBAL, &Globals.szLdapSuffix, handle_ldap_suffix, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1042 {"ldap machine suffix", P_STRING, P_GLOBAL, &Globals.szLdapMachineSuffix, handle_ldap_machine_suffix, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1043 {"ldap user suffix", P_STRING, P_GLOBAL, &Globals.szLdapUserSuffix, handle_ldap_user_suffix, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1044 {"ldap filter", P_STRING, P_GLOBAL, &Globals.szLdapFilter, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1045 {"ldap admin dn", P_STRING, P_GLOBAL, &Globals.szLdapAdminDn, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1046 {"ldap ssl", P_ENUM, P_GLOBAL, &Globals.ldap_ssl, NULL, enum_ldap_ssl, FLAG_ADVANCED | FLAG_DEVELOPER},
1047 {"ldap passwd sync", P_ENUM, P_GLOBAL, &Globals.ldap_passwd_sync, NULL, enum_ldap_passwd_sync, FLAG_ADVANCED | FLAG_DEVELOPER},
1048 {"ldap trust ids", P_BOOL, P_GLOBAL, &Globals.ldap_trust_ids, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1049 {"ldap delete dn", P_BOOL, P_GLOBAL, &Globals.ldap_delete_dn, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1050
1051 {"Miscellaneous Options", P_SEP, P_SEPARATOR},
1052 {"add share command", P_STRING, P_GLOBAL, &Globals.szAddShareCommand, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1053 {"change share command", P_STRING, P_GLOBAL, &Globals.szChangeShareCommand, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1054 {"delete share command", P_STRING, P_GLOBAL, &Globals.szDeleteShareCommand, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1055
1056 {"config file", P_STRING, P_GLOBAL, &Globals.szConfigFile, NULL, NULL, FLAG_HIDE},
1057 {"preload", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1058 {"auto services", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1059 {"lock dir", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_HIDE},
1060 {"lock directory", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1061 {"pid directory", P_STRING, P_GLOBAL, &Globals.szPidDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1062 #ifdef WITH_UTMP
1063 {"utmp directory", P_STRING, P_GLOBAL, &Globals.szUtmpDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1064 {"wtmp directory", P_STRING, P_GLOBAL, &Globals.szWtmpDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1065 {"utmp", P_BOOL, P_GLOBAL, &Globals.bUtmp, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1066 #endif
1067
1068 {"default service", P_STRING, P_GLOBAL, &Globals.szDefaultService, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1069 {"default", P_STRING, P_GLOBAL, &Globals.szDefaultService, NULL, NULL, FLAG_DEVELOPER},
1070 {"message command", P_STRING, P_GLOBAL, &Globals.szMsgCommand, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1071 {"dfree command", P_STRING, P_GLOBAL, &Globals.szDfree, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1072 {"remote announce", P_STRING, P_GLOBAL, &Globals.szRemoteAnnounce, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1073 {"remote browse sync", P_STRING, P_GLOBAL, &Globals.szRemoteBrowseSync, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1074 {"socket address", P_STRING, P_GLOBAL, &Globals.szSocketAddress, NULL, NULL, FLAG_DEVELOPER},
1075 {"homedir map", P_STRING, P_GLOBAL, &Globals.szNISHomeMapName, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1076 {"time offset", P_INTEGER, P_GLOBAL, &extra_time_offset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1077 {"NIS homedir", P_BOOL, P_GLOBAL, &Globals.bNISHomeMap, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1078 {"-valid", P_BOOL, P_LOCAL, &sDefault.valid, NULL, NULL, FLAG_HIDE},
1079
1080 {"copy", P_STRING, P_LOCAL, &sDefault.szCopy, handle_copy, NULL, FLAG_HIDE},
1081 {"include", P_STRING, P_LOCAL, &sDefault.szInclude, handle_include, NULL, FLAG_HIDE},
1082 {"exec", P_STRING, P_LOCAL, &sDefault.szPreExec, NULL, NULL, FLAG_SHARE | FLAG_PRINT},
1083 {"preexec", P_STRING, P_LOCAL, &sDefault.szPreExec, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1084
1085 {"preexec close", P_BOOL, P_LOCAL, &sDefault.bPreexecClose, NULL, NULL, FLAG_SHARE},
1086 {"postexec", P_STRING, P_LOCAL, &sDefault.szPostExec, NULL, NULL, FLAG_SHARE | FLAG_PRINT},
1087 {"root preexec", P_STRING, P_LOCAL, &sDefault.szRootPreExec, NULL, NULL, FLAG_SHARE | FLAG_PRINT},
1088 {"root preexec close", P_BOOL, P_LOCAL, &sDefault.bRootpreexecClose, NULL, NULL, FLAG_SHARE},
1089 {"root postexec", P_STRING, P_LOCAL, &sDefault.szRootPostExec, NULL, NULL, FLAG_SHARE | FLAG_PRINT},
1090 {"available", P_BOOL, P_LOCAL, &sDefault.bAvailable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
1091 {"volume", P_STRING, P_LOCAL, &sDefault.volume, NULL, NULL, FLAG_SHARE },
1092 {"fstype", P_STRING, P_LOCAL, &sDefault.fstype, NULL, NULL, FLAG_SHARE},
1093 {"set directory", P_BOOLREV, P_LOCAL, &sDefault.bNo_set_dir, NULL, NULL, FLAG_SHARE},
1094 {"source environment", P_STRING, P_GLOBAL, &Globals.szSourceEnv, handle_source_env, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1095 {"wide links", P_BOOL, P_LOCAL, &sDefault.bWidelinks, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1096 {"follow symlinks", P_BOOL, P_LOCAL, &sDefault.bSymlinks, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1097 {"dont descend", P_STRING, P_LOCAL, &sDefault.szDontdescend, NULL, NULL, FLAG_SHARE},
1098 {"magic script", P_STRING, P_LOCAL, &sDefault.szMagicScript, NULL, NULL, FLAG_SHARE},
1099 {"magic output", P_STRING, P_LOCAL, &sDefault.szMagicOutput, NULL, NULL, FLAG_SHARE},
1100 {"delete readonly", P_BOOL, P_LOCAL, &sDefault.bDeleteReadonly, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1101 {"dos filemode", P_BOOL, P_LOCAL, &sDefault.bDosFilemode, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1102 {"dos filetimes", P_BOOL, P_LOCAL, &sDefault.bDosFiletimes, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1103 {"dos filetime resolution", P_BOOL, P_LOCAL, &sDefault.bDosFiletimeResolution, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1104
1105 {"fake directory create times", P_BOOL, P_LOCAL, &sDefault.bFakeDirCreateTimes, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
1106 {"panic action", P_STRING, P_GLOBAL, &Globals.szPanicAction, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1107 {"hide local users", P_BOOL, P_GLOBAL, &Globals.bHideLocalUsers, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1108
1109 {"VFS module options", P_SEP, P_SEPARATOR},
1110
1111 {"vfs object", P_LIST, P_LOCAL, &sDefault.szVfsObjectFile, NULL, NULL, FLAG_SHARE},
1112 {"vfs options", P_STRING, P_LOCAL, &sDefault.szVfsOptions, NULL, NULL, FLAG_SHARE},
1113 {"vfs path", P_STRING, P_LOCAL, &sDefault.szVfsPath, NULL, NULL, FLAG_SHARE},
1114
1115
1116 {"msdfs root", P_BOOL, P_LOCAL, &sDefault.bMSDfsRoot, NULL, NULL, FLAG_SHARE},
1117 {"msdfs proxy", P_STRING, P_LOCAL, &sDefault.szMSDfsProxy, NULL, NULL, FLAG_SHARE},
1118 {"host msdfs", P_BOOL, P_GLOBAL, &Globals.bHostMSDfs, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1119
1120 {"Winbind options", P_SEP, P_SEPARATOR},
1121
1122 {"idmap uid", P_STRING, P_GLOBAL, &Globals.szIdmapUID, handle_idmap_uid, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1123 {"winbind uid", P_STRING, P_GLOBAL, &Globals.szIdmapUID, handle_idmap_uid, NULL, FLAG_ADVANCED | FLAG_DEVELOPER | FLAG_HIDE},
1124 {"idmap gid", P_STRING, P_GLOBAL, &Globals.szIdmapGID, handle_idmap_gid, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1125 {"winbind gid", P_STRING, P_GLOBAL, &Globals.szIdmapGID, handle_idmap_gid, NULL, FLAG_ADVANCED | FLAG_DEVELOPER | FLAG_HIDE},
1126 {"template homedir", P_STRING, P_GLOBAL, &Globals.szTemplateHomedir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1127 {"template shell", P_STRING, P_GLOBAL, &Globals.szTemplateShell, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1128 {"winbind separator", P_STRING, P_GLOBAL, &Globals.szWinbindSeparator, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1129 {"winbind cache time", P_INTEGER, P_GLOBAL, &Globals.winbind_cache_time, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1130 {"winbind enum users", P_BOOL, P_GLOBAL, &Globals.bWinbindEnumUsers, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1131 {"winbind enum groups", P_BOOL, P_GLOBAL, &Globals.bWinbindEnumGroups, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1132 {"winbind use default domain", P_BOOL, P_GLOBAL, &Globals.bWinbindUseDefaultDomain, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1133 {"winbind backend", P_STRING, P_GLOBAL, &Globals.szWinbindBackend, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
1134
1135 {NULL, P_BOOL, P_NONE, NULL, NULL, NULL, 0}
1136 };
1137
1138 /***************************************************************************
1139 Initialise the sDefault parameter structure for the printer values.
1140 ***************************************************************************/
1141
1142 static void init_printer_values(void)
1143 {
1144 /* choose defaults depending on the type of printing */
1145 switch (sDefault.iPrinting) {
1146 case PRINT_BSD:
1147 case PRINT_AIX:
1148 case PRINT_LPRNT:
1149 case PRINT_LPROS2:
1150 string_set(&sDefault.szLpqcommand, "lpq -P'%p'");
1151 string_set(&sDefault.szLprmcommand, "lprm -P'%p' %j");
1152 string_set(&sDefault.szPrintcommand,
1153 "lpr -r -P'%p' %s");
1154 break;
1155
1156 case PRINT_LPRNG:
1157 case PRINT_PLP:
1158 string_set(&sDefault.szLpqcommand, "lpq -P'%p'");
1159 string_set(&sDefault.szLprmcommand, "lprm -P'%p' %j");
1160 string_set(&sDefault.szPrintcommand,
1161 "lpr -r -P'%p' %s");
1162 string_set(&sDefault.szQueuepausecommand,
1163 "lpc stop '%p'");
1164 string_set(&sDefault.szQueueresumecommand,
1165 "lpc start '%p'");
1166 string_set(&sDefault.szLppausecommand,
1167 "lpc hold '%p' %j");
1168 string_set(&sDefault.szLpresumecommand,
1169 "lpc release '%p' %j");
1170 break;
1171
1172 case PRINT_CUPS:
1173 #ifdef HAVE_CUPS
1174 string_set(&sDefault.szLpqcommand, "");
1175 string_set(&sDefault.szLprmcommand, "");
1176 string_set(&sDefault.szPrintcommand, "");
1177 string_set(&sDefault.szLppausecommand, "");
1178 string_set(&sDefault.szLpresumecommand, "");
1179 string_set(&sDefault.szQueuepausecommand, "");
1180 string_set(&sDefault.szQueueresumecommand, "");
1181
1182 string_set(&Globals.szPrintcapname, "cups");
1183 #else
1184 string_set(&sDefault.szLpqcommand,
1185 "/usr/bin/lpstat -o '%p'");
1186 string_set(&sDefault.szLprmcommand,
1187 "/usr/bin/cancel '%p-%j'");
1188 string_set(&sDefault.szPrintcommand,
1189 "/usr/bin/lp -d '%p' %s; rm %s");
1190 string_set(&sDefault.szLppausecommand,
1191 "lp -i '%p-%j' -H hold");
1192 string_set(&sDefault.szLpresumecommand,
1193 "lp -i '%p-%j' -H resume");
1194 string_set(&sDefault.szQueuepausecommand,
1195 "/usr/bin/disable '%p'");
1196 string_set(&sDefault.szQueueresumecommand,
1197 "/usr/bin/enable '%p'");
1198 string_set(&Globals.szPrintcapname, "lpstat");
1199 #endif /* HAVE_CUPS */
1200 break;
1201
1202 case PRINT_SYSV:
1203 case PRINT_HPUX:
1204 string_set(&sDefault.szLpqcommand, "lpstat -o%p");
1205 string_set(&sDefault.szLprmcommand, "cancel %p-%j");
1206 string_set(&sDefault.szPrintcommand,
1207 "lp -c -d%p %s; rm %s");
1208 string_set(&sDefault.szQueuepausecommand,
1209 "disable %p");
1210 string_set(&sDefault.szQueueresumecommand,
1211 "enable %p");
1212 #ifndef HPUX
1213 string_set(&sDefault.szLppausecommand,
1214 "lp -i %p-%j -H hold");
1215 string_set(&sDefault.szLpresumecommand,
1216 "lp -i %p-%j -H resume");
1217 #endif /* HPUX */
1218 break;
1219
1220 case PRINT_QNX:
1221 string_set(&sDefault.szLpqcommand, "lpq -P%p");
1222 string_set(&sDefault.szLprmcommand, "lprm -P%p %j");
1223 string_set(&sDefault.szPrintcommand, "lp -r -P%p %s");
1224 break;
1225
1226 case PRINT_SOFTQ:
1227 string_set(&sDefault.szLpqcommand, "qstat -l -d%p");
1228 string_set(&sDefault.szLprmcommand,
1229 "qstat -s -j%j -c");
1230 string_set(&sDefault.szPrintcommand,
1231 "lp -d%p -s %s; rm %s");
1232 string_set(&sDefault.szLppausecommand,
1233 "qstat -s -j%j -h");
1234 string_set(&sDefault.szLpresumecommand,
1235 "qstat -s -j%j -r");
1236 break;
1237 #ifdef DEVELOPER
1238 case PRINT_TEST:
1239 case PRINT_VLP:
1240 string_set(&sDefault.szPrintcommand, "vlp print %p %s");
1241 string_set(&sDefault.szLpqcommand, "vlp lpq %p");
1242 string_set(&sDefault.szLprmcommand, "vlp lprm %p %j");
1243 string_set(&sDefault.szLppausecommand, "vlp lppause %p %j");
1244 string_set(&sDefault.szLpresumecommand, "vlp lpresum %p %j");
1245 string_set(&sDefault.szQueuepausecommand, "vlp queuepause %p");
1246 string_set(&sDefault.szQueueresumecommand, "vlp queueresume %p");
1247 break;
1248 #endif /* DEVELOPER */
1249
1250 }
1251 }
1252
1253 /***************************************************************************
1254 Initialise the global parameter structure.
1255 ***************************************************************************/
1256
1257 static void init_globals(void)
1258 {
1259 static BOOL done_init = False;
1260 pstring s;
1261
1262 if (!done_init) {
1263 int i;
1264 memset((void *)&Globals, '\0', sizeof(Globals));
1265
1266 for (i = 0; parm_table[i].label; i++)
1267 if ((parm_table[i].type == P_STRING ||
1268 parm_table[i].type == P_USTRING) &&
1269 parm_table[i].ptr)
1270 string_set(parm_table[i].ptr, "");
1271
1272 string_set(&sDefault.fstype, FSTYPE_STRING);
1273
1274 init_printer_values();
1275
1276 done_init = True;
1277 }
1278
1279
1280 DEBUG(3, ("Initialising global parameters\n"));
1281
1282 string_set(&Globals.szSMBPasswdFile, dyn_SMB_PASSWD_FILE);
1283 string_set(&Globals.szPrivateDir, dyn_PRIVATE_DIR);
1284
1285 /* use the new 'hash2' method by default, with a prefix of 1 */
1286 string_set(&Globals.szManglingMethod, "hash2");
1287 Globals.mangle_prefix = 1;
1288
1289 string_set(&Globals.szGuestaccount, GUEST_ACCOUNT);
1290
1291 /* using UTF8 by default allows us to support all chars */
1292 string_set(&Globals.unix_charset, "UTF8");
1293
1294 /* using UTF8 by default allows us to support all chars */
1295 string_set(&Globals.display_charset, "ASCII");
1296
1297 /* Use codepage 850 as a default for the dos character set */
1298 string_set(&Globals.dos_charset, "CP850");
1299
1300 /*
1301 * Allow the default PASSWD_CHAT to be overridden in local.h.
1302 */
1303 string_set(&Globals.szPasswdChat, DEFAULT_PASSWD_CHAT);
1304
1305 set_global_myname(myhostname());
1306 string_set(&Globals.szNetbiosName,global_myname());
1307
1308 set_global_myworkgroup(WORKGROUP);
1309 string_set(&Globals.szWorkgroup, lp_workgroup());
1310
1311 string_set(&Globals.szPasswdProgram, "");
1312 string_set(&Globals.szPrintcapname, PRINTCAP_NAME);
1313 string_set(&Globals.szPidDir, dyn_PIDDIR);
1314 string_set(&Globals.szLockDir, dyn_LOCKDIR);
1315 string_set(&Globals.szSocketAddress, "0.0.0.0");
1316 pstrcpy(s, "Samba ");
1317 pstrcat(s, VERSION);
1318 string_set(&Globals.szServerString, s);
1319 slprintf(s, sizeof(s) - 1, "%d.%d", DEFAULT_MAJOR_VERSION,
1320 DEFAULT_MINOR_VERSION);
1321 string_set(&Globals.szAnnounceVersion, s);
1322
1323 pstrcpy(user_socket_options, DEFAULT_SOCKET_OPTIONS);
1324
1325 string_set(&Globals.szLogonDrive, "");
1326 /* %N is the NIS auto.home server if -DAUTOHOME is used, else same as %L */
1327 string_set(&Globals.szLogonHome, "\\\\%N\\%U");
1328 string_set(&Globals.szLogonPath, "\\\\%N\\%U\\profile");
1329
1330 string_set(&Globals.szNameResolveOrder, "lmhosts wins host bcast");
1331 string_set(&Globals.szPasswordServer, "*");
1332
1333 Globals.AlgorithmicRidBase = BASE_RID;
1334
1335 Globals.bLoadPrinters = True;
1336 Globals.mangled_stack = 50;
1337 /* Was 65535 (0xFFFF). 0x4101 matches W2K and causes major speed improvements... */
1338 /* Discovered by 2 days of pain by Don McCall @ HP :-). */
1339 Globals.max_xmit = 0x4104;
1340 Globals.max_mux = 50; /* This is *needed* for profile support. */
1341 Globals.lpqcachetime = 10;
1342 Globals.bDisableSpoolss = False;
1343 Globals.iMaxSmbdProcesses = 0;/* no limit specified */
1344 Globals.iTotalPrintJobs = 0; /* no limit specified */
1345 Globals.pwordlevel = 0;
1346 Globals.unamelevel = 0;
1347 Globals.deadtime = 0;
1348 Globals.bLargeReadwrite = True;
1349 Globals.max_log_size = 5000;
1350 Globals.max_open_files = MAX_OPEN_FILES;
1351 Globals.maxprotocol = PROTOCOL_NT1;
1352 Globals.minprotocol = PROTOCOL_CORE;
1353 Globals.security = SEC_USER;
1354 Globals.paranoid_server_security = True;
1355 Globals.bEncryptPasswords = True;
1356 Globals.bUpdateEncrypt = False;
1357 Globals.serverSchannel = Auto;
1358 Globals.bReadRaw = True;
1359 Globals.bWriteRaw = True;
1360 Globals.bReadPrediction = False;
1361 Globals.bReadbmpx = False;
1362 Globals.bNullPasswords = False;
1363 Globals.bObeyPamRestrictions = False;
1364 Globals.bStripDot = False;
1365 Globals.syslog = 1;
1366 Globals.bSyslogOnly = False;
1367 Globals.bTimestampLogs = True;
1368 string_set(&Globals.szLogLevel, "0");
1369 Globals.bDebugHiresTimestamp = False;
1370 Globals.bDebugPid = False;
1371 Globals.bDebugUid = False;
1372 Globals.max_ttl = 60 * 60 * 24 * 3; /* 3 days default. */
1373 Globals.max_wins_ttl = 60 * 60 * 24 * 6; /* 6 days default. */
1374 Globals.min_wins_ttl = 60 * 60 * 6; /* 6 hours default. */
1375 Globals.machine_password_timeout = 60 * 60 * 24 * 7; /* 7 days default. */
1376 Globals.change_notify_timeout = 60; /* 1 minute default. */
1377 Globals.bKernelChangeNotify = True; /* On if we have it. */
1378 Globals.ReadSize = 16 * 1024;
1379 Globals.lm_announce = 2; /* = Auto: send only if LM clients found */
1380 Globals.lm_interval = 60;
1381 Globals.stat_cache_size = 50; /* Number of stat translations we'll keep */
1382 Globals.announce_as = ANNOUNCE_AS_NT_SERVER;
1383 #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT))
1384 Globals.bNISHomeMap = False;
1385 #ifdef WITH_NISPLUS_HOME
1386 string_set(&Globals.szNISHomeMapName, "auto_home.org_dir");
1387 #else
1388 string_set(&Globals.szNISHomeMapName, "auto.home");
1389 #endif
1390 #endif
1391 Globals.bTimeServer = False;
1392 Globals.bBindInterfacesOnly = False;
1393 Globals.bUnixPasswdSync = False;
1394 Globals.bPamPasswordChange = False;
1395 Globals.bPasswdChatDebug = False;
1396 Globals.bUnicode = True; /* Do unicode on the wire by default */
1397 Globals.bNTPipeSupport = True; /* Do NT pipes by default. */
1398 Globals.bNTStatusSupport = True; /* Use NT status by default. */
1399 Globals.bStatCache = True; /* use stat cache by default */
1400 Globals.restrict_anonymous = 0;
1401 Globals.bClientLanManAuth = True; /* Do use the LanMan hash if it is available */
1402 Globals.bLanmanAuth = True; /* Do use the LanMan hash if it is available */
1403 Globals.bNTLMAuth = True; /* Do use NTLMv1 if it is available (otherwise NTLMv2) */
1404
1405 Globals.map_to_guest = 0; /* By Default, "Never" */
1406 Globals.min_passwd_length = MINPASSWDLENGTH; /* By Default, 5. */
1407 Globals.oplock_break_wait_time = 0; /* By Default, 0 msecs. */
1408 Globals.enhanced_browsing = True;
1409 Globals.iLockSpinCount = 3; /* Try 2 times. */
1410 Globals.iLockSpinTime = 10; /* usec. */
1411 #ifdef MMAP_BLACKLIST
1412 Globals.bUseMmap = False;
1413 #else
1414 Globals.bUseMmap = True;
1415 #endif
1416 Globals.bUnixExtensions = False;
1417
1418 /* hostname lookups can be very expensive and are broken on
1419 a large number of sites (tridge) */
1420 Globals.bHostnameLookups = False;
1421
1422 #ifdef WITH_LDAP_SAMCONFIG
1423 string_set(&Globals.szLdapServer, "localhost");
1424 Globals.ldap_port = 636;
1425 Globals.szPassdbBackend = str_list_make("ldapsam guest", NULL);
1426 #else
1427 Globals.szPassdbBackend = str_list_make("smbpasswd guest", NULL);
1428 #endif /* WITH_LDAP_SAMCONFIG */
1429
1430 string_set(&Globals.szLdapSuffix, "");
1431 string_set(&Globals.szLdapMachineSuffix, "");
1432 string_set(&Globals.szLdapUserSuffix, "");
1433
1434 string_set(&Globals.szLdapFilter, "(&(uid=%u)(objectclass=sambaAccount))");
1435 string_set(&Globals.szLdapAdminDn, "");
1436 Globals.ldap_ssl = LDAP_SSL_ON;
1437 Globals.ldap_passwd_sync = LDAP_PASSWD_SYNC_OFF;
1438 Globals.ldap_delete_dn = False;
1439
1440 /* these parameters are set to defaults that are more appropriate
1441 for the increasing samba install base:
1442
1443 as a member of the workgroup, that will possibly become a
1444 _local_ master browser (lm = True). this is opposed to a forced
1445 local master browser startup (pm = True).
1446
1447 doesn't provide WINS server service by default (wsupp = False),
1448 and doesn't provide domain master browser services by default, either.
1449
1450 */
1451
1452 Globals.bMsAddPrinterWizard = True;
1453 Globals.bPreferredMaster = Auto; /* depending on bDomainMaster */
1454 Globals.os_level = 20;
1455 Globals.bLocalMaster = True;
1456 Globals.bDomainMaster = Auto; /* depending on bDomainLogons */
1457 Globals.bDomainLogons = False;
1458 Globals.bBrowseList = True;
1459 Globals.bWINSsupport = False;
1460 Globals.bWINSproxy = False;
1461
1462 Globals.bDNSproxy = True;
1463
1464 /* this just means to use them if they exist */
1465 Globals.bKernelOplocks = True;
1466
1467 Globals.bAllowTrustedDomains = True;
1468
1469 string_set(&Globals.szTemplateShell, "/bin/false");
1470 string_set(&Globals.szTemplateHomedir, "/home/%D/%U");
1471 string_set(&Globals.szWinbindSeparator, "\\");
1472 string_set(&Globals.szAclCompat, "");
1473
1474 Globals.winbind_cache_time = 15;
1475 Globals.bWinbindEnumUsers = True;
1476 Globals.bWinbindEnumGroups = True;
1477 Globals.bWinbindUseDefaultDomain = False;
1478
1479 string_set(&Globals.szWinbindBackend, "tdb");
1480
1481 Globals.name_cache_timeout = 660; /* In seconds */
1482
1483 Globals.bUseSpnego = True;
1484 Globals.bClientUseSpnego = True;
1485
1486 string_set(&Globals.smb_ports, SMB_PORTS);
1487 }
1488
1489 static TALLOC_CTX *lp_talloc;
1490
1491 /******************************************************************* a
1492 Free up temporary memory - called from the main loop.
1493 ********************************************************************/
1494
1495 void lp_talloc_free(void)
1496 {
1497 if (!lp_talloc)
1498 return;
1499 talloc_destroy(lp_talloc);
1500 lp_talloc = NULL;
1501 }
1502
1503 /*******************************************************************
1504 Convenience routine to grab string parameters into temporary memory
1505 and run standard_sub_basic on them. The buffers can be written to by
1506 callers without affecting the source string.
1507 ********************************************************************/
1508
1509 static char *lp_string(const char *s)
1510 {
1511 size_t len = s ? strlen(s) : 0;
1512 char *ret;
1513
1514 /* The follow debug is useful for tracking down memory problems
1515 especially if you have an inner loop that is calling a lp_*()
1516 function that returns a string. Perhaps this debug should be
1517 present all the time? */
1518
1519 #if 0
1520 DEBUG(10, ("lp_string(%s)\n", s));
1521 #endif
1522
1523 if (!lp_talloc)
1524 lp_talloc = talloc_init("lp_talloc");
1525
1526 ret = (char *)talloc(lp_talloc, len + 100); /* leave room for substitution */
1527
1528 if (!ret)
1529 return NULL;
1530
1531 /* Note: StrnCpy touches len+1 bytes, but we allocate 100
1532 * extra bytes so we're OK. */
1533
1534 if (!s)
1535 *ret = 0;
1536 else
1537 StrnCpy(ret, s, len);
1538
1539 if (trim_string(ret, "\"", "\"")) {
1540 if (strchr(ret,'"') != NULL)
1541 StrnCpy(ret, s, len);
1542 }
1543
1544 standard_sub_basic(current_user_info.smb_name,ret,len+100);
1545 return (ret);
1546 }
1547
1548 /*
1549 In this section all the functions that are used to access the
1550 parameters from the rest of the program are defined
1551 */
1552
1553 #define FN_GLOBAL_STRING(fn_name,ptr) \
1554 char *fn_name(void) {return(lp_string(*(char **)(ptr) ? *(char **)(ptr) : ""));}
1555 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1556 const char *fn_name(void) {return(*(const char **)(ptr) ? *(const char **)(ptr) : "");}
1557 #define FN_GLOBAL_LIST(fn_name,ptr) \
1558 const char **fn_name(void) {return(*(const char ***)(ptr));}
1559 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1560 BOOL fn_name(void) {return(*(BOOL *)(ptr));}
1561 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1562 char fn_name(void) {return(*(char *)(ptr));}
1563 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1564 int fn_name(void) {return(*(int *)(ptr));}
1565
1566 #define FN_LOCAL_STRING(fn_name,val) \
1567 char *fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
1568 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1569 const char *fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1570 #define FN_LOCAL_LIST(fn_name,val) \
1571 const char **fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1572 #define FN_LOCAL_BOOL(fn_name,val) \
1573 BOOL fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1574 #define FN_LOCAL_CHAR(fn_name,val) \
1575 char fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1576 #define FN_LOCAL_INTEGER(fn_name,val) \
1577 int fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1578
1579 FN_GLOBAL_STRING(lp_smb_ports, &Globals.smb_ports)
1580 FN_GLOBAL_STRING(lp_dos_charset, &Globals.dos_charset)
1581 FN_GLOBAL_STRING(lp_unix_charset, &Globals.unix_charset)
1582 FN_GLOBAL_STRING(lp_display_charset, &Globals.display_charset)
1583 FN_GLOBAL_STRING(lp_logfile, &Globals.szLogFile)
1584 FN_GLOBAL_STRING(lp_configfile, &Globals.szConfigFile)
1585 FN_GLOBAL_STRING(lp_smb_passwd_file, &Globals.szSMBPasswdFile)
1586 FN_GLOBAL_STRING(lp_private_dir, &Globals.szPrivateDir)
1587 FN_GLOBAL_STRING(lp_serverstring, &Globals.szServerString)
1588 FN_GLOBAL_STRING(lp_printcapname, &Globals.szPrintcapname)
1589 FN_GLOBAL_STRING(lp_enumports_cmd, &Globals.szEnumPortsCommand)
1590 FN_GLOBAL_STRING(lp_addprinter_cmd, &Globals.szAddPrinterCommand)
1591 FN_GLOBAL_STRING(lp_deleteprinter_cmd, &Globals.szDeletePrinterCommand)
1592 FN_GLOBAL_STRING(lp_os2_driver_map, &Globals.szOs2DriverMap)
1593 FN_GLOBAL_STRING(lp_lockdir, &Globals.szLockDir)
1594 FN_GLOBAL_STRING(lp_piddir, &Globals.szPidDir)
1595 FN_GLOBAL_STRING(lp_mangling_method, &Globals.szManglingMethod)
1596 FN_GLOBAL_INTEGER(lp_mangle_prefix, &Globals.mangle_prefix)
1597 #ifdef WITH_UTMP
1598 FN_GLOBAL_STRING(lp_utmpdir, &Globals.szUtmpDir)
1599 FN_GLOBAL_STRING(lp_wtmpdir, &Globals.szWtmpDir)
1600 FN_GLOBAL_BOOL(lp_utmp, &Globals.bUtmp)
1601 #endif
1602 FN_GLOBAL_STRING(lp_rootdir, &Globals.szRootdir)
1603 FN_GLOBAL_STRING(lp_source_environment, &Globals.szSourceEnv)
1604 FN_GLOBAL_STRING(lp_defaultservice, &Globals.szDefaultService)
1605 FN_GLOBAL_STRING(lp_msg_command, &Globals.szMsgCommand)
1606 FN_GLOBAL_STRING(lp_dfree_command, &Globals.szDfree)
1607 FN_GLOBAL_STRING(lp_hosts_equiv, &Globals.szHostsEquiv)
1608 FN_GLOBAL_STRING(lp_auto_services, &Globals.szAutoServices)
1609 FN_GLOBAL_STRING(lp_passwd_program, &Globals.szPasswdProgram)
1610 FN_GLOBAL_STRING(lp_passwd_chat, &Globals.szPasswdChat)
1611 FN_GLOBAL_STRING(lp_passwordserver, &Globals.szPasswordServer)
1612 FN_GLOBAL_STRING(lp_name_resolve_order, &Globals.szNameResolveOrder)
1613 FN_GLOBAL_STRING(lp_realm, &Globals.szRealm)
1614 FN_GLOBAL_STRING(lp_ads_server, &Globals.szADSserver)
1615 FN_GLOBAL_STRING(lp_username_map, &Globals.szUsernameMap)
1616 FN_GLOBAL_CONST_STRING(lp_logon_script, &Globals.szLogonScript)
1617 FN_GLOBAL_CONST_STRING(lp_logon_path, &Globals.szLogonPath)
1618 FN_GLOBAL_CONST_STRING(lp_logon_drive, &Globals.szLogonDrive)
1619 FN_GLOBAL_CONST_STRING(lp_logon_home, &Globals.szLogonHome)
1620 FN_GLOBAL_STRING(lp_remote_announce, &Globals.szRemoteAnnounce)
1621 FN_GLOBAL_STRING(lp_remote_browse_sync, &Globals.szRemoteBrowseSync)
1622 FN_GLOBAL_LIST(lp_wins_server_list, &Globals.szWINSservers)
1623 FN_GLOBAL_LIST(lp_interfaces, &Globals.szInterfaces)
1624 FN_GLOBAL_STRING(lp_socket_address, &Globals.szSocketAddress)
1625 FN_GLOBAL_STRING(lp_nis_home_map_name, &Globals.szNISHomeMapName)
1626 static FN_GLOBAL_STRING(lp_announce_version, &Globals.szAnnounceVersion)
1627 FN_GLOBAL_LIST(lp_netbios_aliases, &Globals.szNetbiosAliases)
1628 FN_GLOBAL_LIST(lp_passdb_backend, &Globals.szPassdbBackend)
1629 FN_GLOBAL_LIST(lp_sam_backend, &Globals.szSamBackend)
1630 FN_GLOBAL_LIST(lp_preload_modules, &Globals.szPreloadModules)
1631 FN_GLOBAL_STRING(lp_panic_action, &Globals.szPanicAction)
1632 FN_GLOBAL_STRING(lp_adduser_script, &Globals.szAddUserScript)
1633 FN_GLOBAL_STRING(lp_deluser_script, &Globals.szDelUserScript)
1634
1635 FN_GLOBAL_CONST_STRING(lp_guestaccount, &Globals.szGuestaccount)
1636 FN_GLOBAL_STRING(lp_addgroup_script, &Globals.szAddGroupScript)
1637 FN_GLOBAL_STRING(lp_delgroup_script, &Globals.szDelGroupScript)
1638 FN_GLOBAL_STRING(lp_addusertogroup_script, &Globals.szAddUserToGroupScript)
1639 FN_GLOBAL_STRING(lp_deluserfromgroup_script, &Globals.szDelUserFromGroupScript)
1640 FN_GLOBAL_STRING(lp_setprimarygroup_script, &Globals.szSetPrimaryGroupScript)
1641
1642 FN_GLOBAL_STRING(lp_addmachine_script, &Globals.szAddMachineScript)
1643
1644 FN_GLOBAL_STRING(lp_shutdown_script, &Globals.szShutdownScript)
1645 FN_GLOBAL_STRING(lp_abort_shutdown_script, &Globals.szAbortShutdownScript)
1646
1647 FN_GLOBAL_STRING(lp_wins_hook, &Globals.szWINSHook)
1648 FN_GLOBAL_STRING(lp_wins_partners, &Globals.szWINSPartners)
1649 FN_GLOBAL_STRING(lp_template_homedir, &Globals.szTemplateHomedir)
1650 FN_GLOBAL_STRING(lp_template_shell, &Globals.szTemplateShell)
1651 FN_GLOBAL_CONST_STRING(lp_winbind_separator, &Globals.szWinbindSeparator)
1652 FN_GLOBAL_STRING(lp_acl_compatibility, &Globals.szAclCompat)
1653 FN_GLOBAL_BOOL(lp_winbind_enum_users, &Globals.bWinbindEnumUsers)
1654 FN_GLOBAL_BOOL(lp_winbind_enum_groups, &Globals.bWinbindEnumGroups)
1655 FN_GLOBAL_BOOL(lp_winbind_use_default_domain, &Globals.bWinbindUseDefaultDomain)
1656 FN_GLOBAL_STRING(lp_winbind_backend, &Globals.szWinbindBackend)
1657
1658 FN_GLOBAL_STRING(lp_idmap_backend, &Globals.szIdmapBackend)
1659
1660 #ifdef WITH_LDAP_SAMCONFIG
1661 FN_GLOBAL_STRING(lp_ldap_server, &Globals.szLdapServer)
1662 FN_GLOBAL_INTEGER(lp_ldap_port, &Globals.ldap_port)
1663 #endif
1664 FN_GLOBAL_STRING(lp_ldap_suffix, &Globals.szLdapSuffix)
1665 FN_GLOBAL_STRING(lp_ldap_machine_suffix, &Globals.szLdapMachineSuffix)
1666 FN_GLOBAL_STRING(lp_ldap_user_suffix, &Globals.szLdapUserSuffix)
1667 FN_GLOBAL_STRING(lp_ldap_filter, &Globals.szLdapFilter)
1668 FN_GLOBAL_STRING(lp_ldap_admin_dn, &Globals.szLdapAdminDn)
1669 FN_GLOBAL_INTEGER(lp_ldap_ssl, &Globals.ldap_ssl)
1670 FN_GLOBAL_INTEGER(lp_ldap_passwd_sync, &Globals.ldap_passwd_sync)
1671 FN_GLOBAL_BOOL(lp_ldap_trust_ids, &Globals.ldap_trust_ids)
1672 FN_GLOBAL_BOOL(lp_ldap_delete_dn, &Globals.ldap_delete_dn)
1673 FN_GLOBAL_STRING(lp_add_share_cmd, &Globals.szAddShareCommand)
1674 FN_GLOBAL_STRING(lp_change_share_cmd, &Globals.szChangeShareCommand)
1675 FN_GLOBAL_STRING(lp_delete_share_cmd, &Globals.szDeleteShareCommand)
1676
1677 FN_GLOBAL_BOOL(lp_disable_netbios, &Globals.bDisableNetbios)
1678 FN_GLOBAL_BOOL(lp_ms_add_printer_wizard, &Globals.bMsAddPrinterWizard)
1679 FN_GLOBAL_BOOL(lp_dns_proxy, &Globals.bDNSproxy)
1680 FN_GLOBAL_BOOL(lp_wins_support, &Globals.bWINSsupport)
1681 FN_GLOBAL_BOOL(lp_we_are_a_wins_server, &Globals.bWINSsupport)
1682 FN_GLOBAL_BOOL(lp_wins_proxy, &Globals.bWINSproxy)
1683 FN_GLOBAL_BOOL(lp_local_master, &Globals.bLocalMaster)
1684 FN_GLOBAL_BOOL(lp_domain_logons, &Globals.bDomainLogons)
1685 FN_GLOBAL_BOOL(lp_load_printers, &Globals.bLoadPrinters)
1686 FN_GLOBAL_BOOL(lp_readprediction, &Globals.bReadPrediction)
1687 FN_GLOBAL_BOOL(lp_readbmpx, &Globals.bReadbmpx)
1688 FN_GLOBAL_BOOL(lp_readraw, &Globals.bReadRaw)
1689 FN_GLOBAL_BOOL(lp_large_readwrite, &Globals.bLargeReadwrite)
1690 FN_GLOBAL_BOOL(lp_writeraw, &Globals.bWriteRaw)
1691 FN_GLOBAL_BOOL(lp_null_passwords, &Globals.bNullPasswords)
1692 FN_GLOBAL_BOOL(lp_obey_pam_restrictions, &Globals.bObeyPamRestrictions)
1693 FN_GLOBAL_BOOL(lp_strip_dot, &Globals.bStripDot)
1694 FN_GLOBAL_BOOL(lp_encrypted_passwords, &Globals.bEncryptPasswords)
1695 FN_GLOBAL_BOOL(lp_update_encrypted, &Globals.bUpdateEncrypt)
1696 FN_GLOBAL_INTEGER(lp_server_schannel, &Globals.serverSchannel)
1697 FN_GLOBAL_BOOL(lp_syslog_only, &Globals.bSyslogOnly)
1698 FN_GLOBAL_BOOL(lp_timestamp_logs, &Globals.bTimestampLogs)
1699 FN_GLOBAL_BOOL(lp_debug_hires_timestamp, &Globals.bDebugHiresTimestamp)
1700 FN_GLOBAL_BOOL(lp_debug_pid, &Globals.bDebugPid)
1701 FN_GLOBAL_BOOL(lp_debug_uid, &Globals.bDebugUid)
1702 FN_GLOBAL_BOOL(lp_browse_list, &Globals.bBrowseList)
1703 FN_GLOBAL_BOOL(lp_nis_home_map, &Globals.bNISHomeMap)
1704 static FN_GLOBAL_BOOL(lp_time_server, &Globals.bTimeServer)
1705 FN_GLOBAL_BOOL(lp_bind_interfaces_only, &Globals.bBindInterfacesOnly)
1706 FN_GLOBAL_BOOL(lp_pam_password_change, &Globals.bPamPasswordChange)
1707 FN_GLOBAL_BOOL(lp_unix_password_sync, &Globals.bUnixPasswdSync)
1708 FN_GLOBAL_BOOL(lp_passwd_chat_debug, &Globals.bPasswdChatDebug)
1709 FN_GLOBAL_BOOL(lp_unicode, &Globals.bUnicode)
1710 FN_GLOBAL_BOOL(lp_nt_pipe_support, &Globals.bNTPipeSupport)
1711 FN_GLOBAL_BOOL(lp_nt_status_support, &Globals.bNTStatusSupport)
1712 FN_GLOBAL_BOOL(lp_stat_cache, &Globals.bStatCache)
1713 FN_GLOBAL_BOOL(lp_allow_trusted_domains, &Globals.bAllowTrustedDomains)
1714 FN_GLOBAL_INTEGER(lp_restrict_anonymous, &Globals.restrict_anonymous)
1715 FN_GLOBAL_BOOL(lp_lanman_auth, &Globals.bLanmanAuth)
1716 FN_GLOBAL_BOOL(lp_ntlm_auth, &Globals.bNTLMAuth)
1717 FN_GLOBAL_BOOL(lp_client_lanman_auth, &Globals.bClientLanManAuth)
1718 FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, &Globals.bClientNTLMv2Auth)
1719 FN_GLOBAL_BOOL(lp_host_msdfs, &Globals.bHostMSDfs)
1720 FN_GLOBAL_BOOL(lp_kernel_oplocks, &Globals.bKernelOplocks)
1721 FN_GLOBAL_BOOL(lp_enhanced_browsing, &Globals.enhanced_browsing)
1722 FN_GLOBAL_BOOL(lp_use_mmap, &Globals.bUseMmap)
1723 FN_GLOBAL_BOOL(lp_unix_extensions, &Globals.bUnixExtensions)
1724 FN_GLOBAL_BOOL(lp_use_spnego, &Globals.bUseSpnego)
1725 FN_GLOBAL_BOOL(lp_client_use_spnego, &Globals.bClientUseSpnego)
1726 FN_GLOBAL_BOOL(lp_hostname_lookups, &Globals.bHostnameLookups)
1727 FN_GLOBAL_BOOL(lp_kernel_change_notify, &Globals.bKernelChangeNotify)
1728 FN_GLOBAL_INTEGER(lp_os_level, &Globals.os_level)
1729 FN_GLOBAL_INTEGER(lp_max_ttl, &Globals.max_ttl)
1730 FN_GLOBAL_INTEGER(lp_max_wins_ttl, &Globals.max_wins_ttl)
1731 FN_GLOBAL_INTEGER(lp_min_wins_ttl, &Globals.min_wins_ttl)
1732 FN_GLOBAL_INTEGER(lp_max_log_size, &Globals.max_log_size)
1733 FN_GLOBAL_INTEGER(lp_max_open_files, &Globals.max_open_files)
1734 FN_GLOBAL_INTEGER(lp_maxxmit, &Globals.max_xmit)
1735 FN_GLOBAL_INTEGER(lp_maxmux, &Globals.max_mux)
1736 FN_GLOBAL_INTEGER(lp_passwordlevel, &Globals.pwordlevel)
1737 FN_GLOBAL_INTEGER(lp_usernamelevel, &Globals.unamelevel)
1738 FN_GLOBAL_INTEGER(lp_readsize, &Globals.ReadSize)
1739 FN_GLOBAL_INTEGER(lp_deadtime, &Globals.deadtime)
1740 FN_GLOBAL_INTEGER(lp_maxprotocol, &Globals.maxprotocol)
1741 FN_GLOBAL_INTEGER(lp_minprotocol, &Globals.minprotocol)
1742 FN_GLOBAL_INTEGER(lp_security, &Globals.security)
1743 FN_GLOBAL_LIST(lp_auth_methods, &Globals.AuthMethods)
1744 FN_GLOBAL_BOOL(lp_paranoid_server_security, &Globals.paranoid_server_security)
1745 FN_GLOBAL_INTEGER(lp_maxdisksize, &Globals.maxdisksize)
1746 FN_GLOBAL_INTEGER(lp_lpqcachetime, &Globals.lpqcachetime)
1747 FN_GLOBAL_INTEGER(lp_max_smbd_processes, &Globals.iMaxSmbdProcesses)
1748 FN_GLOBAL_INTEGER(lp_disable_spoolss, &Globals.bDisableSpoolss)
1749 FN_GLOBAL_INTEGER(lp_totalprintjobs, &Globals.iTotalPrintJobs)
1750 FN_GLOBAL_INTEGER(lp_syslog, &Globals.syslog)
1751 static FN_GLOBAL_INTEGER(lp_announce_as, &Globals.announce_as)
1752 FN_GLOBAL_INTEGER(lp_lm_announce, &Globals.lm_announce)
1753 FN_GLOBAL_INTEGER(lp_lm_interval, &Globals.lm_interval)
1754 FN_GLOBAL_INTEGER(lp_machine_password_timeout, &Globals.machine_password_timeout)
1755 FN_GLOBAL_INTEGER(lp_change_notify_timeout, &Globals.change_notify_timeout)
1756 FN_GLOBAL_INTEGER(lp_stat_cache_size, &Globals.stat_cache_size)
1757 FN_GLOBAL_INTEGER(lp_map_to_guest, &Globals.map_to_guest)
1758 FN_GLOBAL_INTEGER(lp_min_passwd_length, &Globals.min_passwd_length)
1759 FN_GLOBAL_INTEGER(lp_oplock_break_wait_time, &Globals.oplock_break_wait_time)
1760 FN_GLOBAL_INTEGER(lp_lock_spin_count, &Globals.iLockSpinCount)
1761 FN_GLOBAL_INTEGER(lp_lock_sleep_time, &Globals.iLockSpinTime)
1762 FN_LOCAL_STRING(lp_preexec, szPreExec)
1763 FN_LOCAL_STRING(lp_postexec, szPostExec)
1764 FN_LOCAL_STRING(lp_rootpreexec, szRootPreExec)
1765 FN_LOCAL_STRING(lp_rootpostexec, szRootPostExec)
1766 FN_LOCAL_STRING(lp_servicename, szService)
1767 FN_LOCAL_CONST_STRING(lp_const_servicename, szService)
1768 FN_LOCAL_STRING(lp_pathname, szPath)
1769 FN_LOCAL_STRING(lp_dontdescend, szDontdescend)
1770 FN_LOCAL_STRING(lp_username, szUsername)
1771 FN_LOCAL_LIST(lp_invalid_users, szInvalidUsers)
1772 FN_LOCAL_LIST(lp_valid_users, szValidUsers)
1773 FN_LOCAL_LIST(lp_admin_users, szAdminUsers)
1774 FN_LOCAL_STRING(lp_printcommand, szPrintcommand)
1775 FN_LOCAL_STRING(lp_lpqcommand, szLpqcommand)
1776 FN_LOCAL_STRING(lp_lprmcommand, szLprmcommand)
1777 FN_LOCAL_STRING(lp_lppausecommand, szLppausecommand)
1778 FN_LOCAL_STRING(lp_lpresumecommand, szLpresumecommand)
1779 FN_LOCAL_STRING(lp_queuepausecommand, szQueuepausecommand)
1780 FN_LOCAL_STRING(lp_queueresumecommand, szQueueresumecommand)
1781 static FN_LOCAL_STRING(_lp_printername, szPrintername)
1782 FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
1783 FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
1784 FN_LOCAL_STRING(lp_magicscript, szMagicScript)
1785 FN_LOCAL_STRING(lp_magicoutput, szMagicOutput)
1786 FN_LOCAL_STRING(lp_comment, comment)
1787 FN_LOCAL_STRING(lp_force_user, force_user)
1788 FN_LOCAL_STRING(lp_force_group, force_group)
1789 FN_LOCAL_LIST(lp_readlist, readlist)
1790 FN_LOCAL_LIST(lp_writelist, writelist)
1791 FN_LOCAL_LIST(lp_printer_admin, printer_admin)
1792 FN_LOCAL_STRING(lp_fstype, fstype)
1793 FN_LOCAL_LIST(lp_vfsobj, szVfsObjectFile)
1794 FN_LOCAL_STRING(lp_vfs_options, szVfsOptions)
1795 FN_LOCAL_STRING(lp_vfs_path, szVfsPath)
1796 FN_LOCAL_STRING(lp_msdfs_proxy, szMSDfsProxy)
1797 static FN_LOCAL_STRING(lp_volume, volume)
1798 FN_LOCAL_STRING(lp_mangled_map, szMangledMap)
1799 FN_LOCAL_STRING(lp_veto_files, szVetoFiles)
1800 FN_LOCAL_STRING(lp_hide_files, szHideFiles)
1801 FN_LOCAL_STRING(lp_veto_oplocks, szVetoOplockFiles)
1802 FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
1803 FN_LOCAL_BOOL(lp_autoloaded, autoloaded)
1804 FN_LOCAL_BOOL(lp_preexec_close, bPreexecClose)
1805 FN_LOCAL_BOOL(lp_rootpreexec_close, bRootpreexecClose)
1806 FN_LOCAL_BOOL(lp_casesensitive, bCaseSensitive)
1807 FN_LOCAL_BOOL(lp_preservecase, bCasePreserve)
1808 FN_LOCAL_BOOL(lp_shortpreservecase, bShortCasePreserve)
1809 FN_LOCAL_BOOL(lp_casemangle, bCaseMangle)
1810 FN_LOCAL_BOOL(lp_hide_dot_files, bHideDotFiles)
1811 FN_LOCAL_BOOL(lp_hide_special_files, bHideSpecialFiles)
1812 FN_LOCAL_BOOL(lp_hideunreadable, bHideUnReadable)
1813 FN_LOCAL_BOOL(lp_hideunwriteable_files, bHideUnWriteableFiles)
1814 FN_LOCAL_BOOL(lp_browseable, bBrowseable)
1815 FN_LOCAL_BOOL(lp_readonly, bRead_only)
1816 FN_LOCAL_BOOL(lp_no_set_dir, bNo_set_dir)
1817 FN_LOCAL_BOOL(lp_guest_ok, bGuest_ok)
1818 FN_LOCAL_BOOL(lp_guest_only, bGuest_only)
1819 FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
1820 FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
1821 FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
1822 FN_LOCAL_BOOL(lp_locking, bLocking)
1823 FN_LOCAL_BOOL(lp_strict_locking, bStrictLocking)
1824 FN_LOCAL_BOOL(lp_posix_locking, bPosixLocking)
1825 FN_LOCAL_BOOL(lp_share_modes, bShareModes)
1826 FN_LOCAL_BOOL(lp_oplocks, bOpLocks)
1827 FN_LOCAL_BOOL(lp_level2_oplocks, bLevel2OpLocks)
1828 FN_LOCAL_BOOL(lp_onlyuser, bOnlyUser)
1829 FN_LOCAL_BOOL(lp_manglednames, bMangledNames)
1830 FN_LOCAL_BOOL(lp_widelinks, bWidelinks)
1831 FN_LOCAL_BOOL(lp_symlinks, bSymlinks)
1832 FN_LOCAL_BOOL(lp_syncalways, bSyncAlways)
1833 FN_LOCAL_BOOL(lp_strict_allocate, bStrictAllocate)
1834 FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
1835 FN_LOCAL_BOOL(lp_map_system, bMap_system)
1836 FN_LOCAL_BOOL(lp_delete_readonly, bDeleteReadonly)
1837 FN_LOCAL_BOOL(lp_fake_oplocks, bFakeOplocks)
1838 FN_LOCAL_BOOL(lp_recursive_veto_delete, bDeleteVetoFiles)
1839 FN_LOCAL_BOOL(lp_dos_filemode, bDosFilemode)
1840 FN_LOCAL_BOOL(lp_dos_filetimes, bDosFiletimes)
1841 FN_LOCAL_BOOL(lp_dos_filetime_resolution, bDosFiletimeResolution)
1842 FN_LOCAL_BOOL(lp_fake_dir_create_times, bFakeDirCreateTimes)
1843 FN_LOCAL_BOOL(lp_blocking_locks, bBlockingLocks)
1844 FN_LOCAL_BOOL(lp_inherit_perms, bInheritPerms)
1845 FN_LOCAL_BOOL(lp_inherit_acls, bInheritACLS)
1846 FN_LOCAL_BOOL(lp_use_client_driver, bUseClientDriver)
1847 FN_LOCAL_BOOL(lp_default_devmode, bDefaultDevmode)
1848 FN_LOCAL_BOOL(lp_nt_acl_support, bNTAclSupport)
1849 FN_LOCAL_BOOL(lp_use_sendfile, bUseSendfile)
1850 FN_LOCAL_BOOL(lp_profile_acls, bProfileAcls)
1851 FN_LOCAL_INTEGER(lp_create_mask, iCreate_mask)
1852 FN_LOCAL_INTEGER(lp_force_create_mode, iCreate_force_mode)
1853 FN_LOCAL_INTEGER(lp_security_mask, iSecurity_mask)
1854 FN_LOCAL_INTEGER(lp_force_security_mode, iSecurity_force_mode)
1855 FN_LOCAL_INTEGER(lp_dir_mask, iDir_mask)
1856 FN_LOCAL_INTEGER(lp_force_dir_mode, iDir_force_mode)
1857 FN_LOCAL_INTEGER(lp_dir_security_mask, iDir_Security_mask)
1858 FN_LOCAL_INTEGER(lp_force_dir_security_mode, iDir_Security_force_mode)
1859 FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
1860 FN_LOCAL_INTEGER(lp_defaultcase, iDefaultCase)
1861 FN_LOCAL_INTEGER(lp_minprintspace, iMinPrintSpace)
1862 FN_LOCAL_INTEGER(lp_printing, iPrinting)
1863 FN_LOCAL_INTEGER(lp_max_reported_jobs, iMaxReportedPrintJobs)
1864 FN_LOCAL_INTEGER(lp_oplock_contention_limit, iOplockContentionLimit)
1865 FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
1866 FN_LOCAL_INTEGER(lp_write_cache_size, iWriteCacheSize)
1867 FN_LOCAL_INTEGER(lp_block_size, iBlock_size)
1868 FN_LOCAL_CHAR(lp_magicchar, magic_char)
1869 FN_GLOBAL_INTEGER(lp_winbind_cache_time, &Globals.winbind_cache_time)
1870 FN_GLOBAL_BOOL(lp_hide_local_users, &Globals.bHideLocalUsers)
1871 FN_GLOBAL_INTEGER(lp_algorithmic_rid_base, &Globals.AlgorithmicRidBase)
1872 FN_GLOBAL_INTEGER(lp_name_cache_timeout, &Globals.name_cache_timeout)
1873 FN_GLOBAL_BOOL(lp_client_signing, &Globals.client_signing)
1874
1875 /* local prototypes */
1876
1877 static int map_parameter(const char *pszParmName);
1878 static BOOL set_boolean(BOOL *pb, const char *pszParmValue);
1879 static int getservicebyname(const char *pszServiceName,
1880 service * pserviceDest);
1881 static void copy_service(service * pserviceDest,
1882 service * pserviceSource, BOOL *pcopymapDest);
1883 static BOOL service_ok(int iService);
1884 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue);
1885 static BOOL do_section(const char *pszSectionName);
1886 static void init_copymap(service * pservice);
1887
1888 /* This is a helper function for parametrical options support. */
1889 /* It returns a pointer to parametrical option value if it exists or NULL otherwise */
1890 /* Actual parametrical functions are quite simple */
1891 static const char *get_parametrics(int lookup_service, const char *type, const char *option)
1892 {
1893 char* vfskey;
1894 param_opt_struct *data;
1895
1896 if (lookup_service >= iNumServices) return NULL;
1897
1898 data = (lookup_service < 0) ?
1899 Globals.param_opt : ServicePtrs[lookup_service]->param_opt;
1900
1901 asprintf(&vfskey, "%s:%s", type, option);
1902 while (data) {
1903 if (strcmp(data->key, vfskey) == 0) {
1904 string_free(&vfskey);
1905 return data->value;
1906 }
1907 data = data->next;
1908 }
1909
1910 if (lookup_service >= 0) {
1911 /* Try to fetch the same option but from globals */
1912 /* but only if we are not already working with Globals */
1913 data = Globals.param_opt;
1914 while (data) {
1915 if (strcmp(data->key, vfskey) == 0) {
1916 string_free(&vfskey);
1917 return data->value;
1918 }
1919 data = data->next;
1920 }
1921 }
1922
1923 string_free(&vfskey);
1924
1925 return NULL;
1926 }
1927
1928
1929 /*******************************************************************
1930 convenience routine to return int parameters.
1931 ********************************************************************/
1932 static int lp_int(const char *s)
1933 {
1934
1935 if (!s) {
1936 DEBUG(0,("lp_int(%s): is called with NULL!\n",s));
1937 return (-1);
1938 }
1939
1940 return atoi(s);
1941 }
1942
1943 /*******************************************************************
1944 convenience routine to return unsigned long parameters.
1945 ********************************************************************/
1946 static int lp_ulong(const char *s)
1947 {
1948
1949 if (!s) {
1950 DEBUG(0,("lp_int(%s): is called with NULL!\n",s));
1951 return (-1);
1952 }
1953
1954 return strtoul(s, NULL, 10);
1955 }
1956
1957 /*******************************************************************
1958 convenience routine to return boolean parameters.
1959 ********************************************************************/
1960 static BOOL lp_bool(const char *s)
1961 {
1962 BOOL ret = False;
1963
1964 if (!s) {
1965 DEBUG(0,("lp_bool(%s): is called with NULL!\n",s));
1966 return False;
1967 }
1968
1969 if (!set_boolean(&ret,s)) {
1970 DEBUG(0,("lp_bool(%s): value is not boolean!\n",s));
1971 return False;
1972 }
1973
1974 return ret;
1975 }
1976
1977 /*******************************************************************
1978 convenience routine to return enum parameters.
1979 ********************************************************************/
1980 static int lp_enum(const char *s,const struct enum_list *_enum)
1981 {
1982 int i;
1983
1984 if (!s || !_enum) {
1985 DEBUG(0,("lp_enum(%s,enum): is called with NULL!\n",s));
1986 return False;
1987 }
1988
1989 for (i=0; _enum[i].name; i++) {
1990 if (strcasecmp(_enum[i].name,s)==0)
1991 return _enum[i].value;
1992 }
1993
1994 DEBUG(0,("lp_enum(%s,enum): value is not in enum_list!\n",s));
1995 return (-1);
1996 }
1997
1998 /* Return parametric option from a given service. Type is a part of option before ':' */
1999 /* Parametric option has following syntax: 'Type: option = value' */
2000 /* Returned value is allocated in 'lp_talloc' context */
2001
2002 char *lp_parm_string(int lookup_service, const char *type, const char *option)
2003 {
2004 const char *value = get_parametrics(lookup_service, type, option);
2005
2006 if (value)
2007 return lp_string(value);
2008
2009 return NULL;
2010 }
2011
2012 /* Return parametric option from a given service. Type is a part of option before ':' */
2013 /* Parametric option has following syntax: 'Type: option = value' */
2014 /* Returned value is allocated in 'lp_talloc' context */
2015
2016 char **lp_parm_string_list(int lookup_service, const char *type, const char *option,
2017 const char *separator)
2018 {
2019 const char *value = get_parametrics(lookup_service, type, option);
2020
2021 if (value)
2022 return str_list_make(value, separator);
2023
2024 return NULL;
2025 }
2026
2027 /* Return parametric option from a given service. Type is a part of option before ':' */
2028 /* Parametric option has following syntax: 'Type: option = value' */
2029
2030 int lp_parm_int(int lookup_service, const char *type, const char *option)
2031 {
2032 const char *value = get_parametrics(lookup_service, type, option);
2033
2034 if (value)
2035 return lp_int(value);
2036
2037 return (-1);
2038 }
2039
2040 /* Return parametric option from a given service. Type is a part of option before ':' */
2041 /* Parametric option has following syntax: 'Type: option = value' */
2042
2043 unsigned long lp_parm_ulong(int lookup_service, const char *type, const char *option)
2044 {
2045 const char *value = get_parametrics(lookup_service, type, option);
2046
2047 if (value)
2048 return lp_ulong(value);
2049
2050 return (0);
2051 }
2052
2053 /* Return parametric option from a given service. Type is a part of option before ':' */
2054 /* Parametric option has following syntax: 'Type: option = value' */
2055
2056 BOOL lp_parm_bool(int lookup_service, const char *type, const char *option)
2057 {
2058 const char *value = get_parametrics(lookup_service, type, option);
2059
2060 if (value)
2061 return lp_bool(value);
2062
2063 return False;
2064 }
2065
2066 /* Return parametric option from a given service. Type is a part of option before ':' */
2067 /* Parametric option has following syntax: 'Type: option = value' */
2068
2069 int lp_parm_enum(int lookup_service, const char *type, const char *option,
2070 const struct enum_list *_enum)
2071 {
2072 const char *value = get_parametrics(lookup_service, type, option);
2073
2074 if (value)
2075 return lp_enum(value, _enum);
2076
2077 return (-1);
2078 }
2079
2080
2081 /***************************************************************************
2082 Initialise a service to the defaults.
2083 ***************************************************************************/
2084
2085 static void init_service(service * pservice)
2086 {
2087 memset((char *)pservice, '\0', sizeof(service));
2088 copy_service(pservice, &sDefault, NULL);
2089 }
2090
2091 /***************************************************************************
2092 Free the dynamically allocated parts of a service struct.
2093 ***************************************************************************/
2094
2095 static void free_service(service *pservice)
2096 {
2097 int i;
2098 param_opt_struct *data, *pdata;
2099 if (!pservice)
2100 return;
2101
2102 if (pservice->szService)
2103 DEBUG(5, ("free_service: Freeing service %s\n",
2104 pservice->szService));
2105
2106 string_free(&pservice->szService);
2107 SAFE_FREE(pservice->copymap);
2108
2109 for (i = 0; parm_table[i].label; i++) {
2110 if ((parm_table[i].type == P_STRING ||
2111 parm_table[i].type == P_USTRING) &&
2112 parm_table[i].class == P_LOCAL)
2113 string_free((char **)
2114 (((char *)pservice) +
2115 PTR_DIFF(parm_table[i].ptr, &sDefault)));
2116 else if (parm_table[i].type == P_LIST &&
2117 parm_table[i].class == P_LOCAL)
2118 str_list_free((char ***)
2119 (((char *)pservice) +
2120 PTR_DIFF(parm_table[i].ptr, &sDefault)));
2121 }
2122
2123 DEBUG(5,("Freeing parametrics:\n"));
2124 data = pservice->param_opt;
2125 while (data) {
2126 DEBUG(5,("[%s = %s]\n", data->key, data->value));
2127 string_free(&data->key);
2128 string_free(&data->value);
2129 pdata = data->next;
2130 SAFE_FREE(data);
2131 data = pdata;
2132 }
2133
2134 ZERO_STRUCTP(pservice);
2135 }
2136
2137 /***************************************************************************
2138 Add a new service to the services array initialising it with the given
2139 service.
2140 ***************************************************************************/
2141
2142 static int add_a_service(const service *pservice, const char *name)
2143 {
2144 int i;
2145 service tservice;
2146 int num_to_alloc = iNumServices + 1;
2147 param_opt_struct *data, *pdata;
2148
2149 tservice = *pservice;
2150
2151 /* it might already exist */
2152 if (name) {
2153 i = getservicebyname(name, NULL);
2154 if (i >= 0) {
2155 /* Clean all parametric options for service */
2156 /* They will be added during parsing again */
2157 data = ServicePtrs[i]->param_opt;
2158 while (data) {
2159 string_free(&data->key);
2160 string_free(&data->value);
2161 pdata = data->next;
2162 SAFE_FREE(data);
2163 data = pdata;
2164 }
2165 ServicePtrs[i]->param_opt = NULL;
2166 return (i);
2167 }
2168 }
2169
2170 /* find an invalid one */
2171 for (i = 0; i < iNumServices; i++)
2172 if (!ServicePtrs[i]->valid)
2173 break;
2174
2175 /* if not, then create one */
2176 if (i == iNumServices) {
2177 service **tsp;
2178
2179 tsp = (service **) Realloc(ServicePtrs,
2180 sizeof(service *) *
2181 num_to_alloc);
2182
2183 if (!tsp) {
2184 DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
2185 return (-1);
2186 }
2187 else {
2188 ServicePtrs = tsp;
2189 ServicePtrs[iNumServices] =
2190 (service *) malloc(sizeof(service));
2191 }
2192 if (!ServicePtrs[iNumServices]) {
2193 DEBUG(0,("add_a_service: out of memory!\n"));
2194 return (-1);
2195 }
2196
2197 iNumServices++;
2198 } else
2199 free_service(ServicePtrs[i]);
2200
2201 ServicePtrs[i]->valid = True;
2202
2203 init_service(ServicePtrs[i]);
2204 copy_service(ServicePtrs[i], &tservice, NULL);
2205 if (name)
2206 string_set(&ServicePtrs[i]->szService, name);
2207 return (i);
2208 }
2209
2210 /***************************************************************************
2211 Add a new home service, with the specified home directory, defaults coming
2212 from service ifrom.
2213 ***************************************************************************/
2214
2215 BOOL lp_add_home(const char *pszHomename, int iDefaultService,
2216 const char *user, const char *pszHomedir)
2217 {
2218 int i;
2219 pstring newHomedir;
2220
2221 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
2222
2223 if (i < 0)
2224 return (False);
2225
2226 if (!(*(ServicePtrs[iDefaultService]->szPath))
2227 || strequal(ServicePtrs[iDefaultService]->szPath, lp_pathname(-1))) {
2228 pstrcpy(newHomedir, pszHomedir);
2229 } else {
2230 pstrcpy(newHomedir, lp_pathname(iDefaultService));
2231 string_sub(newHomedir,"%H", pszHomedir, sizeof(newHomedir));
2232 }
2233
2234 string_set(&ServicePtrs[i]->szPath, newHomedir);
2235
2236 if (!(*(ServicePtrs[i]->comment))) {
2237 pstring comment;
2238 slprintf(comment, sizeof(comment) - 1,
2239 "Home directory of %s", user);
2240 string_set(&ServicePtrs[i]->comment, comment);
2241 }
2242 ServicePtrs[i]->bAvailable = sDefault.bAvailable;
2243 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2244
2245 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
2246 user, newHomedir));
2247
2248 return (True);
2249 }
2250
2251 /***************************************************************************
2252 Add a new service, based on an old one.
2253 ***************************************************************************/
2254
2255 int lp_add_service(const char *pszService, int iDefaultService)
2256 {
2257 return (add_a_service(ServicePtrs[iDefaultService], pszService));
2258 }
2259
2260 /***************************************************************************
2261 Add the IPC service.
2262 ***************************************************************************/
2263
2264 static BOOL lp_add_ipc(const char *ipc_name, BOOL guest_ok)
2265 {
2266 pstring comment;
2267 int i = add_a_service(&sDefault, ipc_name);
2268
2269 if (i < 0)
2270 return (False);
2271
2272 slprintf(comment, sizeof(comment) - 1,
2273 "IPC Service (%s)", Globals.szServerString);
2274
2275 string_set(&ServicePtrs[i]->szPath, tmpdir());
2276 string_set(&ServicePtrs[i]->szUsername, "");
2277 string_set(&ServicePtrs[i]->comment, comment);
2278 string_set(&ServicePtrs[i]->fstype, "IPC");
2279 ServicePtrs[i]->iMaxConnections = 0;
2280 ServicePtrs[i]->bAvailable = True;
2281 ServicePtrs[i]->bRead_only = True;
2282 ServicePtrs[i]->bGuest_only = False;
2283 ServicePtrs[i]->bGuest_ok = guest_ok;
2284 ServicePtrs[i]->bPrint_ok = False;
2285 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2286
2287 DEBUG(3, ("adding IPC service\n"));
2288
2289 return (True);
2290 }
2291
2292 /***************************************************************************
2293 Add a new printer service, with defaults coming from service iFrom.
2294 ***************************************************************************/
2295
2296 BOOL lp_add_printer(const char *pszPrintername, int iDefaultService)
2297 {
2298 const char *comment = "From Printcap";
2299 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
2300
2301 if (i < 0)
2302 return (False);
2303
2304 /* note that we do NOT default the availability flag to True - */
2305 /* we take it from the default service passed. This allows all */
2306 /* dynamic printers to be disabled by disabling the [printers] */
2307 /* entry (if/when the 'available' keyword is implemented!). */
2308
2309 /* the printer name is set to the service name. */
2310 string_set(&ServicePtrs[i]->szPrintername, pszPrintername);
2311 string_set(&ServicePtrs[i]->comment, comment);
2312 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
2313 /* Printers cannot be read_only. */
2314 ServicePtrs[i]->bRead_only = False;
2315 /* No share modes on printer services. */
2316 ServicePtrs[i]->bShareModes = False;
2317 /* No oplocks on printer services. */
2318 ServicePtrs[i]->bOpLocks = False;
2319 /* Printer services must be printable. */
2320 ServicePtrs[i]->bPrint_ok = True;
2321
2322 DEBUG(3, ("adding printer service %s\n", pszPrintername));
2323
2324 update_server_announce_as_printserver();
2325
2326 return (True);
2327 }
2328
2329 /***************************************************************************
2330 Map a parameter's string representation to something we can use.
2331 Returns False if the parameter string is not recognised, else TRUE.
2332 ***************************************************************************/
2333
2334 static int map_parameter(const char *pszParmName)
2335 {
2336 int iIndex;
2337
2338 if (*pszParmName == '-')
2339 return (-1);
2340
2341 for (iIndex = 0; parm_table[iIndex].label; iIndex++)
2342 if (strwicmp(parm_table[iIndex].label, pszParmName) == 0)
2343 return (iIndex);
2344
2345 /* Warn only if it isn't parametric option */
2346 if (strchr(pszParmName, ':') == NULL)
2347 DEBUG(0, ("Unknown parameter encountered: \"%s\"\n", pszParmName));
2348 /* We do return 'fail' for parametric options as well because they are
2349 stored in different storage
2350 */
2351 return (-1);
2352 }
2353
2354 /***************************************************************************
2355 Set a boolean variable from the text value stored in the passed string.
2356 Returns True in success, False if the passed string does not correctly
2357 represent a boolean.
2358 ***************************************************************************/
2359
2360 static BOOL set_boolean(BOOL *pb, const char *pszParmValue)
2361 {
2362 BOOL bRetval;
2363
2364 bRetval = True;
2365 if (strwicmp(pszParmValue, "yes") == 0 ||
2366 strwicmp(pszParmValue, "true") == 0 ||
2367 strwicmp(pszParmValue, "1") == 0)
2368 *pb = True;
2369 else if (strwicmp(pszParmValue, "no") == 0 ||
2370 strwicmp(pszParmValue, "False") == 0 ||
2371 strwicmp(pszParmValue, "0") == 0)
2372 *pb = False;
2373 else {
2374 DEBUG(0,
2375 ("ERROR: Badly formed boolean in configuration file: \"%s\".\n",
2376 pszParmValue));
2377 bRetval = False;
2378 }
2379 return (bRetval);
2380 }
2381
2382 /***************************************************************************
2383 Find a service by name. Otherwise works like get_service.
2384 ***************************************************************************/
2385
2386 static int getservicebyname(const char *pszServiceName, service * pserviceDest)
2387 {
2388 int iService;
2389
2390 for (iService = iNumServices - 1; iService >= 0; iService--)
2391 if (VALID(iService) &&
2392 strwicmp(ServicePtrs[iService]->szService, pszServiceName) == 0) {
2393 if (pserviceDest != NULL)
2394 copy_service(pserviceDest, ServicePtrs[iService], NULL);
2395 break;
2396 }
2397
2398 return (iService);
2399 }
2400
2401 /***************************************************************************
2402 Copy a service structure to another.
2403 If pcopymapDest is NULL then copy all fields
2404 ***************************************************************************/
2405
2406 static void copy_service(service * pserviceDest, service * pserviceSource, BOOL *pcopymapDest)
2407 {
2408 int i;
2409 BOOL bcopyall = (pcopymapDest == NULL);
2410 param_opt_struct *data, *pdata, *paramo;
2411 BOOL not_added;
2412
2413 for (i = 0; parm_table[i].label; i++)
2414 if (parm_table[i].ptr && parm_table[i].class == P_LOCAL &&
2415 (bcopyall || pcopymapDest[i])) {
2416 void *def_ptr = parm_table[i].ptr;
2417 void *src_ptr =
2418 ((char *)pserviceSource) + PTR_DIFF(def_ptr,
2419 &sDefault);
2420 void *dest_ptr =
2421 ((char *)pserviceDest) + PTR_DIFF(def_ptr,
2422 &sDefault);
2423
2424 switch (parm_table[i].type) {
2425 case P_BOOL:
2426 case P_BOOLREV:
2427 *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
2428 break;
2429
2430 case P_INTEGER:
2431 case P_ENUM:
2432 case P_OCTAL:
2433 *(int *)dest_ptr = *(int *)src_ptr;
2434 break;
2435
2436 case P_CHAR:
2437 *(char *)dest_ptr = *(char *)src_ptr;
2438 break;
2439
2440 case P_STRING:
2441 string_set(dest_ptr,
2442 *(char **)src_ptr);
2443 break;
2444
2445 case P_USTRING:
2446 string_set(dest_ptr,
2447 *(char **)src_ptr);
2448 strupper(*(char **)dest_ptr);
2449 break;
2450 case P_LIST:
2451 str_list_copy((char ***)dest_ptr, *(const char ***)src_ptr);
2452 break;
2453 default:
2454 break;
2455 }
2456 }
2457
2458 if (bcopyall) {
2459 init_copymap(pserviceDest);
2460 if (pserviceSource->copymap)
2461 memcpy((void *)pserviceDest->copymap,
2462 (void *)pserviceSource->copymap,
2463 sizeof(BOOL) * NUMPARAMETERS);
2464 }
2465
2466 data = pserviceSource->param_opt;
2467 while (data) {
2468 not_added = True;
2469 pdata = pserviceDest->param_opt;
2470 /* Traverse destination */
2471 while (pdata) {
2472 /* If we already have same option, override it */
2473 if (strcmp(pdata->key, data->key) == 0) {
2474 string_free(&pdata->value);
2475 pdata->value = strdup(data->value);
2476 not_added = False;
2477 break;
2478 }
2479 pdata = pdata->next;
2480 }
2481 if (not_added) {
2482 paramo = smb_xmalloc(sizeof(param_opt_struct));
2483 paramo->key = strdup(data->key);
2484 paramo->value = strdup(data->value);
2485 DLIST_ADD(pserviceDest->param_opt, paramo);
2486 }
2487 data = data->next;
2488 }
2489 }
2490
2491 /***************************************************************************
2492 Check a service for consistency. Return False if the service is in any way
2493 incomplete or faulty, else True.
2494 ***************************************************************************/
2495
2496 static BOOL service_ok(int iService)
2497 {
2498 BOOL bRetval;
2499
2500 bRetval = True;
2501 if (ServicePtrs[iService]->szService[0] == '\0') {
2502 DEBUG(0, ("The following message indicates an internal error:\n"));
2503 DEBUG(0, ("No service name in service entry.\n"));
2504 bRetval = False;
2505 }
2506
2507 /* The [printers] entry MUST be printable. I'm all for flexibility, but */
2508 /* I can't see why you'd want a non-printable printer service... */
2509 if (strwicmp(ServicePtrs[iService]->szService, PRINTERS_NAME) == 0) {
2510 if (!ServicePtrs[iService]->bPrint_ok) {
2511 DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
2512 ServicePtrs[iService]->szService));
2513 ServicePtrs[iService]->bPrint_ok = True;
2514 }
2515 /* [printers] service must also be non-browsable. */
2516 if (ServicePtrs[iService]->bBrowseable)
2517 ServicePtrs[iService]->bBrowseable = False;
2518 }
2519
2520 if (ServicePtrs[iService]->szPath[0] == '\0' &&
2521 strwicmp(ServicePtrs[iService]->szService, HOMES_NAME) != 0) {
2522 DEBUG(0, ("No path in service %s - using %s\n",
2523 ServicePtrs[iService]->szService, tmpdir()));
2524 string_set(&ServicePtrs[iService]->szPath, tmpdir());
2525 }
2526
2527 /* If a service is flagged unavailable, log the fact at level 0. */
2528 if (!ServicePtrs[iService]->bAvailable)
2529 DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
2530 ServicePtrs[iService]->szService));
2531
2532 return (bRetval);
2533 }
2534
2535 static struct file_lists {
2536 struct file_lists *next;
2537 char *name;
2538 char *subfname;
2539 time_t modtime;
2540 } *file_lists = NULL;
2541
2542 /*******************************************************************
2543 Keep a linked list of all config files so we know when one has changed
2544 it's date and needs to be reloaded.
2545 ********************************************************************/
2546
2547 static void add_to_file_list(const char *fname, const char *subfname)
2548 {
2549 struct file_lists *f = file_lists;
2550
2551 while (f) {
2552 if (f->name && !strcmp(f->name, fname))
2553 break;
2554 f = f->next;
2555 }
2556
2557 if (!f) {
2558 f = (struct file_lists *)malloc(sizeof(file_lists[0]));
2559 if (!f)
2560 return;
2561 f->next = file_lists;
2562 f->name = strdup(fname);
2563 if (!f->name) {
2564 SAFE_FREE(f);
2565 return;
2566 }
2567 f->subfname = strdup(subfname);
2568 if (!f->subfname) {
2569 SAFE_FREE(f);
2570 return;
2571 }
2572 file_lists = f;
2573 f->modtime = file_modtime(subfname);
2574 } else {
2575 time_t t = file_modtime(subfname);
2576 if (t)
2577 f->modtime = t;
2578 }
2579 }
2580
2581 /*******************************************************************
2582 Check if a config file has changed date.
2583 ********************************************************************/
2584
2585 BOOL lp_file_list_changed(void)
2586 {
2587 struct file_lists *f = file_lists;
2588 DEBUG(6, ("lp_file_list_changed()\n"));
2589
2590 while (f) {
2591 pstring n2;
2592 time_t mod_time;
2593
2594 pstrcpy(n2, f->name);
2595 standard_sub_basic(current_user_info.smb_name, n2,sizeof(n2));
2596
2597 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
2598 f->name, n2, ctime(&f->modtime)));
2599
2600 mod_time = file_modtime(n2);
2601
2602 if (mod_time && ((f->modtime != mod_time) || (f->subfname == NULL) || (strcmp(n2, f->subfname) != 0))) {
2603 DEBUGADD(6,
2604 ("file %s modified: %s\n", n2,
2605 ctime(&mod_time)));
2606 f->modtime = mod_time;
2607 SAFE_FREE(f->subfname);
2608 f->subfname = strdup(n2);
2609 return (True);
2610 }
2611 f = f->next;
2612 }
2613 return (False);
2614 }
2615
2616 /***************************************************************************
2617 Run standard_sub_basic on netbios name... needed because global_myname
2618 is not accessed through any lp_ macro.
2619 Note: We must *NOT* use string_set() here as ptr points to global_myname.
2620 ***************************************************************************/
2621
2622 static BOOL handle_netbios_name(const char *pszParmValue, char **ptr)
2623 {
2624 BOOL ret;
2625 pstring netbios_name;
2626
2627 pstrcpy(netbios_name, pszParmValue);
2628
2629 standard_sub_basic(current_user_info.smb_name, netbios_name,sizeof(netbios_name));
2630
2631
2632 ret = set_global_myname(netbios_name);
2633 string_set(&Globals.szNetbiosName,global_myname());
2634
2635 DEBUG(4, ("handle_netbios_name: set global_myname to: %s\n",
2636 global_myname()));
2637
2638 return ret;
2639 }
2640
2641 static BOOL handle_workgroup(const char *pszParmValue, char **ptr)
2642 {
2643 BOOL ret;
2644
2645 ret = set_global_myworkgroup(pszParmValue);
2646 string_set(&Globals.szWorkgroup,lp_workgroup());
2647
2648 return ret;
2649 }
2650
2651 static BOOL handle_netbios_scope(const char *pszParmValue, char **ptr)
2652 {
2653 BOOL ret;
2654
2655 ret = set_global_scope(pszParmValue);
2656 string_set(&Globals.szNetbiosScope,global_scope());
2657
2658 return ret;
2659 }
2660
2661 static BOOL handle_netbios_aliases(const char *pszParmValue, char **ptr)
2662 {
2663 Globals.szNetbiosAliases = str_list_make(pszParmValue, NULL);
2664 return set_netbios_aliases((const char **)Globals.szNetbiosAliases);
2665 }
2666
2667 /***************************************************************************
2668 Do the work of sourcing in environment variable/value pairs.
2669 ***************************************************************************/
2670
2671 static BOOL source_env(char **lines)
2672 {
2673 char *varval;
2674 size_t len;
2675 int i;
2676 char *p;
2677
2678 for (i = 0; lines[i]; i++) {
2679 char *line = lines[i];
2680
2681 if ((len = strlen(line)) == 0)
2682 continue;
2683
2684 if (line[len - 1] == '\n')
2685 line[--len] = '\0';
2686
2687 if ((varval = malloc(len + 1)) == NULL) {
2688 DEBUG(0, ("source_env: Not enough memory!\n"));
2689 return (False);
2690 }
2691
2692 DEBUG(4, ("source_env: Adding to environment: %s\n", line));
2693 strncpy(varval, line, len);
2694 varval[len] = '\0';
2695
2696 p = strchr_m(line, (int)'=');
2697 if (p == NULL) {
2698 DEBUG(4, ("source_env: missing '=': %s\n", line));
2699 continue;
2700 }
2701
2702 if (putenv(varval)) {
2703 DEBUG(0, ("source_env: Failed to put environment variable %s\n",
2704 varval));
2705 continue;
2706 }
2707
2708 *p = '\0';
2709 p++;
2710 DEBUG(4, ("source_env: getting var %s = %s\n", line, getenv(line)));
2711 }
2712
2713 DEBUG(4, ("source_env: returning successfully\n"));
2714 return (True);
2715 }
2716
2717 /***************************************************************************
2718 Handle the source environment operation.
2719 ***************************************************************************/
2720
2721 static BOOL handle_source_env(const char *pszParmValue, char **ptr)
2722 {
2723 pstring fname;
2724 char *p = fname;
2725 BOOL result;
2726 char **lines;
2727
2728 pstrcpy(fname, pszParmValue);
2729
2730 standard_sub_basic(current_user_info.smb_name, fname,sizeof(fname));
2731
2732 string_set(ptr, pszParmValue);
2733
2734 DEBUG(4, ("handle_source_env: checking env type\n"));
2735
2736 /*
2737 * Filename starting with '|' means popen and read from stdin.
2738 */
2739
2740 if (*p == '|')
2741 lines = file_lines_pload(p + 1, NULL);
2742 else
2743 lines = file_lines_load(fname, NULL);
2744
2745 if (!lines) {
2746 DEBUG(0, ("handle_source_env: Failed to open file %s, Error was %s\n",
2747 fname, strerror(errno)));
2748 return (False);
2749 }
2750
2751 result = source_env(lines);
2752 file_lines_free(lines);
2753
2754 return (result);
2755 }
2756
2757 /***************************************************************************
2758 Handle the include operation.
2759 ***************************************************************************/
2760
2761 static BOOL handle_include(const char *pszParmValue, char **ptr)
2762 {
2763 pstring fname;
2764 pstrcpy(fname, pszParmValue);
2765
2766 standard_sub_basic(current_user_info.smb_name, fname,sizeof(fname));
2767
2768 add_to_file_list(pszParmValue, fname);
2769
2770 string_set(ptr, fname);
2771
2772 if (file_exist(fname, NULL))
2773 return (pm_process(fname, do_section, do_parameter));
2774
2775 DEBUG(2, ("Can't find include file %s\n", fname));
2776
2777 return (False);
2778 }
2779
2780 /***************************************************************************
2781 Handle the interpretation of the copy parameter.
2782 ***************************************************************************/
2783
2784 static BOOL handle_copy(const char *pszParmValue, char **ptr)
2785 {
2786 BOOL bRetval;
2787 int iTemp;
2788 service serviceTemp;
2789
2790 string_set(ptr, pszParmValue);
2791
2792 init_service(&serviceTemp);
2793
2794 bRetval = False;
2795
2796 DEBUG(3, ("Copying service from service %s\n", pszParmValue));
2797
2798 if ((iTemp = getservicebyname(pszParmValue, &serviceTemp)) >= 0) {
2799 if (iTemp == iServiceIndex) {
2800 DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
2801 } else {
2802 copy_service(ServicePtrs[iServiceIndex],
2803 &serviceTemp,
2804 ServicePtrs[iServiceIndex]->copymap);
2805 bRetval = True;
2806 }
2807 } else {
2808 DEBUG(0, ("Unable to copy service - source not found: %s\n", pszParmValue));
2809 bRetval = False;
2810 }
2811
2812 free_service(&serviceTemp);
2813 return (bRetval);
2814 }
2815
2816 /***************************************************************************
2817 Handle idmap/non unix account uid and gid allocation parameters. The format of these
2818 parameters is:
2819
2820 [global]
2821
2822 idmap uid = 1000-1999
2823 idmap gid = 700-899
2824
2825 We only do simple parsing checks here. The strings are parsed into useful
2826 structures in the idmap daemon code.
2827
2828 ***************************************************************************/
2829
2830 /* Some lp_ routines to return idmap [ug]id information */
2831
2832 static uid_t idmap_uid_low, idmap_uid_high;
2833 static gid_t idmap_gid_low, idmap_gid_high;
2834 static uint32 non_unix_account_low, non_unix_account_high;
2835
2836 BOOL lp_idmap_uid(uid_t *low, uid_t *high)
2837 {
2838 if (idmap_uid_low == 0 || idmap_uid_high == 0)
2839 return False;
2840
2841 if (low)
2842 *low = idmap_uid_low;
2843
2844 if (high)
2845 *high = idmap_uid_high;
2846
2847 return True;
2848 }
2849
2850 BOOL lp_idmap_gid(gid_t *low, gid_t *high)
2851 {
2852 if (idmap_gid_low == 0 || idmap_gid_high == 0)
2853 return False;
2854
2855 if (low)
2856 *low = idmap_gid_low;
2857
2858 if (high)
2859 *high = idmap_gid_high;
2860
2861 return True;
2862 }
2863
2864 BOOL lp_non_unix_account_range(uint32 *low, uint32 *high)
2865 {
2866 if (non_unix_account_low == 0 || non_unix_account_high == 0)
2867 return False;
2868
2869 if (low)
2870 *low = non_unix_account_low;
2871
2872 if (high)
2873 *high = non_unix_account_high;
2874
2875 return True;
2876 }
2877
2878 /* Do some simple checks on "idmap [ug]id" parameter values */
2879
2880 static BOOL handle_idmap_uid(const char *pszParmValue, char **ptr)
2881 {
2882 uint32 low, high;
2883
2884 if (sscanf(pszParmValue, "%u-%u", &low, &high) != 2 || high < low)
2885 return False;
2886
2887 /* Parse OK */
2888
2889 string_set(ptr, pszParmValue);
2890
2891 idmap_uid_low = low;
2892 idmap_uid_high = high;
2893
2894 return True;
2895 }
2896
2897 static BOOL handle_idmap_gid(const char *pszParmValue, char **ptr)
2898 {
2899 uint32 low, high;
2900
2901 if (sscanf(pszParmValue, "%u-%u", &low, &high) != 2 || high < low)
2902 return False;
2903
2904 /* Parse OK */
2905
2906 string_set(ptr, pszParmValue);
2907
2908 idmap_gid_low = low;
2909 idmap_gid_high = high;
2910
2911 return True;
2912 }
2913
2914 /***************************************************************************
2915 Do some simple checks on "non unix account range" parameter values.
2916 ***************************************************************************/
2917
2918 static BOOL handle_non_unix_account_range(const char *pszParmValue, char **ptr)
2919 {
2920 uint32 low, high;
2921
2922 if (sscanf(pszParmValue, "%u-%u", &low, &high) != 2 || high < low)
2923 return False;
2924
2925 /* Parse OK */
2926
2927 string_set(ptr, pszParmValue);
2928
2929 non_unix_account_low = low;
2930 non_unix_account_high = high;
2931
2932 return True;
2933 }
2934
2935 /***************************************************************************
2936 Handle the DEBUG level list.
2937 ***************************************************************************/
2938
2939 static BOOL handle_debug_list( const char *pszParmValueIn, char **ptr )
2940 {
2941 pstring pszParmValue;
2942
2943 pstrcpy(pszParmValue, pszParmValueIn);
2944 string_set(ptr, pszParmValueIn);
2945 return debug_parse_levels( pszParmValue );
2946 }
2947
2948 /***************************************************************************
2949 Handle the ldap machine suffix option.
2950 ***************************************************************************/
2951
2952 static BOOL handle_ldap_machine_suffix( const char *pszParmValue, char **ptr)
2953 {
2954 pstring suffix;
2955
2956 pstrcpy(suffix, pszParmValue);
2957
2958 if (! *Globals.szLdapSuffix ) {
2959 string_set( ptr, suffix );
2960 return True;
2961 }
2962
2963 if (! strstr(suffix, Globals.szLdapSuffix) ) {
2964 if ( *pszParmValue )
2965 pstrcat(suffix, ",");
2966 pstrcat(suffix, Globals.szLdapSuffix);
2967 }
2968 string_set( ptr, suffix );
2969 return True;
2970 }
2971
2972 /***************************************************************************
2973 Handle the ldap user suffix option.
2974 ***************************************************************************/
2975
2976 static BOOL handle_ldap_user_suffix( const char *pszParmValue, char **ptr)
2977 {
2978 pstring suffix;
2979
2980 pstrcpy(suffix, pszParmValue);
2981
2982 if (! *Globals.szLdapSuffix ) {
2983 string_set( ptr, suffix );
2984 return True;
2985 }
2986
2987 if (! strstr(suffix, Globals.szLdapSuffix) ) {
2988 if ( *pszParmValue )
2989 pstrcat(suffix, ",");
2990 pstrcat(suffix, Globals.szLdapSuffix);
2991 }
2992 string_set( ptr, suffix );
2993 return True;
2994 }
2995
2996 /***************************************************************************
2997 Handle setting ldap suffix and determines whether ldap machine suffix needs
2998 to be set as well.
2999 ***************************************************************************/
3000
3001 static BOOL handle_ldap_suffix( const char *pszParmValue, char **ptr)
3002 {
3003 pstring suffix;
3004 pstring user_suffix;
3005 pstring machine_suffix;
3006
3007 pstrcpy(suffix, pszParmValue);
3008
3009 if (! *Globals.szLdapMachineSuffix )
3010 string_set(&Globals.szLdapMachineSuffix, suffix);
3011 if (! *Globals.szLdapUserSuffix )
3012 string_set(&Globals.szLdapUserSuffix, suffix);
3013
3014 if (! strstr(Globals.szLdapMachineSuffix, suffix)) {
3015 pstrcpy(machine_suffix, Globals.szLdapMachineSuffix);
3016 if ( *Globals.szLdapMachineSuffix )
3017 pstrcat(machine_suffix, ",");
3018 pstrcat(machine_suffix, suffix);
3019 string_set(&Globals.szLdapMachineSuffix, machine_suffix);
3020 }
3021
3022 if (! strstr(Globals.szLdapUserSuffix, suffix)) {
3023 pstrcpy(user_suffix, Globals.szLdapUserSuffix);
3024 if ( *Globals.szLdapUserSuffix )
3025 pstrcat(user_suffix, ",");
3026 pstrcat(user_suffix, suffix);
3027 string_set(&Globals.szLdapUserSuffix, user_suffix);
3028 }
3029
3030 string_set(ptr, suffix);
3031 return True;
3032 }
3033
3034 static BOOL handle_acl_compatibility(const char *pszParmValue, char **ptr)
3035 {
3036 if (strequal(pszParmValue, "auto"))
3037 string_set(ptr, "");
3038 else if (strequal(pszParmValue, "winnt"))
3039 string_set(ptr, "winnt");
3040 else if (strequal(pszParmValue, "win2k"))
3041 string_set(ptr, "win2k");
3042 else
3043 return False;
3044
3045 return True;
3046 }
3047 /***************************************************************************
3048 Initialise a copymap.
3049 ***************************************************************************/
3050
3051 static void init_copymap(service * pservice)
3052 {
3053 int i;
3054 SAFE_FREE(pservice->copymap);
3055 pservice->copymap = (BOOL *)malloc(sizeof(BOOL) * NUMPARAMETERS);
3056 if (!pservice->copymap)
3057 DEBUG(0,
3058 ("Couldn't allocate copymap!! (size %d)\n",
3059 (int)NUMPARAMETERS));
3060 else
3061 for (i = 0; i < NUMPARAMETERS; i++)
3062 pservice->copymap[i] = True;
3063 }
3064
3065 /***************************************************************************
3066 Return the local pointer to a parameter given the service number and the
3067 pointer into the default structure.
3068 ***************************************************************************/
3069
3070 void *lp_local_ptr(int snum, void *ptr)
3071 {
3072 return (void *)(((char *)ServicePtrs[snum]) + PTR_DIFF(ptr, &sDefault));
3073 }
3074
3075 /***************************************************************************
3076 Process a parameter for a particular service number. If snum < 0
3077 then assume we are in the globals.
3078 ***************************************************************************/
3079
3080 BOOL lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
3081 {
3082 int parmnum, i, slen;
3083 void *parm_ptr = NULL; /* where we are going to store the result */
3084 void *def_ptr = NULL;
3085 pstring vfskey;
3086 char *sep;
3087 param_opt_struct *paramo, *data;
3088 BOOL not_added;
3089
3090 parmnum = map_parameter(pszParmName);
3091
3092 if (parmnum < 0) {
3093 if ((sep=strchr(pszParmName, ':')) != NULL) {
3094 *sep = 0;
3095 ZERO_STRUCT(vfskey);
3096 pstr_sprintf(vfskey, "%s:", pszParmName);
3097 slen = strlen(vfskey);
3098 pstrcat(vfskey, sep+1);
3099 trim_string(vfskey+slen, " ", " ");
3100 not_added = True;
3101 data = (snum < 0) ? Globals.param_opt :
3102 ServicePtrs[snum]->param_opt;
3103 /* Traverse destination */
3104 while (data) {
3105 /* If we already have same option, override it */
3106 if (strcmp(data->key, vfskey) == 0) {
3107 string_free(&data->value);
3108 data->value = strdup(pszParmValue);
3109 not_added = False;
3110 break;
3111 }
3112 data = data->next;
3113 }
3114 if (not_added) {
3115 paramo = smb_xmalloc(sizeof(param_opt_struct));
3116 paramo->key = strdup(vfskey);
3117 paramo->value = strdup(pszParmValue);
3118 if (snum < 0) {
3119 DLIST_ADD(Globals.param_opt, paramo);
3120 } else {
3121 DLIST_ADD(ServicePtrs[snum]->param_opt, paramo);
3122 }
3123 }
3124
3125 *sep = ':';
3126 return (True);
3127 }
3128 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
3129 return (True);
3130 }
3131
3132 if (parm_table[parmnum].flags & FLAG_DEPRECATED) {
3133 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
3134 pszParmName));
3135 }
3136
3137 def_ptr = parm_table[parmnum].ptr;
3138
3139 /* we might point at a service, the default service or a global */
3140 if (snum < 0) {
3141 parm_ptr = def_ptr;
3142 } else {
3143 if (parm_table[parmnum].class == P_GLOBAL) {
3144 DEBUG(0,
3145 ("Global parameter %s found in service section!\n",
3146 pszParmName));
3147 return (True);
3148 }
3149 parm_ptr =
3150 ((char *)ServicePtrs[snum]) + PTR_DIFF(def_ptr,
3151 &sDefault);
3152 }
3153
3154 if (snum >= 0) {
3155 if (!ServicePtrs[snum]->copymap)
3156 init_copymap(ServicePtrs[snum]);
3157
3158 /* this handles the aliases - set the copymap for other entries with
3159 the same data pointer */
3160 for (i = 0; parm_table[i].label; i++)
3161 if (parm_table[i].ptr == parm_table[parmnum].ptr)
3162 ServicePtrs[snum]->copymap[i] = False;
3163 }
3164
3165 /* if it is a special case then go ahead */
3166 if (parm_table[parmnum].special) {
3167 parm_table[parmnum].special(pszParmValue, (char **)parm_ptr);
3168 return (True);
3169 }
3170
3171 /* now switch on the type of variable it is */
3172 switch (parm_table[parmnum].type)
3173 {
3174 case P_BOOL:
3175 set_boolean(parm_ptr, pszParmValue);
3176 break;
3177
3178 case P_BOOLREV:
3179 set_boolean(parm_ptr, pszParmValue);
3180 *(BOOL *)parm_ptr = !*(BOOL *)parm_ptr;
3181 break;
3182
3183 case P_INTEGER:
3184 *(int *)parm_ptr = atoi(pszParmValue);
3185 break;
3186
3187 case P_CHAR:
3188 *(char *)parm_ptr = *pszParmValue;
3189 break;
3190
3191 case P_OCTAL:
3192 sscanf(pszParmValue, "%o", (int *)parm_ptr);
3193 break;
3194
3195 case P_LIST:
3196 str_list_free(parm_ptr);
3197 *(char ***)parm_ptr = str_list_make(pszParmValue, NULL);
3198 break;
3199
3200 case P_STRING:
3201 string_set(parm_ptr, pszParmValue);
3202 break;
3203
3204 case P_USTRING:
3205 string_set(parm_ptr, pszParmValue);
3206 strupper(*(char **)parm_ptr);
3207 break;
3208
3209 case P_GSTRING:
3210 pstrcpy((char *)parm_ptr, pszParmValue);
3211 break;
3212
3213 case P_UGSTRING:
3214 pstrcpy((char *)parm_ptr, pszParmValue);
3215 strupper((char *)parm_ptr);
3216 break;
3217
3218 case P_ENUM:
3219 for (i = 0; parm_table[parmnum].enum_list[i].name; i++) {
3220 if (strequal
3221 (pszParmValue,
3222 parm_table[parmnum].enum_list[i].name)) {
3223 *(int *)parm_ptr =
3224 parm_table[parmnum].
3225 enum_list[i].value;
3226 break;
3227 }
3228 }
3229 break;
3230 case P_SEP:
3231 break;
3232 }
3233
3234 return (True);
3235 }
3236
3237 /***************************************************************************
3238 Process a parameter.
3239 ***************************************************************************/
3240
3241 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue)
3242 {
3243 if (!bInGlobalSection && bGlobalOnly)
3244 return (True);
3245
3246 DEBUGADD(4, ("doing parameter %s = %s\n", pszParmName, pszParmValue));
3247
3248 return (lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
3249 pszParmName, pszParmValue));
3250 }
3251
3252 /***************************************************************************
3253 Print a parameter of the specified type.
3254 ***************************************************************************/
3255
3256 static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
3257 {
3258 int i;
3259 switch (p->type)
3260 {
3261 case P_ENUM:
3262 for (i = 0; p->enum_list[i].name; i++) {
3263 if (*(int *)ptr == p->enum_list[i].value) {
3264 fprintf(f, "%s",
3265 p->enum_list[i].name);
3266 break;
3267 }
3268 }
3269 break;
3270
3271 case P_BOOL:
3272 fprintf(f, "%s", BOOLSTR(*(BOOL *)ptr));
3273 break;
3274
3275 case P_BOOLREV:
3276 fprintf(f, "%s", BOOLSTR(!*(BOOL *)ptr));
3277 break;
3278
3279 case P_INTEGER:
3280 fprintf(f, "%d", *(int *)ptr);
3281 break;
3282
3283 case P_CHAR:
3284 fprintf(f, "%c", *(char *)ptr);
3285 break;
3286
3287 case P_OCTAL:
3288 fprintf(f, "%s", octal_string(*(int *)ptr));
3289 break;
3290
3291 case P_LIST:
3292 if ((char ***)ptr && *(char ***)ptr) {
3293 char **list = *(char ***)ptr;
3294
3295 for (; *list; list++)
3296 fprintf(f, "%s%s", *list,
3297 ((*(list+1))?", ":""));
3298 }
3299 break;
3300
3301 case P_GSTRING:
3302 case P_UGSTRING:
3303 if ((char *)ptr) {
3304 fprintf(f, "%s", (char *)ptr);
3305 }
3306 break;
3307
3308 case P_STRING:
3309 case P_USTRING:
3310 if (*(char **)ptr) {
3311 fprintf(f, "%s", *(char **)ptr);
3312 }
3313 break;
3314 case P_SEP:
3315 break;
3316 }
3317 }
3318
3319 /***************************************************************************
3320 Check if two parameters are equal.
3321 ***************************************************************************/
3322
3323 static BOOL equal_parameter(parm_type type, void *ptr1, void *ptr2)
3324 {
3325 switch (type) {
3326 case P_BOOL:
3327 case P_BOOLREV:
3328 return (*((BOOL *)ptr1) == *((BOOL *)ptr2));
3329
3330 case P_INTEGER:
3331 case P_ENUM:
3332 case P_OCTAL:
3333 return (*((int *)ptr1) == *((int *)ptr2));
3334
3335 case P_CHAR:
3336 return (*((char *)ptr1) == *((char *)ptr2));
3337
3338 case P_LIST:
3339 return str_list_compare(*(char ***)ptr1, *(char ***)ptr2);
3340
3341 case P_GSTRING:
3342 case P_UGSTRING:
3343 {
3344 char *p1 = (char *)ptr1, *p2 = (char *)ptr2;
3345 if (p1 && !*p1)
3346 p1 = NULL;
3347 if (p2 && !*p2)
3348 p2 = NULL;
3349 return (p1 == p2 || strequal(p1, p2));
3350 }
3351 case P_STRING:
3352 case P_USTRING:
3353 {
3354 char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
3355 if (p1 && !*p1)
3356 p1 = NULL;
3357 if (p2 && !*p2)
3358 p2 = NULL;
3359 return (p1 == p2 || strequal(p1, p2));
3360 }
3361 case P_SEP:
3362 break;
3363 }
3364 return (False);
3365 }
3366
3367 /***************************************************************************
3368 Initialize any local varients in the sDefault table.
3369 ***************************************************************************/
3370
3371 void init_locals(void)
3372 {
3373 /* None as yet. */
3374 }
3375
3376 /***************************************************************************
3377 Process a new section (service). At this stage all sections are services.
3378 Later we'll have special sections that permit server parameters to be set.
3379 Returns True on success, False on failure.
3380 ***************************************************************************/
3381
3382 static BOOL do_section(const char *pszSectionName)
3383 {
3384 BOOL bRetval;
3385 BOOL isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
3386 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
3387 bRetval = False;
3388
3389 /* if we were in a global section then do the local inits */
3390 if (bInGlobalSection && !isglobal)
3391 init_locals();
3392
3393 /* if we've just struck a global section, note the fact. */
3394 bInGlobalSection = isglobal;
3395
3396 /* check for multiple global sections */
3397 if (bInGlobalSection) {
3398 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
3399 return (True);
3400 }
3401
3402 if (!bInGlobalSection && bGlobalOnly)
3403 return (True);
3404
3405 /* if we have a current service, tidy it up before moving on */
3406 bRetval = True;
3407
3408 if (iServiceIndex >= 0)
3409 bRetval = service_ok(iServiceIndex);
3410
3411 /* if all is still well, move to the next record in the services array */
3412 if (bRetval) {
3413 /* We put this here to avoid an odd message order if messages are */
3414 /* issued by the post-processing of a previous section. */
3415 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
3416
3417 if ((iServiceIndex = add_a_service(&sDefault, pszSectionName))
3418 < 0) {
3419 DEBUG(0, ("Failed to add a new service\n"));
3420 return (False);
3421 }
3422 }
3423
3424 return (bRetval);
3425 }
3426
3427
3428 /***************************************************************************
3429 Determine if a partcular base parameter is currentl set to the default value.
3430 ***************************************************************************/
3431
3432 static BOOL is_default(int i)
3433 {
3434 if (!defaults_saved)
3435 return False;
3436 switch (parm_table[i].type) {
3437 case P_LIST:
3438 return str_list_compare (parm_table[i].def.lvalue,
3439 *(char ***)parm_table[i].ptr);
3440 case P_STRING:
3441 case P_USTRING:
3442 return strequal(parm_table[i].def.svalue,
3443 *(char **)parm_table[i].ptr);
3444 case P_GSTRING:
3445 case P_UGSTRING:
3446 return strequal(parm_table[i].def.svalue,
3447 (char *)parm_table[i].ptr);
3448 case P_BOOL:
3449 case P_BOOLREV:
3450 return parm_table[i].def.bvalue ==
3451 *(BOOL *)parm_table[i].ptr;
3452 case P_CHAR:
3453 return parm_table[i].def.cvalue ==
3454 *(char *)parm_table[i].ptr;
3455 case P_INTEGER:
3456 case P_OCTAL:
3457 case P_ENUM:
3458 return parm_table[i].def.ivalue ==
3459 *(int *)parm_table[i].ptr;
3460 case P_SEP:
3461 break;
3462 }
3463 return False;
3464 }
3465
3466 /***************************************************************************
3467 Display the contents of the global structure.
3468 ***************************************************************************/
3469
3470 static void dump_globals(FILE *f)
3471 {
3472 int i;
3473 param_opt_struct *data;
3474
3475 fprintf(f, "# Global parameters\n[global]\n");
3476
3477 for (i = 0; parm_table[i].label; i++)
3478 if (parm_table[i].class == P_GLOBAL &&
3479 parm_table[i].ptr &&
3480 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
3481 if (defaults_saved && is_default(i))
3482 continue;
3483 fprintf(f, "\t%s = ", parm_table[i].label);
3484 print_parameter(&parm_table[i], parm_table[i].ptr, f);
3485 fprintf(f, "\n");
3486 }
3487 if (Globals.param_opt != NULL) {
3488 data = Globals.param_opt;
3489 while(data) {
3490 fprintf(f, "\t%s = %s\n", data->key, data->value);
3491 data = data->next;
3492 }
3493 }
3494
3495 }
3496
3497 /***************************************************************************
3498 Return True if a local parameter is currently set to the global default.
3499 ***************************************************************************/
3500
3501 BOOL lp_is_default(int snum, struct parm_struct *parm)
3502 {
3503 int pdiff = PTR_DIFF(parm->ptr, &sDefault);
3504
3505 return equal_parameter(parm->type,
3506 ((char *)ServicePtrs[snum]) + pdiff,
3507 ((char *)&sDefault) + pdiff);
3508 }
3509
3510 /***************************************************************************
3511 Display the contents of a single services record.
3512 ***************************************************************************/
3513
3514 static void dump_a_service(service * pService, FILE * f)
3515 {
3516 int i;
3517 param_opt_struct *data;
3518
3519 if (pService != &sDefault)
3520 fprintf(f, "\n[%s]\n", pService->szService);
3521
3522 for (i = 0; parm_table[i].label; i++)
3523 if (parm_table[i].class == P_LOCAL &&
3524 parm_table[i].ptr &&
3525 (*parm_table[i].label != '-') &&
3526 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
3527 int pdiff = PTR_DIFF(parm_table[i].ptr, &sDefault);
3528
3529 if (pService == &sDefault) {
3530 if (defaults_saved && is_default(i))
3531 continue;
3532 } else {
3533 if (equal_parameter(parm_table[i].type,
3534 ((char *)pService) +
3535 pdiff,
3536 ((char *)&sDefault) +
3537 pdiff))
3538 continue;
3539 }
3540
3541 fprintf(f, "\t%s = ", parm_table[i].label);
3542 print_parameter(&parm_table[i],
3543 ((char *)pService) + pdiff, f);
3544 fprintf(f, "\n");
3545 }
3546 if (pService->param_opt != NULL) {
3547 data = pService->param_opt;
3548 while(data) {
3549 fprintf(f, "\t%s = %s\n", data->key, data->value);
3550 data = data->next;
3551 }
3552 }
3553 }
3554
3555
3556 /***************************************************************************
3557 Return info about the next service in a service. snum==-1 gives the globals.
3558 Return NULL when out of parameters.
3559 ***************************************************************************/
3560
3561 struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters)
3562 {
3563 if (snum == -1) {
3564 /* do the globals */
3565 for (; parm_table[*i].label; (*i)++) {
3566 if (parm_table[*i].class == P_SEPARATOR)
3567 return &parm_table[(*i)++];
3568
3569 if (!parm_table[*i].ptr
3570 || (*parm_table[*i].label == '-'))
3571 continue;
3572
3573 if ((*i) > 0
3574 && (parm_table[*i].ptr ==
3575 parm_table[(*i) - 1].ptr))
3576 continue;
3577
3578 return &parm_table[(*i)++];
3579 }
3580 } else {
3581 service *pService = ServicePtrs[snum];
3582
3583 for (; parm_table[*i].label; (*i)++) {
3584 if (parm_table[*i].class == P_SEPARATOR)
3585 return &parm_table[(*i)++];
3586
3587 if (parm_table[*i].class == P_LOCAL &&
3588 parm_table[*i].ptr &&
3589 (*parm_table[*i].label != '-') &&
3590 ((*i) == 0 ||
3591 (parm_table[*i].ptr !=
3592 parm_table[(*i) - 1].ptr)))
3593 {
3594 int pdiff =
3595 PTR_DIFF(parm_table[*i].ptr,
3596 &sDefault);
3597
3598 if (allparameters ||
3599 !equal_parameter(parm_table[*i].type,
3600 ((char *)pService) +
3601 pdiff,
3602 ((char *)&sDefault) +
3603 pdiff))
3604 {
3605 return &parm_table[(*i)++];
3606 }
3607 }
3608 }
3609 }
3610
3611 return NULL;
3612 }
3613
3614
3615 #if 0
3616 /***************************************************************************
3617 Display the contents of a single copy structure.
3618 ***************************************************************************/
3619 static void dump_copy_map(BOOL *pcopymap)
3620 {
3621 int i;
3622 if (!pcopymap)
3623 return;
3624
3625 printf("\n\tNon-Copied parameters:\n");
3626
3627 for (i = 0; parm_table[i].label; i++)
3628 if (parm_table[i].class == P_LOCAL &&
3629 parm_table[i].ptr && !pcopymap[i] &&
3630 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr)))
3631 {
3632 printf("\t\t%s\n", parm_table[i].label);
3633 }
3634 }
3635 #endif
3636
3637 /***************************************************************************
3638 Return TRUE if the passed service number is within range.
3639 ***************************************************************************/
3640
3641 BOOL lp_snum_ok(int iService)
3642 {
3643 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
3644 }
3645
3646 /***************************************************************************
3647 Auto-load some home services.
3648 ***************************************************************************/
3649
3650 static void lp_add_auto_services(char *str)
3651 {
3652 char *s;
3653 char *p;
3654 int homes;
3655
3656 if (!str)
3657 return;
3658
3659 s = strdup(str);
3660 if (!s)
3661 return;
3662
3663 homes = lp_servicenumber(HOMES_NAME);
3664
3665 for (p = strtok(s, LIST_SEP); p; p = strtok(NULL, LIST_SEP)) {
3666 char *home = get_user_home_dir(p);
3667
3668 if (lp_servicenumber(p) >= 0)
3669 continue;
3670
3671 if (home && homes >= 0)
3672 lp_add_home(p, homes, p, home);
3673 }
3674 SAFE_FREE(s);
3675 }
3676
3677 /***************************************************************************
3678 Auto-load one printer.
3679 ***************************************************************************/
3680
3681 void lp_add_one_printer(char *name, char *comment)
3682 {
3683 int printers = lp_servicenumber(PRINTERS_NAME);
3684 int i;
3685
3686 if (lp_servicenumber(name) < 0) {
3687 lp_add_printer(name, printers);
3688 if ((i = lp_servicenumber(name)) >= 0) {
3689 string_set(&ServicePtrs[i]->comment, comment);
3690 ServicePtrs[i]->autoloaded = True;
3691 }
3692 }
3693 }
3694
3695 /***************************************************************************
3696 Announce ourselves as a print server.
3697 ***************************************************************************/
3698
3699 void update_server_announce_as_printserver(void)
3700 {
3701 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
3702 }
3703
3704 /***************************************************************************
3705 Have we loaded a services file yet?
3706 ***************************************************************************/
3707
3708 BOOL lp_loaded(void)
3709 {
3710 return (bLoaded);
3711 }
3712
3713 /***************************************************************************
3714 Unload unused services.
3715 ***************************************************************************/
3716
3717 void lp_killunused(BOOL (*snumused) (int))
3718 {
3719 int i;
3720 for (i = 0; i < iNumServices; i++) {
3721 if (!VALID(i))
3722 continue;
3723
3724 if (!snumused || !snumused(i)) {
3725 ServicePtrs[i]->valid = False;
3726 free_service(ServicePtrs[i]);
3727 }
3728 }
3729 }
3730
3731 /***************************************************************************
3732 Unload a service.
3733 ***************************************************************************/
3734
3735 void lp_killservice(int iServiceIn)
3736 {
3737 if (VALID(iServiceIn)) {
3738 ServicePtrs[iServiceIn]->valid = False;
3739 free_service(ServicePtrs[iServiceIn]);
3740 }
3741 }
3742
3743 /***************************************************************************
3744 Save the curent values of all global and sDefault parameters into the
3745 defaults union. This allows swat and testparm to show only the
3746 changed (ie. non-default) parameters.
3747 ***************************************************************************/
3748
3749 static void lp_save_defaults(void)
3750 {
3751 int i;
3752 for (i = 0; parm_table[i].label; i++) {
3753 if (i > 0 && parm_table[i].ptr == parm_table[i - 1].ptr)
3754 continue;
3755 switch (parm_table[i].type) {
3756 case P_LIST:
3757 str_list_copy(&(parm_table[i].def.lvalue),
3758 *(const char ***)parm_table[i].ptr);
3759 break;
3760 case P_STRING:
3761 case P_USTRING:
3762 if (parm_table[i].ptr) {
3763 parm_table[i].def.svalue = strdup(*(char **)parm_table[i].ptr);
3764 } else {
3765 parm_table[i].def.svalue = NULL;
3766 }
3767 break;
3768 case P_GSTRING:
3769 case P_UGSTRING:
3770 if (parm_table[i].ptr) {
3771 parm_table[i].def.svalue = strdup((char *)parm_table[i].ptr);
3772 } else {
3773 parm_table[i].def.svalue = NULL;
3774 }
3775 break;
3776 case P_BOOL:
3777 case P_BOOLREV:
3778 parm_table[i].def.bvalue =
3779 *(BOOL *)parm_table[i].ptr;
3780 break;
3781 case P_CHAR:
3782 parm_table[i].def.cvalue =
3783 *(char *)parm_table[i].ptr;
3784 break;
3785 case P_INTEGER:
3786 case P_OCTAL:
3787 case P_ENUM:
3788 parm_table[i].def.ivalue =
3789 *(int *)parm_table[i].ptr;
3790 break;
3791 case P_SEP:
3792 break;
3793 }
3794 }
3795 defaults_saved = True;
3796 }
3797
3798 /*******************************************************************
3799 Set the server type we will announce as via nmbd.
3800 ********************************************************************/
3801
3802 static void set_server_role(void)
3803 {
3804 server_role = ROLE_STANDALONE;
3805
3806 switch (lp_security()) {
3807 case SEC_SHARE:
3808 if (lp_domain_logons())
3809 DEBUG(0, ("Server's Role (logon server) conflicts with share-level security\n"));
3810 break;
3811 case SEC_SERVER:
3812 if (lp_domain_logons())
3813 DEBUG(0, ("Server's Role (logon server) conflicts with server-level security\n"));
3814 server_role = ROLE_DOMAIN_MEMBER;
3815 break;
3816 case SEC_DOMAIN:
3817 if (lp_domain_logons()) {
3818 DEBUG(1, ("Server's Role (logon server) NOT ADVISED with domain-level security\n"));
3819 server_role = ROLE_DOMAIN_BDC;
3820 break;
3821 }
3822 server_role = ROLE_DOMAIN_MEMBER;
3823 break;
3824 case SEC_ADS:
3825 if (lp_domain_logons()) {
3826 server_role = ROLE_DOMAIN_PDC;
3827 break;
3828 }
3829 server_role = ROLE_DOMAIN_MEMBER;
3830 break;
3831 case SEC_USER:
3832 if (lp_domain_logons()) {
3833
3834 if (Globals.bDomainMaster) /* auto or yes */
3835 server_role = ROLE_DOMAIN_PDC;
3836 else
3837 server_role = ROLE_DOMAIN_BDC;
3838 }
3839 break;
3840 default:
3841 DEBUG(0, ("Server's Role undefined due to unknown security mode\n"));
3842 break;
3843 }
3844
3845 DEBUG(10, ("set_server_role: role = "));
3846
3847 switch(server_role) {
3848 case ROLE_STANDALONE:
3849 DEBUGADD(10, ("ROLE_STANDALONE\n"));
3850 break;
3851 case ROLE_DOMAIN_MEMBER:
3852 DEBUGADD(10, ("ROLE_DOMAIN_MEMBER\n"));
3853 break;
3854 case ROLE_DOMAIN_BDC:
3855 DEBUGADD(10, ("ROLE_DOMAIN_BDC\n"));
3856 break;
3857 case ROLE_DOMAIN_PDC:
3858 DEBUGADD(10, ("ROLE_DOMAIN_PDC\n"));
3859 break;
3860 }
3861 }
3862
3863 /***************************************************************************
3864 Load the services array from the services file. Return True on success,
3865 False on failure.
3866 ***************************************************************************/
3867
3868 BOOL lp_load(const char *pszFname, BOOL global_only, BOOL save_defaults,
3869 BOOL add_ipc)
3870 {
3871 pstring n2;
3872 BOOL bRetval;
3873 param_opt_struct *data, *pdata;
3874
3875 pstrcpy(n2, pszFname);
3876 standard_sub_basic(current_user_info.smb_name, n2,sizeof(n2));
3877
3878 add_to_file_list(pszFname, n2);
3879
3880 bRetval = False;
3881
3882 DEBUG(3, ("lp_load: refreshing parameters\n"));
3883
3884 bInGlobalSection = True;
3885 bGlobalOnly = global_only;
3886
3887 init_globals();
3888 debug_init();
3889
3890 if (save_defaults)
3891 {
3892 init_locals();
3893 lp_save_defaults();
3894 }
3895
3896 if (Globals.param_opt != NULL) {
3897 data = Globals.param_opt;
3898 while (data) {
3899 string_free(&data->key);
3900 string_free(&data->value);
3901 pdata = data->next;
3902 SAFE_FREE(data);
3903 data = pdata;
3904 }
3905 Globals.param_opt = NULL;
3906 }
3907
3908 /* We get sections first, so have to start 'behind' to make up */
3909 iServiceIndex = -1;
3910 bRetval = pm_process(n2, do_section, do_parameter);
3911
3912 /* finish up the last section */
3913 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
3914 if (bRetval)
3915 if (iServiceIndex >= 0)
3916 bRetval = service_ok(iServiceIndex);
3917
3918 lp_add_auto_services(lp_auto_services());
3919
3920 if (add_ipc) {
3921 /* When 'restrict anonymous = 2' guest connections to ipc$
3922 are denied */
3923 lp_add_ipc("IPC$", (lp_restrict_anonymous() < 2));
3924 lp_add_ipc("ADMIN$", False);
3925 }
3926
3927 set_server_role();
3928 set_default_server_announce_type();
3929
3930 bLoaded = True;
3931
3932 /* Now we check bWINSsupport and set szWINSserver to 127.0.0.1 */
3933 /* if bWINSsupport is true and we are in the client */
3934 if (in_client && Globals.bWINSsupport) {
3935 lp_do_parameter(-1, "wins server", "127.0.0.1");
3936 }
3937
3938 init_iconv();
3939
3940 return (bRetval);
3941 }
3942
3943 /***************************************************************************
3944 Reset the max number of services.
3945 ***************************************************************************/
3946
3947 void lp_resetnumservices(void)
3948 {
3949 iNumServices = 0;
3950 }
3951
3952 /***************************************************************************
3953 Return the max number of services.
3954 ***************************************************************************/
3955
3956 int lp_numservices(void)
3957 {
3958 return (iNumServices);
3959 }
3960
3961 /***************************************************************************
3962 Display the contents of the services array in human-readable form.
3963 ***************************************************************************/
3964
3965 void lp_dump(FILE *f, BOOL show_defaults, int maxtoprint)
3966 {
3967 int iService;
3968
3969 if (show_defaults)
3970 defaults_saved = False;
3971
3972 dump_globals(f);
3973
3974 dump_a_service(&sDefault, f);
3975
3976 for (iService = 0; iService < maxtoprint; iService++)
3977 lp_dump_one(f, show_defaults, iService);
3978 }
3979
3980 /***************************************************************************
3981 Display the contents of one service in human-readable form.
3982 ***************************************************************************/
3983
3984 void lp_dump_one(FILE * f, BOOL show_defaults, int snum)
3985 {
3986 if (VALID(snum)) {
3987 if (ServicePtrs[snum]->szService[0] == '\0')
3988 return;
3989 dump_a_service(ServicePtrs[snum], f);
3990 }
3991 }
3992
3993 /***************************************************************************
3994 Return the number of the service with the given name, or -1 if it doesn't
3995 exist. Note that this is a DIFFERENT ANIMAL from the internal function
3996 getservicebyname()! This works ONLY if all services have been loaded, and
3997 does not copy the found service.
3998 ***************************************************************************/
3999
4000 int lp_servicenumber(const char *pszServiceName)
4001 {
4002 int iService;
4003 fstring serviceName;
4004
4005
4006 for (iService = iNumServices - 1; iService >= 0; iService--) {
4007 if (VALID(iService) && ServicePtrs[iService]->szService) {
4008 /*
4009 * The substitution here is used to support %U is
4010 * service names
4011 */
4012 fstrcpy(serviceName, ServicePtrs[iService]->szService);
4013 standard_sub_basic(current_user_info.smb_name, serviceName,sizeof(serviceName));
4014 if (strequal(serviceName, pszServiceName))
4015 break;
4016 }
4017 }
4018
4019 if (iService < 0)
4020 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
4021
4022 return (iService);
4023 }
4024
4025 /*******************************************************************
4026 A useful volume label function.
4027 ********************************************************************/
4028
4029 char *volume_label(int snum)
4030 {
4031 char *ret = lp_volume(snum);
4032 if (!*ret)
4033 return lp_servicename(snum);
4034 return (ret);
4035 }
4036
4037
4038 /*******************************************************************
4039 Set the server type we will announce as via nmbd.
4040 ********************************************************************/
4041
4042 static void set_default_server_announce_type(void)
4043 {
4044 default_server_announce = 0;
4045 default_server_announce |= SV_TYPE_WORKSTATION;
4046 default_server_announce |= SV_TYPE_SERVER;
4047 default_server_announce |= SV_TYPE_SERVER_UNIX;
4048
4049 switch (lp_announce_as()) {
4050 case ANNOUNCE_AS_NT_SERVER:
4051 default_server_announce |= SV_TYPE_SERVER_NT;
4052 /* fall through... */
4053 case ANNOUNCE_AS_NT_WORKSTATION:
4054 default_server_announce |= SV_TYPE_NT;
4055 break;
4056 case ANNOUNCE_AS_WIN95:
4057 default_server_announce |= SV_TYPE_WIN95_PLUS;
4058 break;
4059 case ANNOUNCE_AS_WFW:
4060 default_server_announce |= SV_TYPE_WFW;
4061 break;
4062 default:
4063 break;
4064 }
4065
4066 switch (lp_server_role()) {
4067 case ROLE_DOMAIN_MEMBER:
4068 default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
4069 break;
4070 case ROLE_DOMAIN_PDC:
4071 default_server_announce |= SV_TYPE_DOMAIN_CTRL;
4072 break;
4073 case ROLE_DOMAIN_BDC:
4074 default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
4075 break;
4076 case ROLE_STANDALONE:
4077 default:
4078 break;
4079 }
4080 if (lp_time_server())
4081 default_server_announce |= SV_TYPE_TIME_SOURCE;
4082
4083 if (lp_host_msdfs())
4084 default_server_announce |= SV_TYPE_DFS_SERVER;
4085 }
4086
4087 /***********************************************************
4088 returns role of Samba server
4089 ************************************************************/
4090
4091 int lp_server_role(void)
4092 {
4093 return server_role;
4094 }
4095
4096 /***********************************************************
4097 If we are PDC then prefer us as DMB
4098 ************************************************************/
4099
4100 BOOL lp_domain_master(void)
4101 {
4102 if (Globals.bDomainMaster == Auto)
4103 return (lp_server_role() == ROLE_DOMAIN_PDC);
4104
4105 return Globals.bDomainMaster;
4106 }
4107
4108 /***********************************************************
4109 If we are DMB then prefer us as LMB
4110 ************************************************************/
4111
4112 BOOL lp_preferred_master(void)
4113 {
4114 if (Globals.bPreferredMaster == Auto)
4115 return (lp_local_master() && lp_domain_master());
4116
4117 return Globals.bPreferredMaster;
4118 }
4119
4120 /*******************************************************************
4121 Remove a service.
4122 ********************************************************************/
4123
4124 void lp_remove_service(int snum)
4125 {
4126 ServicePtrs[snum]->valid = False;
4127 }
4128
4129 /*******************************************************************
4130 Copy a service.
4131 ********************************************************************/
4132
4133 void lp_copy_service(int snum, const char *new_name)
4134 {
4135 char *oldname = lp_servicename(snum);
4136 do_section(new_name);
4137 if (snum >= 0) {
4138 snum = lp_servicenumber(new_name);
4139 if (snum >= 0)
4140 lp_do_parameter(snum, "copy", oldname);
4141 }
4142 }
4143
4144
4145 /*******************************************************************
4146 Get the default server type we will announce as via nmbd.
4147 ********************************************************************/
4148
4149 int lp_default_server_announce(void)
4150 {
4151 return default_server_announce;
4152 }
4153
4154 /*******************************************************************
4155 Split the announce version into major and minor numbers.
4156 ********************************************************************/
4157
4158 int lp_major_announce_version(void)
4159 {
4160 static BOOL got_major = False;
4161 static int major_version = DEFAULT_MAJOR_VERSION;
4162 char *vers;
4163 char *p;
4164
4165 if (got_major)
4166 return major_version;
4167
4168 got_major = True;
4169 if ((vers = lp_announce_version()) == NULL)
4170 return major_version;
4171
4172 if ((p = strchr_m(vers, '.')) == 0)
4173 return major_version;
4174
4175 *p = '\0';
4176 major_version = atoi(vers);
4177 return major_version;
4178 }
4179
4180 int lp_minor_announce_version(void)
4181 {
4182 static BOOL got_minor = False;
4183 static int minor_version = DEFAULT_MINOR_VERSION;
4184 char *vers;
4185 char *p;
4186
4187 if (got_minor)
4188 return minor_version;
4189
4190 got_minor = True;
4191 if ((vers = lp_announce_version()) == NULL)
4192 return minor_version;
4193
4194 if ((p = strchr_m(vers, '.')) == 0)
4195 return minor_version;
4196
4197 p++;
4198 minor_version = atoi(p);
4199 return minor_version;
4200 }
4201
4202 /***********************************************************
4203 Set the global name resolution order (used in smbclient).
4204 ************************************************************/
4205
4206 void lp_set_name_resolve_order(char *new_order)
4207 {
4208 Globals.szNameResolveOrder = new_order;
4209 }
4210
4211 const char *lp_printername(int snum)
4212 {
4213 const char *ret = _lp_printername(snum);
4214 if (ret == NULL || (ret != NULL && *ret == '\0'))
4215 ret = lp_const_servicename(snum);
4216
4217 return ret;
4218 }
4219
4220
4221 /****************************************************************
4222 Compatibility fn. for 2.2.2 code.....
4223 *****************************************************************/
4224
4225 void get_private_directory(pstring privdir)
4226 {
4227 pstrcpy (privdir, lp_private_dir());
4228 }
4229
4230 /***********************************************************
4231 Allow daemons such as winbindd to fix their logfile name.
4232 ************************************************************/
4233
4234 void lp_set_logfile(const char *name)
4235 {
4236 extern pstring debugf;
4237 string_set(&Globals.szLogFile, name);
4238 pstrcpy(debugf, name);
4239 }
4240
4241 /*******************************************************************
4242 Return the NetBIOS called name.
4243 ********************************************************************/
4244
4245 const char *get_called_name(void)
4246 {
4247 extern fstring local_machine;
4248 static fstring called_name;
4249
4250 if (! *local_machine)
4251 return global_myname();
4252
4253 /*
4254 * Windows NT/2k uses "*SMBSERVER" and XP uses "*SMBSERV"
4255 * arrggg!!! but we've already rewritten the client's
4256 * netbios name at this point...
4257 */
4258
4259 if (*local_machine) {
4260 if (!StrCaseCmp(local_machine, "_SMBSERVER") || !StrCaseCmp(local_machine, "_SMBSERV")) {
4261 fstrcpy(called_name, get_my_primary_ip());
4262 DEBUG(8,("get_called_name: assuming that client used IP address [%s] as called name.\n",
4263 called_name));
4264 return called_name;
4265 }
4266 }
4267
4268 return local_machine;
4269 }
4270
4271 /*******************************************************************
4272 Return the max print jobs per queue.
4273 ********************************************************************/
4274
4275 int lp_maxprintjobs(int snum)
4276 {
4277 int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
4278 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
4279 maxjobs = PRINT_MAX_JOBID - 1;
4280
4281 return maxjobs;
4282 }
Anubhav's Work In Progress branches