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