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