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