?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r7531: Finally fix lp_load(). I had left hooks in place which restricted us
[Samba/ekacnet.git] / source4 / param / loadparm.c
blobdeb7d2284ff00418eb0647795f3578fd570b09ad
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) James Myers 2003 <myersjj@samba.org>
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 2 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, write to the Free Software
26 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 */
28
29 /*
30 * Load parameters.
31 *
32 * This module provides suitable callback functions for the params
33 * module. It builds the internal table of service details which is
34 * then used by the rest of the server.
35 *
36 * To add a parameter:
37 *
38 * 1) add it to the global or service structure definition
39 * 2) add it to the parm_table
40 * 3) add it to the list of available functions (eg: using FN_GLOBAL_STRING())
41 * 4) If it's a global then initialise it in init_globals. If a local
42 * (ie. service) parameter then initialise it in the sDefault structure
43 *
44 *
45 * Notes:
46 * The configuration file is processed sequentially for speed. It is NOT
47 * accessed randomly as happens in 'real' Windows. For this reason, there
48 * is a fair bit of sequence-dependent code here - ie., code which assumes
49 * that certain things happen before others. In particular, the code which
50 * happens at the boundary between sections is delicately poised, so be
51 * careful!
52 *
53 */
54
55 #include "includes.h"
56 #include "version.h"
57 #include "dynconfig.h"
58 #include "system/time.h"
59 #include "system/iconv.h"
60 #include "system/network.h"
61 #include "system/printing.h"
62 #include "librpc/gen_ndr/ndr_svcctl.h"
63 #include "librpc/gen_ndr/ndr_samr.h"
64 #include "librpc/gen_ndr/ndr_nbt.h"
65 #include "dlinklist.h"
66 #include "param/loadparm.h"
67
68 BOOL in_client = False; /* Not in the client by default */
69 static BOOL bLoaded = False;
70
71 #ifndef GLOBAL_NAME
72 #define GLOBAL_NAME "global"
73 #endif
74
75 #ifndef PRINTERS_NAME
76 #define PRINTERS_NAME "printers"
77 #endif
78
79 #ifndef HOMES_NAME
80 #define HOMES_NAME "homes"
81 #endif
82
83 /* some helpful bits */
84 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && ServicePtrs[(i)]->valid)
85 #define VALID(i) ServicePtrs[i]->valid
86
87 static BOOL do_parameter(const char *, const char *);
88 static BOOL do_parameter_var(const char *pszParmName, const char *fmt, ...);
89
90 static BOOL defaults_saved = False;
91
92
93 #define FLAG_BASIC 0x0001 /* fundamental options */
94 #define FLAG_SHARE 0x0002 /* file sharing options */
95 #define FLAG_PRINT 0x0004 /* printing options */
96 #define FLAG_GLOBAL 0x0008 /* local options that should be globally settable in SWAT */
97 #define FLAG_WIZARD 0x0010 /* Parameters that the wizard will operate on */
98 #define FLAG_ADVANCED 0x0020 /* Parameters that the wizard will operate on */
99 #define FLAG_DEVELOPER 0x0040 /* Parameters that the wizard will operate on */
100 #define FLAG_DEPRECATED 0x1000 /* options that should no longer be used */
101 #define FLAG_HIDE 0x2000 /* options that should be hidden in SWAT */
102 #define FLAG_DOS_STRING 0x4000 /* convert from UNIX to DOS codepage when reading this string. */
103 #define FLAG_CMDLINE 0x8000 /* this option was set from the command line */
104
105
106
107
108 struct param_opt {
109 struct param_opt *prev, *next;
110 char *key;
111 char *value;
112 int flags;
113 };
114
115 /*
116 * This structure describes global (ie., server-wide) parameters.
117 */
118 typedef struct
119 {
120 char **smb_ports;
121 char *dos_charset;
122 char *unix_charset;
123 char *ncalrpc_dir;
124 char *display_charset;
125 char *szPrintcapname;
126 char *szLockDir;
127 char *szPidDir;
128 char *szRootdir;
129 char *szDefaultService;
130 char *szHostsEquiv;
131 char *szServerString;
132 char *szAutoServices;
133 char *szPasswdProgram;
134 char *szPasswdChat;
135 char *szLogFile;
136 char *szConfigFile;
137 char *szSMBPasswdFile;
138 char *szSAM_URL;
139 char *szSPOOLSS_URL;
140 char *szWINS_URL;
141 char *szPrivateDir;
142 char **szPreloadModules;
143 char **szPasswordServers;
144 char *szSocketOptions;
145 char *szRealm;
146 char *szADSserver;
147 char *szLogonScript;
148 char *szLogonPath;
149 char *szLogonDrive;
150 char *szLogonHome;
151 char **szWINSservers;
152 char **szInterfaces;
153 char *szRemoteAnnounce;
154 char *szRemoteBrowseSync;
155 char *szSocketAddress;
156 char *szAnnounceVersion; /* This is initialised in init_globals */
157 char *szWorkgroup;
158 char *szNetbiosName;
159 char **szNetbiosAliases;
160 char *szNetbiosScope;
161 char *szDomainOtherSIDs;
162 char **szNameResolveOrder;
163 char *szPanicAction;
164 char *szAddUserScript;
165 char *szAddMachineScript;
166 char *szWINSHook;
167 char *szWINSPartners;
168 char **dcerpc_ep_servers;
169 char **server_services;
170 char *szWinbindUID;
171 char *szWinbindGID;
172 char *szNonUnixAccountRange;
173 char *szTemplateHomedir;
174 char *szTemplateShell;
175 char *szWinbindSeparator;
176 BOOL bWinbindEnumUsers;
177 BOOL bWinbindEnumGroups;
178 BOOL bWinbindUseDefaultDomain;
179 char *szIDMapBackend;
180 char *szGuestaccount;
181 char *swat_directory;
182 BOOL web_tls;
183 char *web_keyfile;
184 char *web_certfile;
185 char *web_cafile;
186 char *web_crlfile;
187 int max_mux;
188 int max_xmit;
189 int pwordlevel;
190 int unamelevel;
191 int maxprotocol;
192 int minprotocol;
193 int security;
194 char **AuthMethods;
195 BOOL paranoid_server_security;
196 int lpqcachetime;
197 BOOL bDisableSpoolss;
198 int os_level;
199 int enhanced_browsing;
200 int time_offset;
201 int max_ttl;
202 int max_wins_ttl;
203 int min_wins_ttl;
204 int lm_announce;
205 int lm_interval;
206 int announce_as; /* This is initialised in init_globals */
207 int machine_password_timeout;
208 int winbind_cache_time;
209 int iLockSpinCount;
210 int iLockSpinTime;
211 int nbt_port;
212 int dgram_port;
213 int cldap_port;
214 int krb5_port;
215 int web_port;
216 char *socket_options;
217 BOOL bDNSproxy;
218 BOOL bWINSsupport;
219 BOOL bWINSproxy;
220 BOOL bLocalMaster;
221 BOOL bPreferredMaster;
222 BOOL bDomainMaster;
223 BOOL bDomainLogons;
224 BOOL bEncryptPasswords;
225 BOOL bNullPasswords;
226 BOOL bObeyPamRestrictions;
227 BOOL bLoadPrinters;
228 BOOL bLargeReadwrite;
229 BOOL bReadRaw;
230 BOOL bWriteRaw;
231 BOOL bTimeServer;
232 BOOL bBindInterfacesOnly;
233 BOOL bPamPasswordChange;
234 BOOL bNTSmbSupport;
235 BOOL bNTStatusSupport;
236 BOOL bAllowTrustedDomains;
237 BOOL bLanmanAuth;
238 BOOL bNTLMAuth;
239 BOOL bUseSpnego;
240 int server_signing;
241 int client_signing;
242 BOOL bClientLanManAuth;
243 BOOL bClientNTLMv2Auth;
244 BOOL bHostMSDfs;
245 BOOL bHideLocalUsers;
246 BOOL bUnicode;
247 BOOL bUseMmap;
248 BOOL bHostnameLookups;
249 BOOL bUnixExtensions;
250 BOOL bDisableNetbios;
251 BOOL bRpcBigEndian;
252 int restrict_anonymous;
253 int name_cache_timeout;
254 struct param_opt *param_opt;
255 }
256 global;
257
258 static global Globals;
259
260 /*
261 * This structure describes a single service.
262 */
263 typedef struct
264 {
265 BOOL valid;
266 BOOL autoloaded;
267 char *szService;
268 char *szPath;
269 char *szUsername;
270 char **szInvalidUsers;
271 char **szValidUsers;
272 char **szAdminUsers;
273 char *szCopy;
274 char *szInclude;
275 char *szPrintcommand;
276 char *szLpqcommand;
277 char *szLprmcommand;
278 char *szLppausecommand;
279 char *szLpresumecommand;
280 char *szQueuepausecommand;
281 char *szQueueresumecommand;
282 char *szPrintername;
283 char **szHostsallow;
284 char **szHostsdeny;
285 char *comment;
286 char *volume;
287 char *fstype;
288 char *szMSDfsProxy;
289 char **ntvfs_handler;
290 int iMinPrintSpace;
291 int iMaxPrintJobs;
292 int iMaxConnections;
293 int iPrinting;
294 int iCSCPolicy;
295 BOOL bAvailable;
296 BOOL bBrowseable;
297 BOOL bRead_only;
298 BOOL bPrint_ok;
299 BOOL bMap_system;
300 BOOL bMap_hidden;
301 BOOL bMap_archive;
302 BOOL bLocking;
303 BOOL bStrictLocking;
304 BOOL bPosixLocking;
305 BOOL bOpLocks;
306 BOOL bLevel2OpLocks;
307 BOOL bOnlyUser;
308 BOOL bGuest_only;
309 BOOL bGuest_ok;
310 BOOL *copymap;
311 BOOL bMSDfsRoot;
312 BOOL bShareModes;
313 BOOL bStrictSync;
314 BOOL bCIFileSystem;
315 struct param_opt *param_opt;
316
317 char dummy[3]; /* for alignment */
318 }
319 service;
320
321
322 /* This is a default service used to prime a services structure */
323 static service sDefault = {
324 True, /* valid */
325 False, /* not autoloaded */
326 NULL, /* szService */
327 NULL, /* szPath */
328 NULL, /* szUsername */
329 NULL, /* szInvalidUsers */
330 NULL, /* szValidUsers */
331 NULL, /* szAdminUsers */
332 NULL, /* szCopy */
333 NULL, /* szInclude */
334 NULL, /* szPrintcommand */
335 NULL, /* szLpqcommand */
336 NULL, /* szLprmcommand */
337 NULL, /* szLppausecommand */
338 NULL, /* szLpresumecommand */
339 NULL, /* szQueuepausecommand */
340 NULL, /* szQueueresumecommand */
341 NULL, /* szPrintername */
342 NULL, /* szHostsallow */
343 NULL, /* szHostsdeny */
344 NULL, /* comment */
345 NULL, /* volume */
346 NULL, /* fstype */
347 NULL, /* szMSDfsProxy */
348 NULL, /* ntvfs_handler */
349 0, /* iMinPrintSpace */
350 1000, /* iMaxPrintJobs */
351 0, /* iMaxConnections */
352 DEFAULT_PRINTING, /* iPrinting */
353 0, /* iCSCPolicy */
354 True, /* bAvailable */
355 True, /* bBrowseable */
356 True, /* bRead_only */
357 False, /* bPrint_ok */
358 False, /* bMap_system */
359 False, /* bMap_hidden */
360 True, /* bMap_archive */
361 True, /* bLocking */
362 True, /* bStrictLocking */
363 True, /* bPosixLocking */
364 True, /* bOpLocks */
365 True, /* bLevel2OpLocks */
366 False, /* bOnlyUser */
367 False, /* bGuest_only */
368 False, /* bGuest_ok */
369 NULL, /* copymap */
370 False, /* bMSDfsRoot */
371 True, /* bShareModes */
372 False, /* bStrictSync */
373 False, /* bCIFileSystem */
374 NULL, /* Parametric options */
375
376 "" /* dummy */
377 };
378
379 /* local variables */
380 static service **ServicePtrs = NULL;
381 static int iNumServices = 0;
382 static int iServiceIndex = 0;
383 static BOOL bInGlobalSection = True;
384 static int server_role;
385 static int default_server_announce;
386
387 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
388
389 /* prototypes for the special type handlers */
390 static BOOL handle_include(const char *pszParmValue, char **ptr);
391 static BOOL handle_copy(const char *pszParmValue, char **ptr);
392 static BOOL handle_winbind_uid(const char *pszParmValue, char **ptr);
393 static BOOL handle_winbind_gid(const char *pszParmValue, char **ptr);
394 static BOOL handle_non_unix_account_range(const char *pszParmValue, char **ptr);
395
396 static void set_server_role(void);
397 static void set_default_server_announce_type(void);
398
399 static const struct enum_list enum_protocol[] = {
400 {PROTOCOL_NT1, "NT1"},
401 {PROTOCOL_LANMAN2, "LANMAN2"},
402 {PROTOCOL_LANMAN1, "LANMAN1"},
403 {PROTOCOL_CORE, "CORE"},
404 {PROTOCOL_COREPLUS, "COREPLUS"},
405 {PROTOCOL_COREPLUS, "CORE+"},
406 {-1, NULL}
407 };
408
409 static const struct enum_list enum_security[] = {
410 {SEC_SHARE, "SHARE"},
411 {SEC_USER, "USER"},
412 {SEC_SERVER, "SERVER"},
413 {SEC_DOMAIN, "DOMAIN"},
414 #ifdef HAVE_ADS
415 {SEC_ADS, "ADS"},
416 #endif
417 {-1, NULL}
418 };
419
420 static const struct enum_list enum_printing[] = {
421 {PRINT_SYSV, "sysv"},
422 {PRINT_AIX, "aix"},
423 {PRINT_HPUX, "hpux"},
424 {PRINT_BSD, "bsd"},
425 {PRINT_QNX, "qnx"},
426 {PRINT_PLP, "plp"},
427 {PRINT_LPRNG, "lprng"},
428 {PRINT_SOFTQ, "softq"},
429 {PRINT_CUPS, "cups"},
430 {PRINT_LPRNT, "nt"},
431 {PRINT_LPROS2, "os2"},
432 #ifdef DEVELOPER
433 {PRINT_TEST, "test"},
434 {PRINT_VLP, "vlp"},
435 #endif /* DEVELOPER */
436 {-1, NULL}
437 };
438
439 /* Types of machine we can announce as. */
440 #define ANNOUNCE_AS_NT_SERVER 1
441 #define ANNOUNCE_AS_WIN95 2
442 #define ANNOUNCE_AS_WFW 3
443 #define ANNOUNCE_AS_NT_WORKSTATION 4
444
445 static const struct enum_list enum_announce_as[] = {
446 {ANNOUNCE_AS_NT_SERVER, "NT"},
447 {ANNOUNCE_AS_NT_SERVER, "NT Server"},
448 {ANNOUNCE_AS_NT_WORKSTATION, "NT Workstation"},
449 {ANNOUNCE_AS_WIN95, "win95"},
450 {ANNOUNCE_AS_WFW, "WfW"},
451 {-1, NULL}
452 };
453
454 static const struct enum_list enum_bool_auto[] = {
455 {False, "No"},
456 {False, "False"},
457 {False, "0"},
458 {True, "Yes"},
459 {True, "True"},
460 {True, "1"},
461 {Auto, "Auto"},
462 {-1, NULL}
463 };
464
465 /* Client-side offline caching policy types */
466 #define CSC_POLICY_MANUAL 0
467 #define CSC_POLICY_DOCUMENTS 1
468 #define CSC_POLICY_PROGRAMS 2
469 #define CSC_POLICY_DISABLE 3
470
471 static const struct enum_list enum_csc_policy[] = {
472 {CSC_POLICY_MANUAL, "manual"},
473 {CSC_POLICY_DOCUMENTS, "documents"},
474 {CSC_POLICY_PROGRAMS, "programs"},
475 {CSC_POLICY_DISABLE, "disable"},
476 {-1, NULL}
477 };
478
479 /* SMB signing types. */
480 static const struct enum_list enum_smb_signing_vals[] = {
481 {SMB_SIGNING_OFF, "No"},
482 {SMB_SIGNING_OFF, "False"},
483 {SMB_SIGNING_OFF, "0"},
484 {SMB_SIGNING_OFF, "Off"},
485 {SMB_SIGNING_OFF, "disabled"},
486 {SMB_SIGNING_SUPPORTED, "Yes"},
487 {SMB_SIGNING_SUPPORTED, "True"},
488 {SMB_SIGNING_SUPPORTED, "1"},
489 {SMB_SIGNING_SUPPORTED, "On"},
490 {SMB_SIGNING_SUPPORTED, "enabled"},
491 {SMB_SIGNING_REQUIRED, "required"},
492 {SMB_SIGNING_REQUIRED, "mandatory"},
493 {SMB_SIGNING_REQUIRED, "force"},
494 {SMB_SIGNING_REQUIRED, "forced"},
495 {SMB_SIGNING_REQUIRED, "enforced"},
496 {SMB_SIGNING_AUTO, "auto"},
497 {-1, NULL}
498 };
499
500
501 /* Note: We do not initialise the defaults union - it is not allowed in ANSI C
502 *
503 * Note: We have a flag called FLAG_DEVELOPER but is not used at this time, it
504 * is implied in current control logic. This may change at some later time. A
505 * flag value of 0 means - show as development option only.
506 *
507 * The FLAG_HIDE is explicit. Paramters set this way do NOT appear in any edit
508 * screen in SWAT. This is used to exclude parameters as well as to squash all
509 * parameters that have been duplicated by pseudonyms.
510 */
511 static struct parm_struct parm_table[] = {
512 {"Base Options", P_SEP, P_SEPARATOR},
513
514 {"dos charset", P_STRING, P_GLOBAL, &Globals.dos_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
515 {"unix charset", P_STRING, P_GLOBAL, &Globals.unix_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
516 {"ncalrpc dir", P_STRING, P_GLOBAL, &Globals.ncalrpc_dir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
517 {"display charset", P_STRING, P_GLOBAL, &Globals.display_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
518 {"comment", P_STRING, P_LOCAL, &sDefault.comment, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
519 {"path", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
520 {"directory", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_HIDE},
521 {"workgroup", P_USTRING, P_GLOBAL, &Globals.szWorkgroup, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
522 {"realm", P_STRING, P_GLOBAL, &Globals.szRealm, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
523 {"ADS server", P_STRING, P_GLOBAL, &Globals.szADSserver, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
524 {"netbios name", P_USTRING, P_GLOBAL, &Globals.szNetbiosName, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
525 {"netbios aliases", P_LIST, P_GLOBAL, &Globals.szNetbiosAliases, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
526 {"netbios scope", P_USTRING, P_GLOBAL, &Globals.szNetbiosScope, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
527 {"server string", P_STRING, P_GLOBAL, &Globals.szServerString, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
528 {"interfaces", P_LIST, P_GLOBAL, &Globals.szInterfaces, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
529 {"bind interfaces only", P_BOOL, P_GLOBAL, &Globals.bBindInterfacesOnly, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
530 {"ntvfs handler", P_LIST, P_LOCAL, &sDefault.ntvfs_handler, NULL, NULL, FLAG_ADVANCED},
531 {"dcerpc endpoint servers", P_LIST, P_GLOBAL, &Globals.dcerpc_ep_servers, NULL, NULL, FLAG_ADVANCED},
532 {"server services", P_LIST, P_GLOBAL, &Globals.server_services, NULL, NULL, FLAG_ADVANCED},
533
534 {"Security Options", P_SEP, P_SEPARATOR},
535
536 {"security", P_ENUM, P_GLOBAL, &Globals.security, NULL, enum_security, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
537 {"auth methods", P_LIST, P_GLOBAL, &Globals.AuthMethods, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
538 {"encrypt passwords", P_BOOL, P_GLOBAL, &Globals.bEncryptPasswords, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
539 {"allow trusted domains", P_BOOL, P_GLOBAL, &Globals.bAllowTrustedDomains, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
540 {"hosts equiv", P_STRING, P_GLOBAL, &Globals.szHostsEquiv, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
541 {"idmap backend", P_STRING, P_GLOBAL, &Globals.szIDMapBackend, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
542 {"null passwords", P_BOOL, P_GLOBAL, &Globals.bNullPasswords, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
543 {"obey pam restrictions", P_BOOL, P_GLOBAL, &Globals.bObeyPamRestrictions, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
544 {"password server", P_LIST, P_GLOBAL, &Globals.szPasswordServers, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
545 {"smb passwd file", P_STRING, P_GLOBAL, &Globals.szSMBPasswdFile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
546 {"sam database", P_STRING, P_GLOBAL, &Globals.szSAM_URL, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
547 {"spoolss database", P_STRING, P_GLOBAL, &Globals.szSPOOLSS_URL, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
548 {"wins database", P_STRING, P_GLOBAL, &Globals.szWINS_URL, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
549 {"private dir", P_STRING, P_GLOBAL, &Globals.szPrivateDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
550 {"non unix account range", P_STRING, P_GLOBAL, &Globals.szNonUnixAccountRange, handle_non_unix_account_range, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
551 {"root directory", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
552 {"root dir", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
553 {"root", P_STRING, P_GLOBAL, &Globals.szRootdir, NULL, NULL, FLAG_HIDE | FLAG_DEVELOPER},
554 {"guest account", P_STRING, P_GLOBAL, &Globals.szGuestaccount, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
555
556 {"pam password change", P_BOOL, P_GLOBAL, &Globals.bPamPasswordChange, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
557 {"passwd program", P_STRING, P_GLOBAL, &Globals.szPasswdProgram, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
558 {"passwd chat", P_STRING, P_GLOBAL, &Globals.szPasswdChat, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
559 {"password level", P_INTEGER, P_GLOBAL, &Globals.pwordlevel, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
560 {"username level", P_INTEGER, P_GLOBAL, &Globals.unamelevel, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
561 {"restrict anonymous", P_INTEGER, P_GLOBAL, &Globals.restrict_anonymous, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
562 {"lanman auth", P_BOOL, P_GLOBAL, &Globals.bLanmanAuth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
563 {"ntlm auth", P_BOOL, P_GLOBAL, &Globals.bNTLMAuth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
564 {"client NTLMv2 auth", P_BOOL, P_GLOBAL, &Globals.bClientNTLMv2Auth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
565 {"client lanman auth", P_BOOL, P_GLOBAL, &Globals.bClientLanManAuth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
566
567 {"username", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
568 {"user", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_HIDE},
569 {"users", P_STRING, P_LOCAL, &sDefault.szUsername, NULL, NULL, FLAG_HIDE},
570
571 {"invalid users", P_LIST, P_LOCAL, &sDefault.szInvalidUsers, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
572 {"valid users", P_LIST, P_LOCAL, &sDefault.szValidUsers, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
573 {"admin users", P_LIST, P_LOCAL, &sDefault.szAdminUsers, NULL, NULL, FLAG_GLOBAL | FLAG_SHARE},
574
575 {"read only", P_BOOL, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE},
576
577 {"guest only", P_BOOL, P_LOCAL, &sDefault.bGuest_only, NULL, NULL, FLAG_SHARE},
578
579 {"guest ok", P_BOOL, P_LOCAL, &sDefault.bGuest_ok, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
580
581 {"only user", P_BOOL, P_LOCAL, &sDefault.bOnlyUser, NULL, NULL, FLAG_SHARE},
582 {"hosts allow", P_LIST, P_LOCAL, &sDefault.szHostsallow, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
583 {"hosts deny", P_LIST, P_LOCAL, &sDefault.szHostsdeny, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
584 {"preload modules", P_LIST, P_GLOBAL, &Globals.szPreloadModules, NULL, NULL, FLAG_BASIC | FLAG_GLOBAL},
585
586 {"Logging Options", P_SEP, P_SEPARATOR},
587
588 {"log level", P_INTEGER, P_GLOBAL, &DEBUGLEVEL, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
589 {"debuglevel", P_INTEGER, P_GLOBAL, &DEBUGLEVEL, NULL, NULL, FLAG_HIDE},
590 {"log file", P_STRING, P_GLOBAL, &Globals.szLogFile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
591
592 {"Protocol Options", P_SEP, P_SEPARATOR},
593
594 {"smb ports", P_LIST, P_GLOBAL, &Globals.smb_ports, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
595 {"nbt port", P_INTEGER, P_GLOBAL, &Globals.nbt_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
596 {"dgram port", P_INTEGER, P_GLOBAL, &Globals.dgram_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
597 {"cldap port", P_INTEGER, P_GLOBAL, &Globals.cldap_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
598 {"krb5 port", P_INTEGER, P_GLOBAL, &Globals.krb5_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
599 {"web port", P_INTEGER, P_GLOBAL, &Globals.web_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
600 {"web tls", P_BOOL, P_GLOBAL, &Globals.web_tls, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
601 {"web tls keyfile", P_STRING, P_GLOBAL, &Globals.web_keyfile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
602 {"web tls certfile", P_STRING, P_GLOBAL, &Globals.web_certfile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
603 {"web tls cafile", P_STRING, P_GLOBAL, &Globals.web_cafile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
604 {"web tls crlfile", P_STRING, P_GLOBAL, &Globals.web_crlfile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
605 {"swat directory", P_STRING, P_GLOBAL, &Globals.swat_directory, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
606 {"large readwrite", P_BOOL, P_GLOBAL, &Globals.bLargeReadwrite, NULL, NULL, FLAG_DEVELOPER},
607 {"max protocol", P_ENUM, P_GLOBAL, &Globals.maxprotocol, NULL, enum_protocol, FLAG_DEVELOPER},
608 {"min protocol", P_ENUM, P_GLOBAL, &Globals.minprotocol, NULL, enum_protocol, FLAG_DEVELOPER},
609 {"unicode", P_BOOL, P_GLOBAL, &Globals.bUnicode, NULL, NULL, FLAG_DEVELOPER},
610 {"read raw", P_BOOL, P_GLOBAL, &Globals.bReadRaw, NULL, NULL, FLAG_DEVELOPER},
611 {"write raw", P_BOOL, P_GLOBAL, &Globals.bWriteRaw, NULL, NULL, FLAG_DEVELOPER},
612 {"disable netbios", P_BOOL, P_GLOBAL, &Globals.bDisableNetbios, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
613
614 {"nt status support", P_BOOL, P_GLOBAL, &Globals.bNTStatusSupport, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
615
616 {"announce version", P_STRING, P_GLOBAL, &Globals.szAnnounceVersion, NULL, NULL, FLAG_DEVELOPER},
617 {"announce as", P_ENUM, P_GLOBAL, &Globals.announce_as, NULL, enum_announce_as, FLAG_DEVELOPER},
618 {"max mux", P_INTEGER, P_GLOBAL, &Globals.max_mux, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
619 {"max xmit", P_INTEGER, P_GLOBAL, &Globals.max_xmit, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
620
621 {"name resolve order", P_LIST, P_GLOBAL, &Globals.szNameResolveOrder, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
622 {"max ttl", P_INTEGER, P_GLOBAL, &Globals.max_ttl, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
623 {"max wins ttl", P_INTEGER, P_GLOBAL, &Globals.max_wins_ttl, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
624 {"min wins ttl", P_INTEGER, P_GLOBAL, &Globals.min_wins_ttl, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
625 {"time server", P_BOOL, P_GLOBAL, &Globals.bTimeServer, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
626 {"unix extensions", P_BOOL, P_GLOBAL, &Globals.bUnixExtensions, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
627 {"use spnego", P_BOOL, P_GLOBAL, &Globals.bUseSpnego, NULL, NULL, FLAG_DEVELOPER},
628 {"server signing", P_ENUM, P_GLOBAL, &Globals.server_signing, NULL, enum_smb_signing_vals, FLAG_ADVANCED},
629 {"client signing", P_ENUM, P_GLOBAL, &Globals.client_signing, NULL, enum_smb_signing_vals, FLAG_ADVANCED},
630 {"rpc big endian", P_BOOL, P_GLOBAL, &Globals.bRpcBigEndian, NULL, NULL, FLAG_DEVELOPER},
631
632 {"Tuning Options", P_SEP, P_SEPARATOR},
633
634 {"lpq cache time", P_INTEGER, P_GLOBAL, &Globals.lpqcachetime, NULL, NULL, FLAG_DEVELOPER},
635 {"max connections", P_INTEGER, P_LOCAL, &sDefault.iMaxConnections, NULL, NULL, FLAG_SHARE},
636 {"paranoid server security", P_BOOL, P_GLOBAL, &Globals.paranoid_server_security, NULL, NULL, FLAG_DEVELOPER},
637 {"min print space", P_INTEGER, P_LOCAL, &sDefault.iMinPrintSpace, NULL, NULL, FLAG_PRINT},
638
639 {"socket options", P_STRING, P_GLOBAL, &Globals.socket_options, NULL, NULL, FLAG_DEVELOPER},
640 {"use mmap", P_BOOL, P_GLOBAL, &Globals.bUseMmap, NULL, NULL, FLAG_DEVELOPER},
641 {"hostname lookups", P_BOOL, P_GLOBAL, &Globals.bHostnameLookups, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
642
643 {"name cache timeout", P_INTEGER, P_GLOBAL, &Globals.name_cache_timeout, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
644 {"strict sync", P_BOOL, P_LOCAL, &sDefault.bStrictSync, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
645 {"case insensitive filesystem", P_BOOL, P_LOCAL, &sDefault.bCIFileSystem, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
646
647 {"Printing Options", P_SEP, P_SEPARATOR},
648
649 {"max print jobs", P_INTEGER, P_LOCAL, &sDefault.iMaxPrintJobs, NULL, NULL, FLAG_PRINT},
650 {"load printers", P_BOOL, P_GLOBAL, &Globals.bLoadPrinters, NULL, NULL, FLAG_PRINT},
651 {"printcap name", P_STRING, P_GLOBAL, &Globals.szPrintcapname, NULL, NULL, FLAG_PRINT | FLAG_DEVELOPER},
652 {"printcap", P_STRING, P_GLOBAL, &Globals.szPrintcapname, NULL, NULL, FLAG_HIDE},
653 {"printable", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_PRINT},
654 {"print ok", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_HIDE},
655 {"printing", P_ENUM, P_LOCAL, &sDefault.iPrinting, NULL, enum_printing, FLAG_PRINT | FLAG_GLOBAL},
656 {"print command", P_STRING, P_LOCAL, &sDefault.szPrintcommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
657 {"disable spoolss", P_BOOL, P_GLOBAL, &Globals.bDisableSpoolss, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
658 {"lpq command", P_STRING, P_LOCAL, &sDefault.szLpqcommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
659 {"lprm command", P_STRING, P_LOCAL, &sDefault.szLprmcommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
660 {"lppause command", P_STRING, P_LOCAL, &sDefault.szLppausecommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
661 {"lpresume command", P_STRING, P_LOCAL, &sDefault.szLpresumecommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
662 {"queuepause command", P_STRING, P_LOCAL, &sDefault.szQueuepausecommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
663 {"queueresume command", P_STRING, P_LOCAL, &sDefault.szQueueresumecommand, NULL, NULL, FLAG_PRINT | FLAG_GLOBAL},
664
665 {"printer name", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_PRINT},
666 {"printer", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_HIDE},
667
668 {"Filename Handling", P_SEP, P_SEPARATOR},
669
670 {"map system", P_BOOL, P_LOCAL, &sDefault.bMap_system, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
671 {"map hidden", P_BOOL, P_LOCAL, &sDefault.bMap_hidden, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
672 {"map archive", P_BOOL, P_LOCAL, &sDefault.bMap_archive, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
673
674 {"Domain Options", P_SEP, P_SEPARATOR},
675
676 {"machine password timeout", P_INTEGER, P_GLOBAL, &Globals.machine_password_timeout, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
677
678 {"Logon Options", P_SEP, P_SEPARATOR},
679
680 {"add user script", P_STRING, P_GLOBAL, &Globals.szAddUserScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
681 {"add machine script", P_STRING, P_GLOBAL, &Globals.szAddMachineScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
682
683 {"logon script", P_STRING, P_GLOBAL, &Globals.szLogonScript, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
684 {"logon path", P_STRING, P_GLOBAL, &Globals.szLogonPath, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
685 {"logon drive", P_STRING, P_GLOBAL, &Globals.szLogonDrive, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
686 {"logon home", P_STRING, P_GLOBAL, &Globals.szLogonHome, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
687 {"domain logons", P_BOOL, P_GLOBAL, &Globals.bDomainLogons, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
688
689 {"Browse Options", P_SEP, P_SEPARATOR},
690
691 {"os level", P_INTEGER, P_GLOBAL, &Globals.os_level, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
692 {"lm announce", P_ENUM, P_GLOBAL, &Globals.lm_announce, NULL, enum_bool_auto, FLAG_ADVANCED | FLAG_DEVELOPER},
693 {"lm interval", P_INTEGER, P_GLOBAL, &Globals.lm_interval, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
694 {"preferred master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
695 {"prefered master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_HIDE},
696 {"local master", P_BOOL, P_GLOBAL, &Globals.bLocalMaster, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
697 {"domain master", P_ENUM, P_GLOBAL, &Globals.bDomainMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
698 {"browseable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
699 {"browsable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_HIDE},
700 {"enhanced browsing", P_BOOL, P_GLOBAL, &Globals.enhanced_browsing, NULL, NULL, FLAG_DEVELOPER | FLAG_ADVANCED},
701
702 {"WINS Options", P_SEP, P_SEPARATOR},
703 {"dns proxy", P_BOOL, P_GLOBAL, &Globals.bDNSproxy, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
704 {"wins proxy", P_BOOL, P_GLOBAL, &Globals.bWINSproxy, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
705
706 {"wins server", P_LIST, P_GLOBAL, &Globals.szWINSservers, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
707 {"wins support", P_BOOL, P_GLOBAL, &Globals.bWINSsupport, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
708 {"wins hook", P_STRING, P_GLOBAL, &Globals.szWINSHook, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
709 {"wins partners", P_STRING, P_GLOBAL, &Globals.szWINSPartners, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
710
711 {"Locking Options", P_SEP, P_SEPARATOR},
712
713 {"csc policy", P_ENUM, P_LOCAL, &sDefault.iCSCPolicy, NULL, enum_csc_policy, FLAG_SHARE | FLAG_GLOBAL},
714 {"locking", P_BOOL, P_LOCAL, &sDefault.bLocking, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
715 {"lock spin count", P_INTEGER, P_GLOBAL, &Globals.iLockSpinCount, NULL, NULL, FLAG_GLOBAL},
716 {"lock spin time", P_INTEGER, P_GLOBAL, &Globals.iLockSpinTime, NULL, NULL, FLAG_GLOBAL},
717
718 {"oplocks", P_BOOL, P_LOCAL, &sDefault.bOpLocks, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
719 {"level2 oplocks", P_BOOL, P_LOCAL, &sDefault.bLevel2OpLocks, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
720 {"posix locking", P_BOOL, P_LOCAL, &sDefault.bPosixLocking, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
721 {"strict locking", P_BOOL, P_LOCAL, &sDefault.bStrictLocking, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
722 {"share modes", P_BOOL, P_LOCAL, &sDefault.bShareModes, NULL, NULL, FLAG_SHARE|FLAG_GLOBAL},
723
724 {"Miscellaneous Options", P_SEP, P_SEPARATOR},
725
726 {"config file", P_STRING, P_GLOBAL, &Globals.szConfigFile, NULL, NULL, FLAG_HIDE},
727 {"preload", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
728 {"auto services", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
729 {"lock dir", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_HIDE},
730 {"lock directory", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
731 {"pid directory", P_STRING, P_GLOBAL, &Globals.szPidDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
732
733 {"default service", P_STRING, P_GLOBAL, &Globals.szDefaultService, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
734 {"default", P_STRING, P_GLOBAL, &Globals.szDefaultService, NULL, NULL, FLAG_DEVELOPER},
735 {"remote announce", P_STRING, P_GLOBAL, &Globals.szRemoteAnnounce, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
736 {"remote browse sync", P_STRING, P_GLOBAL, &Globals.szRemoteBrowseSync, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
737 {"socket address", P_STRING, P_GLOBAL, &Globals.szSocketAddress, NULL, NULL, FLAG_DEVELOPER},
738 {"time offset", P_INTEGER, P_GLOBAL, &Globals.time_offset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
739 {"-valid", P_BOOL, P_LOCAL, &sDefault.valid, NULL, NULL, FLAG_HIDE},
740
741 {"copy", P_STRING, P_LOCAL, &sDefault.szCopy, handle_copy, NULL, FLAG_HIDE},
742 {"include", P_STRING, P_LOCAL, &sDefault.szInclude, handle_include, NULL, FLAG_HIDE},
743
744 {"available", P_BOOL, P_LOCAL, &sDefault.bAvailable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
745 {"volume", P_STRING, P_LOCAL, &sDefault.volume, NULL, NULL, FLAG_SHARE },
746 {"fstype", P_STRING, P_LOCAL, &sDefault.fstype, NULL, NULL, FLAG_SHARE},
747
748 {"panic action", P_STRING, P_GLOBAL, &Globals.szPanicAction, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
749 {"hide local users", P_BOOL, P_GLOBAL, &Globals.bHideLocalUsers, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
750
751 {"msdfs root", P_BOOL, P_LOCAL, &sDefault.bMSDfsRoot, NULL, NULL, FLAG_SHARE},
752 {"msdfs proxy", P_STRING, P_LOCAL, &sDefault.szMSDfsProxy, NULL, NULL, FLAG_SHARE},
753 {"host msdfs", P_BOOL, P_GLOBAL, &Globals.bHostMSDfs, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
754 {"Winbind options", P_SEP, P_SEPARATOR},
755
756 {"winbind uid", P_STRING, P_GLOBAL, &Globals.szWinbindUID, handle_winbind_uid, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
757 {"winbind gid", P_STRING, P_GLOBAL, &Globals.szWinbindGID, handle_winbind_gid, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
758 {"template homedir", P_STRING, P_GLOBAL, &Globals.szTemplateHomedir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
759 {"template shell", P_STRING, P_GLOBAL, &Globals.szTemplateShell, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
760 {"winbind separator", P_STRING, P_GLOBAL, &Globals.szWinbindSeparator, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
761 {"winbind cache time", P_INTEGER, P_GLOBAL, &Globals.winbind_cache_time, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
762 {"winbind enum users", P_BOOL, P_GLOBAL, &Globals.bWinbindEnumUsers, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
763 {"winbind enum groups", P_BOOL, P_GLOBAL, &Globals.bWinbindEnumGroups, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
764 {"winbind use default domain", P_BOOL, P_GLOBAL, &Globals.bWinbindUseDefaultDomain, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
765
766 {NULL, P_BOOL, P_NONE, NULL, NULL, NULL, 0}
767 };
768
769 /***************************************************************************
770 Initialise the sDefault parameter structure for the printer values.
771 ***************************************************************************/
772
773 static void init_printer_values(void)
774 {
775 /* choose defaults depending on the type of printing */
776 switch (sDefault.iPrinting) {
777 case PRINT_BSD:
778 case PRINT_AIX:
779 case PRINT_LPRNT:
780 case PRINT_LPROS2:
781 do_parameter("Lpqcommand", "lpq -P'%p'");
782 do_parameter("Lprmcommand", "lprm -P'%p' %j");
783 do_parameter("Printcommand",
784 "lpr -r -P'%p' %s");
785 break;
786
787 case PRINT_LPRNG:
788 case PRINT_PLP:
789 do_parameter("Lpqcommand", "lpq -P'%p'");
790 do_parameter("Lprmcommand", "lprm -P'%p' %j");
791 do_parameter("Printcommand",
792 "lpr -r -P'%p' %s");
793 do_parameter("Queuepausecommand",
794 "lpc stop '%p'");
795 do_parameter("Queueresumecommand",
796 "lpc start '%p'");
797 do_parameter("Lppausecommand",
798 "lpc hold '%p' %j");
799 do_parameter("Lpresumecommand",
800 "lpc release '%p' %j");
801 break;
802
803 case PRINT_CUPS:
804 #ifdef HAVE_CUPS
805 do_parameter("Lpqcommand", "");
806 do_parameter("Lprmcommand", "");
807 do_parameter("Printcommand", "");
808 do_parameter("Lppausecommand", "");
809 do_parameter("Lpresumecommand", "");
810 do_parameter("Queuepausecommand", "");
811 do_parameter("Queueresumecommand", "");
812
813 do_parameter("Printcapname", "cups");
814 #else
815 do_parameter("Lpqcommand",
816 "/usr/bin/lpstat -o '%p'");
817 do_parameter("Lprmcommand",
818 "/usr/bin/cancel '%p-%j'");
819 do_parameter("Printcommand",
820 "/usr/bin/lp -d '%p' %s; rm %s");
821 do_parameter("Lppausecommand",
822 "lp -i '%p-%j' -H hold");
823 do_parameter("Lpresumecommand",
824 "lp -i '%p-%j' -H resume");
825 do_parameter("Queuepausecommand",
826 "/usr/bin/disable '%p'");
827 do_parameter("Queueresumecommand",
828 "/usr/bin/enable '%p'");
829 do_parameter("Printcapname", "lpstat");
830 #endif /* HAVE_CUPS */
831 break;
832
833 case PRINT_SYSV:
834 case PRINT_HPUX:
835 do_parameter("Lpqcommand", "lpstat -o%p");
836 do_parameter("Lprmcommand", "cancel %p-%j");
837 do_parameter("Printcommand",
838 "lp -c -d%p %s; rm %s");
839 do_parameter("Queuepausecommand",
840 "disable %p");
841 do_parameter("Queueresumecommand",
842 "enable %p");
843 #ifndef HPUX
844 do_parameter("Lppausecommand",
845 "lp -i %p-%j -H hold");
846 do_parameter("Lpresumecommand",
847 "lp -i %p-%j -H resume");
848 #endif /* HPUX */
849 break;
850
851 case PRINT_QNX:
852 do_parameter("Lpqcommand", "lpq -P%p");
853 do_parameter("Lprmcommand", "lprm -P%p %j");
854 do_parameter("Printcommand", "lp -r -P%p %s");
855 break;
856
857 case PRINT_SOFTQ:
858 do_parameter("Lpqcommand", "qstat -l -d%p");
859 do_parameter("Lprmcommand",
860 "qstat -s -j%j -c");
861 do_parameter("Printcommand",
862 "lp -d%p -s %s; rm %s");
863 do_parameter("Lppausecommand",
864 "qstat -s -j%j -h");
865 do_parameter("Lpresumecommand",
866 "qstat -s -j%j -r");
867 break;
868 #ifdef DEVELOPER
869 case PRINT_TEST:
870 case PRINT_VLP:
871 do_parameter("Printcommand", "vlp print %p %s");
872 do_parameter("Lpqcommand", "vlp lpq %p");
873 do_parameter("Lprmcommand", "vlp lprm %p %j");
874 do_parameter("Lppausecommand", "vlp lppause %p %j");
875 do_parameter("Lpresumecommand", "vlp lpresum %p %j");
876 do_parameter("Queuepausecommand", "vlp queuepause %p");
877 do_parameter("Queueresumecommand", "vlp queueresume %p");
878 break;
879 #endif /* DEVELOPER */
880
881 }
882 }
883
884
885 /***************************************************************************
886 Initialise the global parameter structure.
887 ***************************************************************************/
888 static void init_globals(void)
889 {
890 int i;
891 char *myname;
892
893 DEBUG(3, ("Initialising global parameters\n"));
894
895 for (i = 0; parm_table[i].label; i++) {
896 if ((parm_table[i].type == P_STRING ||
897 parm_table[i].type == P_USTRING) &&
898 parm_table[i].ptr &&
899 !(parm_table[i].flags & FLAG_CMDLINE)) {
900 string_set(parm_table[i].ptr, "");
901 }
902 }
903
904 /* options that can be set on the command line must be initialised via
905 the slower do_parameter() to ensure that FLAG_CMDLINE is obeyed */
906 #ifdef TCP_NODELAY
907 do_parameter("socket options", "TCP_NODELAY");
908 #endif
909 do_parameter("workgroup", DEFAULT_WORKGROUP);
910 myname = get_myname();
911 do_parameter("netbios name", myname);
912 SAFE_FREE(myname);
913 do_parameter("max protocol", "NT1");
914 do_parameter("name resolve order", "lmhosts wins host bcast");
915
916 init_printer_values();
917
918 do_parameter("fstype", FSTYPE_STRING);
919 do_parameter("ntvfs handler", "unixuid default");
920 do_parameter("max connections", "-1");
921
922 do_parameter("dcerpc endpoint servers", "epmapper srvsvc wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi winreg dssetup");
923 do_parameter("server services", "smb rpc nbt ldap cldap web");
924 do_parameter("auth methods", "anonymous sam_ignoredomain");
925 do_parameter("smb passwd file", dyn_SMB_PASSWD_FILE);
926 do_parameter("private dir", dyn_PRIVATE_DIR);
927 do_parameter_var("sam database", "tdb://%s/sam.ldb", dyn_PRIVATE_DIR);
928 do_parameter_var("spoolss database", "tdb://%s/spoolss.ldb", dyn_PRIVATE_DIR);
929 do_parameter_var("wins database", "tdb://%s/wins.ldb", dyn_PRIVATE_DIR);
930 do_parameter_var("registry:HKEY_LOCAL_MACHINE", "ldb:/%s/hklm.ldb", dyn_PRIVATE_DIR);
931 do_parameter("guest account", GUEST_ACCOUNT);
932
933 /* using UTF8 by default allows us to support all chars */
934 do_parameter("unix charset", "UTF8");
935
936 /* Use codepage 850 as a default for the dos character set */
937 do_parameter("dos charset", "CP850");
938
939 /*
940 * Allow the default PASSWD_CHAT to be overridden in local.h.
941 */
942 do_parameter("passwd chat", DEFAULT_PASSWD_CHAT);
943
944 do_parameter("passwd program", "");
945 do_parameter("printcap name", PRINTCAP_NAME);
946
947 do_parameter("pid directory", dyn_PIDDIR);
948 do_parameter("lock dir", dyn_LOCKDIR);
949 do_parameter("ncalrpc dir", dyn_NCALRPCDIR);
950
951 do_parameter("socket address", "0.0.0.0");
952 do_parameter_var("server string", "Samba %s", SAMBA_VERSION_STRING);
953
954 do_parameter_var("announce version", "%d.%d",
955 DEFAULT_MAJOR_VERSION,
956 DEFAULT_MINOR_VERSION);
957
958 do_parameter("logon drive", "");
959
960 do_parameter("logon home", "\\\\%N\\%U");
961 do_parameter("logon path", "\\\\%N\\%U\\profile");
962 do_parameter("password server", "*");
963
964 do_parameter("load printers", "True");
965
966 do_parameter("max mux", "50");
967 do_parameter("max xmit", "12288");
968 do_parameter("lpqcachetime", "10");
969 do_parameter("DisableSpoolss", "False");
970 do_parameter("password level", "0");
971 do_parameter("username level", "0");
972 do_parameter("LargeReadwrite", "True");
973 do_parameter("minprotocol", "CORE");
974 do_parameter("security", "USER");
975 do_parameter("paranoid server security", "True");
976 do_parameter("EncryptPasswords", "True");
977 do_parameter("ReadRaw", "True");
978 do_parameter("WriteRaw", "True");
979 do_parameter("NullPasswords", "False");
980 do_parameter("ObeyPamRestrictions", "False");
981 do_parameter("lm announce", "Auto");
982 do_parameter("lm interval", "60");
983 do_parameter("announce as", "NT SERVER");
984
985 do_parameter("TimeServer", "False");
986 do_parameter("BindInterfacesOnly", "False");
987 do_parameter("PamPasswordChange", "False");
988 do_parameter("Unicode", "True");
989 do_parameter("restrict anonymous", "0");
990 do_parameter("ClientLanManAuth", "True");
991 do_parameter("LanmanAuth", "True");
992 do_parameter("NTLMAuth", "True");
993
994 do_parameter("enhanced browsing", "True");
995 do_parameter("LockSpinCount", "3");
996 do_parameter("LockSpinTime", "10");
997 #ifdef MMAP_BLACKLIST
998 do_parameter("UseMmap", "False");
999 #else
1000 do_parameter("UseMmap", "True");
1001 #endif
1002 do_parameter("UnixExtensions", "False");
1003
1004 /* hostname lookups can be very expensive and are broken on
1005 a large number of sites (tridge) */
1006 do_parameter("HostnameLookups", "False");
1007
1008 do_parameter("PreferredMaster", "Auto");
1009 do_parameter("os level", "20");
1010 do_parameter("LocalMaster", "True");
1011 do_parameter("DomainMaster", "Auto"); /* depending on bDomainLogons */
1012 do_parameter("DomainLogons", "False");
1013 do_parameter("WINSsupport", "False");
1014 do_parameter("WINSproxy", "False");
1015
1016 do_parameter("DNSproxy", "True");
1017
1018 do_parameter("AllowTrustedDomains", "True");
1019
1020 do_parameter("TemplateShell", "/bin/false");
1021 do_parameter("TemplateHomedir", "/home/%D/%U");
1022 do_parameter("WinbindSeparator", "\\");
1023
1024 do_parameter("winbind cache time", "15");
1025 do_parameter("WinbindEnumUsers", "True");
1026 do_parameter("WinbindEnumGroups", "True");
1027 do_parameter("WinbindUseDefaultDomain", "False");
1028
1029 do_parameter("IDMapBackend", "tdb");
1030
1031 do_parameter("name cache timeout", "660"); /* In seconds */
1032
1033 do_parameter("client signing", "Yes");
1034 do_parameter("server signing", "auto");
1035
1036 do_parameter("use spnego", "True");
1037
1038 do_parameter("smb ports", SMB_PORTS);
1039 do_parameter("nbt port", "137");
1040 do_parameter("dgram port", "138");
1041 do_parameter("cldap port", "389");
1042 do_parameter("krb5 port", "88");
1043 do_parameter("web port", "901");
1044 do_parameter("swat directory", dyn_SWATDIR);
1045
1046 do_parameter("nt status support", "True");
1047
1048 do_parameter("max wins ttl", "432000");
1049 do_parameter("min wins ttl", "10");
1050
1051 do_parameter("web tls", "True");
1052 do_parameter_var("web tls keyfile", "%s/tls/key.pem", dyn_PRIVATE_DIR);
1053 do_parameter_var("web tls certfile", "%s/tls/cert.pem", dyn_PRIVATE_DIR);
1054 do_parameter_var("web tls cafile", "%s/tls/ca.pem", dyn_PRIVATE_DIR);
1055 }
1056
1057 static TALLOC_CTX *lp_talloc;
1058
1059 /******************************************************************* a
1060 Free up temporary memory - called from the main loop.
1061 ********************************************************************/
1062
1063 void lp_talloc_free(void)
1064 {
1065 if (!lp_talloc)
1066 return;
1067 talloc_free(lp_talloc);
1068 lp_talloc = NULL;
1069 }
1070
1071 /*******************************************************************
1072 Convenience routine to grab string parameters into temporary memory
1073 and run standard_sub_basic on them. The buffers can be written to by
1074 callers without affecting the source string.
1075 ********************************************************************/
1076
1077 static const char *lp_string(const char *s)
1078 {
1079 #if 0 /* until REWRITE done to make thread-safe */
1080 size_t len = s ? strlen(s) : 0;
1081 char *ret;
1082 #endif
1083
1084 /* The follow debug is useful for tracking down memory problems
1085 especially if you have an inner loop that is calling a lp_*()
1086 function that returns a string. Perhaps this debug should be
1087 present all the time? */
1088
1089 #if 0
1090 DEBUG(10, ("lp_string(%s)\n", s));
1091 #endif
1092
1093 #if 0 /* until REWRITE done to make thread-safe */
1094 if (!lp_talloc)
1095 lp_talloc = talloc_init("lp_talloc");
1096
1097 ret = talloc_array(lp_talloc, char, len + 100); /* leave room for substitution */
1098
1099 if (!ret)
1100 return NULL;
1101
1102 if (!s)
1103 *ret = 0;
1104 else
1105 StrnCpy(ret, s, len);
1106
1107 if (trim_string(ret, "\"", "\"")) {
1108 if (strchr(ret,'"') != NULL)
1109 StrnCpy(ret, s, len);
1110 }
1111
1112 standard_sub_basic(ret,len+100);
1113 return (ret);
1114 #endif
1115 return s;
1116 }
1117
1118 /*
1119 In this section all the functions that are used to access the
1120 parameters from the rest of the program are defined
1121 */
1122
1123 #define FN_GLOBAL_STRING(fn_name,ptr) \
1124 const char *fn_name(void) {return(lp_string(*(char **)(ptr) ? *(char **)(ptr) : ""));}
1125 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
1126 const char *fn_name(void) {return(*(const char **)(ptr) ? *(const char **)(ptr) : "");}
1127 #define FN_GLOBAL_LIST(fn_name,ptr) \
1128 const char **fn_name(void) {return(*(const char ***)(ptr));}
1129 #define FN_GLOBAL_BOOL(fn_name,ptr) \
1130 BOOL fn_name(void) {return(*(BOOL *)(ptr));}
1131 #define FN_GLOBAL_CHAR(fn_name,ptr) \
1132 char fn_name(void) {return(*(char *)(ptr));}
1133 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
1134 int fn_name(void) {return(*(int *)(ptr));}
1135
1136 #define FN_LOCAL_STRING(fn_name,val) \
1137 const char *fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
1138 #define FN_LOCAL_CONST_STRING(fn_name,val) \
1139 const char *fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
1140 #define FN_LOCAL_LIST(fn_name,val) \
1141 const char **fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1142 #define FN_LOCAL_BOOL(fn_name,val) \
1143 BOOL fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1144 #define FN_LOCAL_CHAR(fn_name,val) \
1145 char fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1146 #define FN_LOCAL_INTEGER(fn_name,val) \
1147 int fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
1148
1149 FN_GLOBAL_LIST(lp_smb_ports, &Globals.smb_ports)
1150 FN_GLOBAL_INTEGER(lp_nbt_port, &Globals.nbt_port)
1151 FN_GLOBAL_INTEGER(lp_dgram_port, &Globals.dgram_port)
1152 FN_GLOBAL_INTEGER(lp_cldap_port, &Globals.cldap_port)
1153 FN_GLOBAL_INTEGER(lp_krb5_port, &Globals.krb5_port)
1154 FN_GLOBAL_INTEGER(lp_web_port, &Globals.web_port)
1155 FN_GLOBAL_STRING(lp_dos_charset, &Globals.dos_charset)
1156 FN_GLOBAL_STRING(lp_swat_directory, &Globals.swat_directory)
1157 FN_GLOBAL_BOOL(lp_web_tls, &Globals.web_tls)
1158 FN_GLOBAL_STRING(lp_web_keyfile, &Globals.web_keyfile)
1159 FN_GLOBAL_STRING(lp_web_certfile, &Globals.web_certfile)
1160 FN_GLOBAL_STRING(lp_web_cafile, &Globals.web_cafile)
1161 FN_GLOBAL_STRING(lp_web_crlfile, &Globals.web_crlfile)
1162 FN_GLOBAL_STRING(lp_unix_charset, &Globals.unix_charset)
1163 FN_GLOBAL_STRING(lp_display_charset, &Globals.display_charset)
1164 FN_GLOBAL_STRING(lp_logfile, &Globals.szLogFile)
1165 FN_GLOBAL_STRING(lp_configfile, &Globals.szConfigFile)
1166 FN_GLOBAL_STRING(lp_smb_passwd_file, &Globals.szSMBPasswdFile)
1167 FN_GLOBAL_STRING(lp_sam_url, &Globals.szSAM_URL)
1168 FN_GLOBAL_STRING(lp_spoolss_url, &Globals.szSPOOLSS_URL)
1169 FN_GLOBAL_STRING(lp_wins_url, &Globals.szWINS_URL)
1170 FN_GLOBAL_STRING(lp_private_dir, &Globals.szPrivateDir)
1171 FN_GLOBAL_STRING(lp_serverstring, &Globals.szServerString)
1172 FN_GLOBAL_STRING(lp_printcapname, &Globals.szPrintcapname)
1173 FN_GLOBAL_STRING(lp_lockdir, &Globals.szLockDir)
1174 FN_GLOBAL_STRING(lp_ncalrpc_dir, &Globals.ncalrpc_dir)
1175 FN_GLOBAL_STRING(lp_piddir, &Globals.szPidDir)
1176 FN_GLOBAL_LIST(lp_dcerpc_endpoint_servers, &Globals.dcerpc_ep_servers)
1177 FN_GLOBAL_LIST(lp_server_services, &Globals.server_services)
1178 FN_GLOBAL_STRING(lp_rootdir, &Globals.szRootdir)
1179 FN_GLOBAL_STRING(lp_defaultservice, &Globals.szDefaultService)
1180 FN_GLOBAL_STRING(lp_hosts_equiv, &Globals.szHostsEquiv)
1181 FN_GLOBAL_STRING(lp_auto_services, &Globals.szAutoServices)
1182 FN_GLOBAL_STRING(lp_passwd_program, &Globals.szPasswdProgram)
1183 FN_GLOBAL_STRING(lp_passwd_chat, &Globals.szPasswdChat)
1184 FN_GLOBAL_LIST(lp_passwordserver, &Globals.szPasswordServers)
1185 FN_GLOBAL_LIST(lp_name_resolve_order, &Globals.szNameResolveOrder)
1186 FN_GLOBAL_STRING(lp_realm, &Globals.szRealm)
1187 FN_GLOBAL_STRING(lp_ads_server, &Globals.szADSserver)
1188 FN_GLOBAL_STRING(lp_socket_options, &Globals.socket_options)
1189 FN_GLOBAL_STRING(lp_workgroup, &Globals.szWorkgroup)
1190 FN_GLOBAL_STRING(lp_netbios_name, &Globals.szNetbiosName)
1191 FN_GLOBAL_STRING(lp_netbios_scope, &Globals.szNetbiosScope)
1192 FN_GLOBAL_CONST_STRING(lp_logon_script, &Globals.szLogonScript)
1193 FN_GLOBAL_CONST_STRING(lp_logon_path, &Globals.szLogonPath)
1194 FN_GLOBAL_CONST_STRING(lp_logon_drive, &Globals.szLogonDrive)
1195 FN_GLOBAL_CONST_STRING(lp_logon_home, &Globals.szLogonHome)
1196 FN_GLOBAL_STRING(lp_remote_announce, &Globals.szRemoteAnnounce)
1197 FN_GLOBAL_STRING(lp_remote_browse_sync, &Globals.szRemoteBrowseSync)
1198 FN_GLOBAL_LIST(lp_wins_server_list, &Globals.szWINSservers)
1199 FN_GLOBAL_LIST(lp_interfaces, &Globals.szInterfaces)
1200 FN_GLOBAL_STRING(lp_socket_address, &Globals.szSocketAddress)
1201 FN_GLOBAL_LIST(lp_netbios_aliases, &Globals.szNetbiosAliases)
1202 FN_GLOBAL_LIST(lp_preload_modules, &Globals.szPreloadModules)
1203 FN_GLOBAL_STRING(lp_panic_action, &Globals.szPanicAction)
1204 FN_GLOBAL_STRING(lp_adduser_script, &Globals.szAddUserScript)
1205
1206 FN_GLOBAL_CONST_STRING(lp_guestaccount, &Globals.szGuestaccount)
1207
1208 FN_GLOBAL_STRING(lp_addmachine_script, &Globals.szAddMachineScript)
1209
1210 FN_GLOBAL_STRING(lp_wins_hook, &Globals.szWINSHook)
1211 FN_GLOBAL_STRING(lp_wins_partners, &Globals.szWINSPartners)
1212 FN_GLOBAL_STRING(lp_template_homedir, &Globals.szTemplateHomedir)
1213 FN_GLOBAL_STRING(lp_template_shell, &Globals.szTemplateShell)
1214 FN_GLOBAL_CONST_STRING(lp_winbind_separator, &Globals.szWinbindSeparator)
1215 FN_GLOBAL_BOOL(lp_winbind_enum_users, &Globals.bWinbindEnumUsers)
1216 FN_GLOBAL_BOOL(lp_winbind_enum_groups, &Globals.bWinbindEnumGroups)
1217 FN_GLOBAL_BOOL(lp_winbind_use_default_domain, &Globals.bWinbindUseDefaultDomain)
1218 FN_GLOBAL_STRING(lp_idmap_backend, &Globals.szIDMapBackend)
1219
1220 FN_GLOBAL_BOOL(lp_disable_netbios, &Globals.bDisableNetbios)
1221 FN_GLOBAL_BOOL(lp_dns_proxy, &Globals.bDNSproxy)
1222 FN_GLOBAL_BOOL(lp_wins_support, &Globals.bWINSsupport)
1223 FN_GLOBAL_BOOL(lp_we_are_a_wins_server, &Globals.bWINSsupport)
1224 FN_GLOBAL_BOOL(lp_wins_proxy, &Globals.bWINSproxy)
1225 FN_GLOBAL_BOOL(lp_local_master, &Globals.bLocalMaster)
1226 FN_GLOBAL_BOOL(lp_domain_logons, &Globals.bDomainLogons)
1227 FN_GLOBAL_BOOL(lp_load_printers, &Globals.bLoadPrinters)
1228 FN_GLOBAL_BOOL(lp_readraw, &Globals.bReadRaw)
1229 FN_GLOBAL_BOOL(lp_large_readwrite, &Globals.bLargeReadwrite)
1230 FN_GLOBAL_BOOL(lp_writeraw, &Globals.bWriteRaw)
1231 FN_GLOBAL_BOOL(lp_null_passwords, &Globals.bNullPasswords)
1232 FN_GLOBAL_BOOL(lp_obey_pam_restrictions, &Globals.bObeyPamRestrictions)
1233 FN_GLOBAL_BOOL(lp_encrypted_passwords, &Globals.bEncryptPasswords)
1234 static FN_GLOBAL_BOOL(lp_time_server, &Globals.bTimeServer)
1235 FN_GLOBAL_BOOL(lp_bind_interfaces_only, &Globals.bBindInterfacesOnly)
1236 FN_GLOBAL_BOOL(lp_pam_password_change, &Globals.bPamPasswordChange)
1237 FN_GLOBAL_BOOL(lp_unicode, &Globals.bUnicode)
1238 FN_GLOBAL_BOOL(lp_nt_status_support, &Globals.bNTStatusSupport)
1239 FN_GLOBAL_BOOL(lp_allow_trusted_domains, &Globals.bAllowTrustedDomains)
1240 FN_GLOBAL_INTEGER(lp_restrict_anonymous, &Globals.restrict_anonymous)
1241 FN_GLOBAL_BOOL(lp_lanman_auth, &Globals.bLanmanAuth)
1242 FN_GLOBAL_BOOL(lp_ntlm_auth, &Globals.bNTLMAuth)
1243 FN_GLOBAL_BOOL(lp_client_lanman_auth, &Globals.bClientLanManAuth)
1244 FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, &Globals.bClientNTLMv2Auth)
1245 FN_GLOBAL_BOOL(lp_host_msdfs, &Globals.bHostMSDfs)
1246 FN_GLOBAL_BOOL(lp_enhanced_browsing, &Globals.enhanced_browsing)
1247 FN_GLOBAL_BOOL(lp_use_mmap, &Globals.bUseMmap)
1248 FN_GLOBAL_BOOL(lp_unix_extensions, &Globals.bUnixExtensions)
1249 FN_GLOBAL_BOOL(lp_use_spnego, &Globals.bUseSpnego)
1250 FN_GLOBAL_BOOL(lp_hostname_lookups, &Globals.bHostnameLookups)
1251 FN_GLOBAL_BOOL(lp_rpc_big_endian, &Globals.bRpcBigEndian)
1252 FN_GLOBAL_INTEGER(lp_os_level, &Globals.os_level)
1253 FN_GLOBAL_INTEGER(lp_max_ttl, &Globals.max_ttl)
1254 FN_GLOBAL_INTEGER(lp_max_wins_ttl, &Globals.max_wins_ttl)
1255 FN_GLOBAL_INTEGER(lp_min_wins_ttl, &Globals.min_wins_ttl)
1256 FN_GLOBAL_INTEGER(lp_time_offset, &Globals.time_offset)
1257 FN_GLOBAL_INTEGER(lp_maxmux, &Globals.max_mux)
1258 FN_GLOBAL_INTEGER(lp_max_xmit, &Globals.max_xmit)
1259 FN_GLOBAL_INTEGER(lp_passwordlevel, &Globals.pwordlevel)
1260 FN_GLOBAL_INTEGER(lp_usernamelevel, &Globals.unamelevel)
1261 FN_GLOBAL_INTEGER(lp_maxprotocol, &Globals.maxprotocol)
1262 FN_GLOBAL_INTEGER(lp_minprotocol, &Globals.minprotocol)
1263 FN_GLOBAL_INTEGER(lp_security, &Globals.security)
1264 FN_GLOBAL_LIST(lp_auth_methods, &Globals.AuthMethods)
1265 FN_GLOBAL_BOOL(lp_paranoid_server_security, &Globals.paranoid_server_security)
1266 FN_GLOBAL_INTEGER(lp_lpqcachetime, &Globals.lpqcachetime)
1267 FN_GLOBAL_INTEGER(lp_disable_spoolss, &Globals.bDisableSpoolss)
1268 static FN_GLOBAL_INTEGER(lp_announce_as, &Globals.announce_as)
1269 FN_GLOBAL_INTEGER(lp_lm_announce, &Globals.lm_announce)
1270 FN_GLOBAL_INTEGER(lp_lm_interval, &Globals.lm_interval)
1271 FN_GLOBAL_INTEGER(lp_machine_password_timeout, &Globals.machine_password_timeout)
1272 FN_GLOBAL_INTEGER(lp_lock_spin_count, &Globals.iLockSpinCount)
1273 FN_GLOBAL_INTEGER(lp_lock_sleep_time, &Globals.iLockSpinTime)
1274 FN_LOCAL_STRING(lp_servicename, szService)
1275 FN_LOCAL_CONST_STRING(lp_const_servicename, szService)
1276 FN_LOCAL_STRING(lp_pathname, szPath)
1277 FN_LOCAL_STRING(lp_username, szUsername)
1278 FN_LOCAL_LIST(lp_invalid_users, szInvalidUsers)
1279 FN_LOCAL_LIST(lp_valid_users, szValidUsers)
1280 FN_LOCAL_LIST(lp_admin_users, szAdminUsers)
1281 FN_LOCAL_STRING(lp_printcommand, szPrintcommand)
1282 FN_LOCAL_STRING(lp_lpqcommand, szLpqcommand)
1283 FN_LOCAL_STRING(lp_lprmcommand, szLprmcommand)
1284 FN_LOCAL_STRING(lp_lppausecommand, szLppausecommand)
1285 FN_LOCAL_STRING(lp_lpresumecommand, szLpresumecommand)
1286 FN_LOCAL_STRING(lp_queuepausecommand, szQueuepausecommand)
1287 FN_LOCAL_STRING(lp_queueresumecommand, szQueueresumecommand)
1288 static FN_LOCAL_STRING(_lp_printername, szPrintername)
1289 FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
1290 FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
1291 FN_LOCAL_STRING(lp_comment, comment)
1292 FN_LOCAL_STRING(lp_fstype, fstype)
1293 FN_LOCAL_STRING(lp_msdfs_proxy, szMSDfsProxy)
1294 static FN_LOCAL_STRING(lp_volume, volume)
1295 FN_LOCAL_LIST(lp_ntvfs_handler, ntvfs_handler)
1296 FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
1297 FN_LOCAL_BOOL(lp_autoloaded, autoloaded)
1298 FN_LOCAL_BOOL(lp_browseable, bBrowseable)
1299 FN_LOCAL_BOOL(lp_readonly, bRead_only)
1300 FN_LOCAL_BOOL(lp_guest_ok, bGuest_ok)
1301 FN_LOCAL_BOOL(lp_guest_only, bGuest_only)
1302 FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
1303 FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
1304 FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
1305 FN_LOCAL_BOOL(lp_locking, bLocking)
1306 FN_LOCAL_BOOL(lp_strict_locking, bStrictLocking)
1307 FN_LOCAL_BOOL(lp_posix_locking, bPosixLocking)
1308 FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
1309 FN_LOCAL_BOOL(lp_ci_filesystem, bCIFileSystem)
1310 FN_LOCAL_BOOL(lp_share_modes, bShareModes)
1311 FN_LOCAL_BOOL(lp_oplocks, bOpLocks)
1312 FN_LOCAL_BOOL(lp_level2_oplocks, bLevel2OpLocks)
1313 FN_LOCAL_BOOL(lp_onlyuser, bOnlyUser)
1314 FN_LOCAL_BOOL(lp_map_system, bMap_system)
1315 FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
1316 FN_LOCAL_INTEGER(lp_minprintspace, iMinPrintSpace)
1317 FN_LOCAL_INTEGER(lp_printing, iPrinting)
1318 FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
1319 FN_GLOBAL_INTEGER(lp_winbind_cache_time, &Globals.winbind_cache_time)
1320 FN_GLOBAL_BOOL(lp_hide_local_users, &Globals.bHideLocalUsers)
1321 FN_GLOBAL_INTEGER(lp_name_cache_timeout, &Globals.name_cache_timeout)
1322 FN_GLOBAL_INTEGER(lp_server_signing, &Globals.server_signing)
1323 FN_GLOBAL_INTEGER(lp_client_signing, &Globals.client_signing)
1324
1325 /* local prototypes */
1326
1327 static int map_parameter(const char *pszParmName);
1328 static BOOL set_boolean(BOOL *pb, const char *pszParmValue);
1329 static int getservicebyname(const char *pszServiceName,
1330 service * pserviceDest);
1331 static void copy_service(service * pserviceDest,
1332 service * pserviceSource, BOOL *pcopymapDest);
1333 static BOOL service_ok(int iService);
1334 static BOOL do_section(const char *pszSectionName);
1335 static void init_copymap(service * pservice);
1336
1337 /* This is a helper function for parametrical options support. */
1338 /* It returns a pointer to parametrical option value if it exists or NULL otherwise */
1339 /* Actual parametrical functions are quite simple */
1340 const char *lp_get_parametric(int lookup_service, const char *type, const char *option)
1341 {
1342 char *vfskey;
1343 struct param_opt *data;
1344
1345 if (lookup_service >= iNumServices) return NULL;
1346
1347 data = (lookup_service < 0) ?
1348 Globals.param_opt : ServicePtrs[lookup_service]->param_opt;
1349
1350 asprintf(&vfskey, "%s:%s", type, option);
1351 strlower(vfskey);
1352
1353 while (data) {
1354 if (strcmp(data->key, vfskey) == 0) {
1355 free(vfskey);
1356 return data->value;
1357 }
1358 data = data->next;
1359 }
1360
1361 if (lookup_service >= 0) {
1362 /* Try to fetch the same option but from globals */
1363 /* but only if we are not already working with Globals */
1364 data = Globals.param_opt;
1365 while (data) {
1366 if (strcmp(data->key, vfskey) == 0) {
1367 free(vfskey);
1368 return data->value;
1369 }
1370 data = data->next;
1371 }
1372 }
1373
1374 free(vfskey);
1375
1376 return NULL;
1377 }
1378
1379
1380 /*******************************************************************
1381 convenience routine to return int parameters.
1382 ********************************************************************/
1383 static int lp_int(const char *s)
1384 {
1385
1386 if (!s) {
1387 DEBUG(0,("lp_int(%s): is called with NULL!\n",s));
1388 return (-1);
1389 }
1390
1391 return atoi(s);
1392 }
1393
1394 /*******************************************************************
1395 convenience routine to return unsigned long parameters.
1396 ********************************************************************/
1397 static int lp_ulong(const char *s)
1398 {
1399
1400 if (!s) {
1401 DEBUG(0,("lp_int(%s): is called with NULL!\n",s));
1402 return (-1);
1403 }
1404
1405 return strtoul(s, NULL, 10);
1406 }
1407
1408 /*******************************************************************
1409 convenience routine to return boolean parameters.
1410 ********************************************************************/
1411 static BOOL lp_bool(const char *s)
1412 {
1413 BOOL ret = False;
1414
1415 if (!s) {
1416 DEBUG(0,("lp_bool(%s): is called with NULL!\n",s));
1417 return False;
1418 }
1419
1420 if (!set_boolean(&ret,s)) {
1421 DEBUG(0,("lp_bool(%s): value is not boolean!\n",s));
1422 return False;
1423 }
1424
1425 return ret;
1426 }
1427
1428
1429 /* Return parametric option from a given service. Type is a part of option before ':' */
1430 /* Parametric option has following syntax: 'Type: option = value' */
1431 /* Returned value is allocated in 'lp_talloc' context */
1432
1433 const char *lp_parm_string(int lookup_service, const char *type, const char *option)
1434 {
1435 const char *value = lp_get_parametric(lookup_service, type, option);
1436
1437 if (value)
1438 return lp_string(value);
1439
1440 return NULL;
1441 }
1442
1443 /* Return parametric option from a given service. Type is a part of option before ':' */
1444 /* Parametric option has following syntax: 'Type: option = value' */
1445 /* Returned value is allocated in 'lp_talloc' context */
1446
1447 const char **lp_parm_string_list(int lookup_service, const char *type, const char *option,
1448 const char *separator)
1449 {
1450 const char *value = lp_get_parametric(lookup_service, type, option);
1451
1452 if (value)
1453 return str_list_make(talloc_autofree_context(), value, separator);
1454
1455 return NULL;
1456 }
1457
1458 /* Return parametric option from a given service. Type is a part of option before ':' */
1459 /* Parametric option has following syntax: 'Type: option = value' */
1460
1461 int lp_parm_int(int lookup_service, const char *type, const char *option, int default_v)
1462 {
1463 const char *value = lp_get_parametric(lookup_service, type, option);
1464
1465 if (value)
1466 return lp_int(value);
1467
1468 return default_v;
1469 }
1470
1471 /* Return parametric option from a given service. Type is a part of option before ':' */
1472 /* Parametric option has following syntax: 'Type: option = value' */
1473
1474 unsigned long lp_parm_ulong(int lookup_service, const char *type, const char *option, unsigned long default_v)
1475 {
1476 const char *value = lp_get_parametric(lookup_service, type, option);
1477
1478 if (value)
1479 return lp_ulong(value);
1480
1481 return default_v;
1482 }
1483
1484 /* Return parametric option from a given service. Type is a part of option before ':' */
1485 /* Parametric option has following syntax: 'Type: option = value' */
1486
1487 BOOL lp_parm_bool(int lookup_service, const char *type, const char *option, BOOL default_v)
1488 {
1489 const char *value = lp_get_parametric(lookup_service, type, option);
1490
1491 if (value)
1492 return lp_bool(value);
1493
1494 return default_v;
1495 }
1496
1497
1498 /***************************************************************************
1499 Initialise a service to the defaults.
1500 ***************************************************************************/
1501
1502 static void init_service(service * pservice)
1503 {
1504 memset((char *)pservice, '\0', sizeof(service));
1505 copy_service(pservice, &sDefault, NULL);
1506 }
1507
1508 /***************************************************************************
1509 Free the dynamically allocated parts of a service struct.
1510 ***************************************************************************/
1511
1512 static void free_service(service *pservice)
1513 {
1514 int i;
1515 struct param_opt *data, *pdata;
1516 if (!pservice)
1517 return;
1518
1519 if (pservice->szService)
1520 DEBUG(5, ("free_service: Freeing service %s\n",
1521 pservice->szService));
1522
1523 string_free(&pservice->szService);
1524 SAFE_FREE(pservice->copymap);
1525
1526 for (i = 0; parm_table[i].label; i++) {
1527 if ((parm_table[i].type == P_STRING ||
1528 parm_table[i].type == P_USTRING) &&
1529 parm_table[i].class == P_LOCAL) {
1530 string_free((char **)
1531 (((char *)pservice) +
1532 PTR_DIFF(parm_table[i].ptr, &sDefault)));
1533 } else if (parm_table[i].type == P_LIST &&
1534 parm_table[i].class == P_LOCAL) {
1535 char ***listp = (char ***)(((char *)pservice) +
1536 PTR_DIFF(parm_table[i].ptr, &sDefault));
1537 talloc_free(*listp);
1538 *listp = NULL;
1539 }
1540 }
1541
1542 DEBUG(5,("Freeing parametrics:\n"));
1543 data = pservice->param_opt;
1544 while (data) {
1545 DEBUG(5,("[%s = %s]\n", data->key, data->value));
1546 string_free(&data->key);
1547 string_free(&data->value);
1548 pdata = data->next;
1549 SAFE_FREE(data);
1550 data = pdata;
1551 }
1552
1553 ZERO_STRUCTP(pservice);
1554 }
1555
1556 /***************************************************************************
1557 Add a new service to the services array initialising it with the given
1558 service.
1559 ***************************************************************************/
1560
1561 static int add_a_service(const service *pservice, const char *name)
1562 {
1563 int i;
1564 service tservice;
1565 int num_to_alloc = iNumServices + 1;
1566 struct param_opt *data, *pdata;
1567
1568 tservice = *pservice;
1569
1570 /* it might already exist */
1571 if (name) {
1572 i = getservicebyname(name, NULL);
1573 if (i >= 0) {
1574 /* Clean all parametric options for service */
1575 /* They will be added during parsing again */
1576 data = ServicePtrs[i]->param_opt;
1577 while (data) {
1578 string_free(&data->key);
1579 string_free(&data->value);
1580 pdata = data->next;
1581 SAFE_FREE(data);
1582 data = pdata;
1583 }
1584 ServicePtrs[i]->param_opt = NULL;
1585 return (i);
1586 }
1587 }
1588
1589 /* find an invalid one */
1590 for (i = 0; i < iNumServices; i++)
1591 if (!ServicePtrs[i]->valid)
1592 break;
1593
1594 /* if not, then create one */
1595 if (i == iNumServices) {
1596 service **tsp;
1597
1598 tsp = realloc_p(ServicePtrs, service *, num_to_alloc);
1599
1600 if (!tsp) {
1601 DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
1602 return (-1);
1603 }
1604 else {
1605 ServicePtrs = tsp;
1606 ServicePtrs[iNumServices] = malloc_p(service);
1607 }
1608 if (!ServicePtrs[iNumServices]) {
1609 DEBUG(0,("add_a_service: out of memory!\n"));
1610 return (-1);
1611 }
1612
1613 iNumServices++;
1614 } else
1615 free_service(ServicePtrs[i]);
1616
1617 ServicePtrs[i]->valid = True;
1618
1619 init_service(ServicePtrs[i]);
1620 copy_service(ServicePtrs[i], &tservice, NULL);
1621 if (name)
1622 string_set(&ServicePtrs[i]->szService, name);
1623 return (i);
1624 }
1625
1626 /***************************************************************************
1627 Add a new home service, with the specified home directory, defaults coming
1628 from service ifrom.
1629 ***************************************************************************/
1630
1631 BOOL lp_add_home(const char *pszHomename, int iDefaultService,
1632 const char *user, const char *pszHomedir)
1633 {
1634 int i;
1635 pstring newHomedir;
1636
1637 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
1638
1639 if (i < 0)
1640 return (False);
1641
1642 if (!(*(ServicePtrs[iDefaultService]->szPath))
1643 || strequal(ServicePtrs[iDefaultService]->szPath, lp_pathname(-1))) {
1644 pstrcpy(newHomedir, pszHomedir);
1645 } else {
1646 pstrcpy(newHomedir, lp_pathname(iDefaultService));
1647 string_sub(newHomedir,"%H", pszHomedir, sizeof(newHomedir));
1648 }
1649
1650 string_set(&ServicePtrs[i]->szPath, newHomedir);
1651
1652 if (!(*(ServicePtrs[i]->comment))) {
1653 pstring comment;
1654 slprintf(comment, sizeof(comment) - 1,
1655 "Home directory of %s", user);
1656 string_set(&ServicePtrs[i]->comment, comment);
1657 }
1658 ServicePtrs[i]->bAvailable = sDefault.bAvailable;
1659 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
1660
1661 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
1662 user, newHomedir));
1663
1664 return (True);
1665 }
1666
1667 /***************************************************************************
1668 Add a new service, based on an old one.
1669 ***************************************************************************/
1670
1671 int lp_add_service(const char *pszService, int iDefaultService)
1672 {
1673 return (add_a_service(ServicePtrs[iDefaultService], pszService));
1674 }
1675
1676 /***************************************************************************
1677 Add the IPC service.
1678 ***************************************************************************/
1679
1680 static BOOL lp_add_hidden(const char *name, const char *fstype, BOOL guest_ok)
1681 {
1682 pstring comment;
1683 int i = add_a_service(&sDefault, name);
1684
1685 if (i < 0)
1686 return (False);
1687
1688 slprintf(comment, sizeof(comment) - 1,
1689 "%s Service (%s)", fstype, Globals.szServerString);
1690
1691 string_set(&ServicePtrs[i]->szPath, tmpdir());
1692 string_set(&ServicePtrs[i]->szUsername, "");
1693 string_set(&ServicePtrs[i]->comment, comment);
1694 string_set(&ServicePtrs[i]->fstype, fstype);
1695 ServicePtrs[i]->iMaxConnections = -1;
1696 ServicePtrs[i]->bAvailable = True;
1697 ServicePtrs[i]->bRead_only = True;
1698 ServicePtrs[i]->bGuest_only = False;
1699 ServicePtrs[i]->bGuest_ok = guest_ok;
1700 ServicePtrs[i]->bPrint_ok = False;
1701 ServicePtrs[i]->bBrowseable = False;
1702
1703 if (strcasecmp(fstype, "IPC") == 0) {
1704 lp_do_parameter(i, "ntvfs handler", "default");
1705 }
1706
1707 DEBUG(3, ("adding hidden service %s\n", name));
1708
1709 return (True);
1710 }
1711
1712 /***************************************************************************
1713 Add a new printer service, with defaults coming from service iFrom.
1714 ***************************************************************************/
1715
1716 BOOL lp_add_printer(const char *pszPrintername, int iDefaultService)
1717 {
1718 const char *comment = "From Printcap";
1719 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
1720
1721 if (i < 0)
1722 return (False);
1723
1724 /* note that we do NOT default the availability flag to True - */
1725 /* we take it from the default service passed. This allows all */
1726 /* dynamic printers to be disabled by disabling the [printers] */
1727 /* entry (if/when the 'available' keyword is implemented!). */
1728
1729 /* the printer name is set to the service name. */
1730 string_set(&ServicePtrs[i]->szPrintername, pszPrintername);
1731 string_set(&ServicePtrs[i]->comment, comment);
1732 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
1733 /* Printers cannot be read_only. */
1734 ServicePtrs[i]->bRead_only = False;
1735 /* No share modes on printer services. */
1736 ServicePtrs[i]->bShareModes = False;
1737 /* No oplocks on printer services. */
1738 ServicePtrs[i]->bOpLocks = False;
1739 /* Printer services must be printable. */
1740 ServicePtrs[i]->bPrint_ok = True;
1741
1742 DEBUG(3, ("adding printer service %s\n", pszPrintername));
1743
1744 update_server_announce_as_printserver();
1745
1746 return (True);
1747 }
1748
1749 /***************************************************************************
1750 Map a parameter's string representation to something we can use.
1751 Returns False if the parameter string is not recognised, else TRUE.
1752 ***************************************************************************/
1753
1754 static int map_parameter(const char *pszParmName)
1755 {
1756 int iIndex;
1757
1758 if (*pszParmName == '-')
1759 return (-1);
1760
1761 for (iIndex = 0; parm_table[iIndex].label; iIndex++)
1762 if (strwicmp(parm_table[iIndex].label, pszParmName) == 0)
1763 return (iIndex);
1764
1765 /* Warn only if it isn't parametric option */
1766 if (strchr(pszParmName, ':') == NULL)
1767 DEBUG(0, ("Unknown parameter encountered: \"%s\"\n", pszParmName));
1768 /* We do return 'fail' for parametric options as well because they are
1769 stored in different storage
1770 */
1771 return (-1);
1772 }
1773
1774
1775 /*
1776 return the parameter structure for a parameter
1777 */
1778 struct parm_struct *lp_parm_struct(const char *name)
1779 {
1780 int parmnum = map_parameter(name);
1781 if (parmnum == -1) return NULL;
1782 return &parm_table[parmnum];
1783 }
1784
1785 /*
1786 return the parameter pointer for a parameter
1787 */
1788 void *lp_parm_ptr(int snum, struct parm_struct *parm)
1789 {
1790 if (snum == -1) {
1791 return parm->ptr;
1792 }
1793 return ((char *)ServicePtrs[snum]) + PTR_DIFF(parm->ptr, &sDefault);
1794 }
1795
1796 /***************************************************************************
1797 Set a boolean variable from the text value stored in the passed string.
1798 Returns True in success, False if the passed string does not correctly
1799 represent a boolean.
1800 ***************************************************************************/
1801
1802 static BOOL set_boolean(BOOL *pb, const char *pszParmValue)
1803 {
1804 BOOL bRetval;
1805
1806 bRetval = True;
1807 if (strwicmp(pszParmValue, "yes") == 0 ||
1808 strwicmp(pszParmValue, "true") == 0 ||
1809 strwicmp(pszParmValue, "1") == 0)
1810 *pb = True;
1811 else if (strwicmp(pszParmValue, "no") == 0 ||
1812 strwicmp(pszParmValue, "False") == 0 ||
1813 strwicmp(pszParmValue, "0") == 0)
1814 *pb = False;
1815 else {
1816 DEBUG(0,
1817 ("ERROR: Badly formed boolean in configuration file: \"%s\".\n",
1818 pszParmValue));
1819 bRetval = False;
1820 }
1821 return (bRetval);
1822 }
1823
1824 /***************************************************************************
1825 Find a service by name. Otherwise works like get_service.
1826 ***************************************************************************/
1827
1828 static int getservicebyname(const char *pszServiceName, service * pserviceDest)
1829 {
1830 int iService;
1831
1832 for (iService = iNumServices - 1; iService >= 0; iService--)
1833 if (VALID(iService) &&
1834 strwicmp(ServicePtrs[iService]->szService, pszServiceName) == 0) {
1835 if (pserviceDest != NULL)
1836 copy_service(pserviceDest, ServicePtrs[iService], NULL);
1837 break;
1838 }
1839
1840 return (iService);
1841 }
1842
1843 /***************************************************************************
1844 Copy a service structure to another.
1845 If pcopymapDest is NULL then copy all fields
1846 ***************************************************************************/
1847
1848 static void copy_service(service * pserviceDest, service * pserviceSource, BOOL *pcopymapDest)
1849 {
1850 int i;
1851 BOOL bcopyall = (pcopymapDest == NULL);
1852 struct param_opt *data, *pdata, *paramo;
1853 BOOL not_added;
1854
1855 for (i = 0; parm_table[i].label; i++)
1856 if (parm_table[i].ptr && parm_table[i].class == P_LOCAL &&
1857 (bcopyall || pcopymapDest[i])) {
1858 void *def_ptr = parm_table[i].ptr;
1859 void *src_ptr =
1860 ((char *)pserviceSource) + PTR_DIFF(def_ptr,
1861 &sDefault);
1862 void *dest_ptr =
1863 ((char *)pserviceDest) + PTR_DIFF(def_ptr,
1864 &sDefault);
1865
1866 switch (parm_table[i].type) {
1867 case P_BOOL:
1868 *(BOOL *)dest_ptr = *(BOOL *)src_ptr;
1869 break;
1870
1871 case P_INTEGER:
1872 case P_ENUM:
1873 *(int *)dest_ptr = *(int *)src_ptr;
1874 break;
1875
1876 case P_STRING:
1877 string_set(dest_ptr,
1878 *(char **)src_ptr);
1879 break;
1880
1881 case P_USTRING:
1882 string_set(dest_ptr,
1883 *(char **)src_ptr);
1884 strupper(*(char **)dest_ptr);
1885 break;
1886 case P_LIST:
1887 *(const char ***)dest_ptr = str_list_copy(talloc_autofree_context(),
1888 *(const char ***)src_ptr);
1889 break;
1890 default:
1891 break;
1892 }
1893 }
1894
1895 if (bcopyall) {
1896 init_copymap(pserviceDest);
1897 if (pserviceSource->copymap)
1898 memcpy((void *)pserviceDest->copymap,
1899 (void *)pserviceSource->copymap,
1900 sizeof(BOOL) * NUMPARAMETERS);
1901 }
1902
1903 data = pserviceSource->param_opt;
1904 while (data) {
1905 not_added = True;
1906 pdata = pserviceDest->param_opt;
1907 /* Traverse destination */
1908 while (pdata) {
1909 /* If we already have same option, override it */
1910 if (strcmp(pdata->key, data->key) == 0) {
1911 string_free(&pdata->value);
1912 pdata->value = strdup(data->value);
1913 not_added = False;
1914 break;
1915 }
1916 pdata = pdata->next;
1917 }
1918 if (not_added) {
1919 paramo = smb_xmalloc_p(struct param_opt);
1920 paramo->key = strdup(data->key);
1921 paramo->value = strdup(data->value);
1922 DLIST_ADD(pserviceDest->param_opt, paramo);
1923 }
1924 data = data->next;
1925 }
1926 }
1927
1928 /***************************************************************************
1929 Check a service for consistency. Return False if the service is in any way
1930 incomplete or faulty, else True.
1931 ***************************************************************************/
1932
1933 static BOOL service_ok(int iService)
1934 {
1935 BOOL bRetval;
1936
1937 bRetval = True;
1938 if (ServicePtrs[iService]->szService[0] == '\0') {
1939 DEBUG(0, ("The following message indicates an internal error:\n"));
1940 DEBUG(0, ("No service name in service entry.\n"));
1941 bRetval = False;
1942 }
1943
1944 /* The [printers] entry MUST be printable. I'm all for flexibility, but */
1945 /* I can't see why you'd want a non-printable printer service... */
1946 if (strwicmp(ServicePtrs[iService]->szService, PRINTERS_NAME) == 0) {
1947 if (!ServicePtrs[iService]->bPrint_ok) {
1948 DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
1949 ServicePtrs[iService]->szService));
1950 ServicePtrs[iService]->bPrint_ok = True;
1951 update_server_announce_as_printserver();
1952 }
1953 /* [printers] service must also be non-browsable. */
1954 if (ServicePtrs[iService]->bBrowseable)
1955 ServicePtrs[iService]->bBrowseable = False;
1956 }
1957
1958 /* If a service is flagged unavailable, log the fact at level 0. */
1959 if (!ServicePtrs[iService]->bAvailable)
1960 DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
1961 ServicePtrs[iService]->szService));
1962
1963 return (bRetval);
1964 }
1965
1966 static struct file_lists {
1967 struct file_lists *next;
1968 char *name;
1969 char *subfname;
1970 time_t modtime;
1971 } *file_lists = NULL;
1972
1973 /*******************************************************************
1974 Keep a linked list of all config files so we know when one has changed
1975 it's date and needs to be reloaded.
1976 ********************************************************************/
1977
1978 static void add_to_file_list(const char *fname, const char *subfname)
1979 {
1980 struct file_lists *f = file_lists;
1981
1982 while (f) {
1983 if (f->name && !strcmp(f->name, fname))
1984 break;
1985 f = f->next;
1986 }
1987
1988 if (!f) {
1989 f = malloc_p(struct file_lists);
1990 if (!f)
1991 return;
1992 f->next = file_lists;
1993 f->name = strdup(fname);
1994 if (!f->name) {
1995 SAFE_FREE(f);
1996 return;
1997 }
1998 f->subfname = strdup(subfname);
1999 if (!f->subfname) {
2000 SAFE_FREE(f);
2001 return;
2002 }
2003 file_lists = f;
2004 f->modtime = file_modtime(subfname);
2005 } else {
2006 time_t t = file_modtime(subfname);
2007 if (t)
2008 f->modtime = t;
2009 }
2010 }
2011
2012 /*******************************************************************
2013 Check if a config file has changed date.
2014 ********************************************************************/
2015
2016 BOOL lp_file_list_changed(void)
2017 {
2018 struct file_lists *f = file_lists;
2019 DEBUG(6, ("lp_file_list_changed()\n"));
2020
2021 while (f) {
2022 pstring n2;
2023 time_t mod_time;
2024
2025 pstrcpy(n2, f->name);
2026 standard_sub_basic(n2,sizeof(n2));
2027
2028 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
2029 f->name, n2, ctime(&f->modtime)));
2030
2031 mod_time = file_modtime(n2);
2032
2033 if (mod_time && ((f->modtime != mod_time) || (f->subfname == NULL) || (strcmp(n2, f->subfname) != 0))) {
2034 DEBUGADD(6,
2035 ("file %s modified: %s\n", n2,
2036 ctime(&mod_time)));
2037 f->modtime = mod_time;
2038 SAFE_FREE(f->subfname);
2039 f->subfname = strdup(n2);
2040 return (True);
2041 }
2042 f = f->next;
2043 }
2044 return (False);
2045 }
2046
2047 /***************************************************************************
2048 Handle the include operation.
2049 ***************************************************************************/
2050
2051 static BOOL handle_include(const char *pszParmValue, char **ptr)
2052 {
2053 pstring fname;
2054 pstrcpy(fname, pszParmValue);
2055
2056 standard_sub_basic(fname,sizeof(fname));
2057
2058 add_to_file_list(pszParmValue, fname);
2059
2060 string_set(ptr, fname);
2061
2062 if (file_exist(fname))
2063 return (pm_process(fname, do_section, do_parameter));
2064
2065 DEBUG(2, ("Can't find include file %s\n", fname));
2066
2067 return (False);
2068 }
2069
2070 /***************************************************************************
2071 Handle the interpretation of the copy parameter.
2072 ***************************************************************************/
2073
2074 static BOOL handle_copy(const char *pszParmValue, char **ptr)
2075 {
2076 BOOL bRetval;
2077 int iTemp;
2078 service serviceTemp;
2079
2080 string_set(ptr, pszParmValue);
2081
2082 init_service(&serviceTemp);
2083
2084 bRetval = False;
2085
2086 DEBUG(3, ("Copying service from service %s\n", pszParmValue));
2087
2088 if ((iTemp = getservicebyname(pszParmValue, &serviceTemp)) >= 0) {
2089 if (iTemp == iServiceIndex) {
2090 DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
2091 } else {
2092 copy_service(ServicePtrs[iServiceIndex],
2093 &serviceTemp,
2094 ServicePtrs[iServiceIndex]->copymap);
2095 bRetval = True;
2096 }
2097 } else {
2098 DEBUG(0, ("Unable to copy service - source not found: %s\n", pszParmValue));
2099 bRetval = False;
2100 }
2101
2102 free_service(&serviceTemp);
2103 return (bRetval);
2104 }
2105
2106 /***************************************************************************
2107 Handle winbind/non unix account uid and gid allocation parameters. The format of these
2108 parameters is:
2109
2110 [global]
2111
2112 winbind uid = 1000-1999
2113 winbind gid = 700-899
2114
2115 We only do simple parsing checks here. The strings are parsed into useful
2116 structures in the winbind daemon code.
2117
2118 ***************************************************************************/
2119
2120 /* Some lp_ routines to return winbind [ug]id information */
2121
2122 static uid_t winbind_uid_low, winbind_uid_high;
2123 static gid_t winbind_gid_low, winbind_gid_high;
2124 static uint32_t non_unix_account_low, non_unix_account_high;
2125
2126 BOOL lp_winbind_uid(uid_t *low, uid_t *high)
2127 {
2128 if (winbind_uid_low == 0 || winbind_uid_high == 0)
2129 return False;
2130
2131 if (low)
2132 *low = winbind_uid_low;
2133
2134 if (high)
2135 *high = winbind_uid_high;
2136
2137 return True;
2138 }
2139
2140 BOOL lp_winbind_gid(gid_t *low, gid_t *high)
2141 {
2142 if (winbind_gid_low == 0 || winbind_gid_high == 0)
2143 return False;
2144
2145 if (low)
2146 *low = winbind_gid_low;
2147
2148 if (high)
2149 *high = winbind_gid_high;
2150
2151 return True;
2152 }
2153
2154 BOOL lp_non_unix_account_range(uint32_t *low, uint32_t *high)
2155 {
2156 if (non_unix_account_low == 0 || non_unix_account_high == 0)
2157 return False;
2158
2159 if (low)
2160 *low = non_unix_account_low;
2161
2162 if (high)
2163 *high = non_unix_account_high;
2164
2165 return True;
2166 }
2167
2168 /* Do some simple checks on "winbind [ug]id" parameter values */
2169
2170 static BOOL handle_winbind_uid(const char *pszParmValue, char **ptr)
2171 {
2172 uint32_t low, high;
2173
2174 if (sscanf(pszParmValue, "%u-%u", &low, &high) != 2 || high < low)
2175 return False;
2176
2177 /* Parse OK */
2178
2179 string_set(ptr, pszParmValue);
2180
2181 winbind_uid_low = low;
2182 winbind_uid_high = high;
2183
2184 return True;
2185 }
2186
2187 static BOOL handle_winbind_gid(const char *pszParmValue, char **ptr)
2188 {
2189 uint32_t low, high;
2190
2191 if (sscanf(pszParmValue, "%u-%u", &low, &high) != 2 || high < low)
2192 return False;
2193
2194 /* Parse OK */
2195
2196 string_set(ptr, pszParmValue);
2197
2198 winbind_gid_low = low;
2199 winbind_gid_high = high;
2200
2201 return True;
2202 }
2203
2204 /***************************************************************************
2205 Do some simple checks on "non unix account range" parameter values.
2206 ***************************************************************************/
2207
2208 static BOOL handle_non_unix_account_range(const char *pszParmValue, char **ptr)
2209 {
2210 uint32_t low, high;
2211
2212 if (sscanf(pszParmValue, "%u-%u", &low, &high) != 2 || high < low)
2213 return False;
2214
2215 /* Parse OK */
2216
2217 string_set(ptr, pszParmValue);
2218
2219 non_unix_account_low = low;
2220 non_unix_account_high = high;
2221
2222 return True;
2223 }
2224
2225
2226 /***************************************************************************
2227 Initialise a copymap.
2228 ***************************************************************************/
2229
2230 static void init_copymap(service * pservice)
2231 {
2232 int i;
2233 SAFE_FREE(pservice->copymap);
2234 pservice->copymap = malloc_array_p(BOOL, NUMPARAMETERS);
2235 if (!pservice->copymap)
2236 DEBUG(0,
2237 ("Couldn't allocate copymap!! (size %d)\n",
2238 (int)NUMPARAMETERS));
2239 else
2240 for (i = 0; i < NUMPARAMETERS; i++)
2241 pservice->copymap[i] = True;
2242 }
2243
2244 /***************************************************************************
2245 Return the local pointer to a parameter given the service number and the
2246 pointer into the default structure.
2247 ***************************************************************************/
2248
2249 void *lp_local_ptr(int snum, void *ptr)
2250 {
2251 return (void *)(((char *)ServicePtrs[snum]) + PTR_DIFF(ptr, &sDefault));
2252 }
2253
2254
2255 /***************************************************************************
2256 Process a parametric option
2257 ***************************************************************************/
2258 static BOOL lp_do_parameter_parametric(int snum, const char *pszParmName, const char *pszParmValue, int flags)
2259 {
2260 struct param_opt *paramo, *data;
2261 char *name;
2262
2263 while (isspace(*pszParmName)) {
2264 pszParmName++;
2265 }
2266
2267 name = strdup(pszParmName);
2268 if (!name) return False;
2269
2270 strlower(name);
2271
2272 if (snum < 0) {
2273 data = Globals.param_opt;
2274 } else {
2275 data = ServicePtrs[snum]->param_opt;
2276 }
2277
2278 /* Traverse destination */
2279 for (paramo=data; paramo; paramo=paramo->next) {
2280 /* If we already have the option set, override it unless
2281 it was a command line option and the new one isn't */
2282 if (strcmp(paramo->key, name) == 0) {
2283 if ((paramo->flags & FLAG_CMDLINE) &&
2284 !(flags & FLAG_CMDLINE)) {
2285 return True;
2286 }
2287
2288 free(paramo->value);
2289 paramo->value = strdup(pszParmValue);
2290 paramo->flags = flags;
2291 free(name);
2292 return True;
2293 }
2294 }
2295
2296 paramo = smb_xmalloc_p(struct param_opt);
2297 paramo->key = strdup(name);
2298 paramo->value = strdup(pszParmValue);
2299 paramo->flags = flags;
2300 if (snum < 0) {
2301 DLIST_ADD(Globals.param_opt, paramo);
2302 } else {
2303 DLIST_ADD(ServicePtrs[snum]->param_opt, paramo);
2304 }
2305
2306 free(name);
2307
2308 return True;
2309 }
2310
2311 /***************************************************************************
2312 Process a parameter for a particular service number. If snum < 0
2313 then assume we are in the globals.
2314 ***************************************************************************/
2315 BOOL lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
2316 {
2317 int parmnum, i;
2318 void *parm_ptr = NULL; /* where we are going to store the result */
2319 void *def_ptr = NULL;
2320
2321 parmnum = map_parameter(pszParmName);
2322
2323 if (parmnum < 0) {
2324 if (strchr(pszParmName, ':')) {
2325 return lp_do_parameter_parametric(snum, pszParmName, pszParmValue, 0);
2326 }
2327 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
2328 return (True);
2329 }
2330
2331 if (parm_table[parmnum].flags & FLAG_DEPRECATED) {
2332 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
2333 pszParmName));
2334 }
2335
2336 /* if the flag has been set on the command line, then don't allow override,
2337 but don't report an error */
2338 if (parm_table[parmnum].flags & FLAG_CMDLINE) {
2339 return True;
2340 }
2341
2342 def_ptr = parm_table[parmnum].ptr;
2343
2344 /* we might point at a service, the default service or a global */
2345 if (snum < 0) {
2346 parm_ptr = def_ptr;
2347 } else {
2348 if (parm_table[parmnum].class == P_GLOBAL) {
2349 DEBUG(0,
2350 ("Global parameter %s found in service section!\n",
2351 pszParmName));
2352 return (True);
2353 }
2354 parm_ptr =
2355 ((char *)ServicePtrs[snum]) + PTR_DIFF(def_ptr,
2356 &sDefault);
2357 }
2358
2359 if (snum >= 0) {
2360 if (!ServicePtrs[snum]->copymap)
2361 init_copymap(ServicePtrs[snum]);
2362
2363 /* this handles the aliases - set the copymap for other entries with
2364 the same data pointer */
2365 for (i = 0; parm_table[i].label; i++)
2366 if (parm_table[i].ptr == parm_table[parmnum].ptr)
2367 ServicePtrs[snum]->copymap[i] = False;
2368 }
2369
2370 /* if it is a special case then go ahead */
2371 if (parm_table[parmnum].special) {
2372 parm_table[parmnum].special(pszParmValue, (char **)parm_ptr);
2373 return (True);
2374 }
2375
2376 /* now switch on the type of variable it is */
2377 switch (parm_table[parmnum].type)
2378 {
2379 case P_BOOL:
2380 set_boolean(parm_ptr, pszParmValue);
2381 break;
2382
2383 case P_INTEGER:
2384 *(int *)parm_ptr = atoi(pszParmValue);
2385 break;
2386
2387 case P_LIST:
2388 *(const char ***)parm_ptr = str_list_make(talloc_autofree_context(),
2389 pszParmValue, NULL);
2390 break;
2391
2392 case P_STRING:
2393 string_set(parm_ptr, pszParmValue);
2394 break;
2395
2396 case P_USTRING:
2397 string_set(parm_ptr, pszParmValue);
2398 strupper(*(char **)parm_ptr);
2399 break;
2400
2401 case P_ENUM:
2402 for (i = 0; parm_table[parmnum].enum_list[i].name; i++) {
2403 if (strequal
2404 (pszParmValue,
2405 parm_table[parmnum].enum_list[i].name)) {
2406 *(int *)parm_ptr =
2407 parm_table[parmnum].
2408 enum_list[i].value;
2409 break;
2410 }
2411 }
2412 if (!parm_table[parmnum].enum_list[i].name) {
2413 DEBUG(0,("Unknown enumerated value '%s' for '%s'\n",
2414 pszParmValue, pszParmName));
2415 return False;
2416 }
2417 break;
2418 case P_SEP:
2419 break;
2420 }
2421
2422 return (True);
2423 }
2424
2425 /***************************************************************************
2426 Process a parameter.
2427 ***************************************************************************/
2428
2429 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue)
2430 {
2431 return (lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
2432 pszParmName, pszParmValue));
2433 }
2434
2435 /*
2436 variable argument do parameter
2437 */
2438 static BOOL do_parameter_var(const char *pszParmName, const char *fmt, ...) PRINTF_ATTRIBUTE(2, 3);
2439
2440 static BOOL do_parameter_var(const char *pszParmName, const char *fmt, ...)
2441 {
2442 char *s;
2443 BOOL ret;
2444 va_list ap;
2445
2446 va_start(ap, fmt);
2447 s = talloc_vasprintf(NULL, fmt, ap);
2448 va_end(ap);
2449 ret = do_parameter(pszParmName, s);
2450 talloc_free(s);
2451 return ret;
2452 }
2453
2454
2455 /*
2456 set a parameter from the commandline - this is called from command line parameter
2457 parsing code. It sets the parameter then marks the parameter as unable to be modified
2458 by smb.conf processing
2459 */
2460 BOOL lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
2461 {
2462 int parmnum = map_parameter(pszParmName);
2463 int i;
2464
2465 while (isspace(*pszParmValue)) pszParmValue++;
2466
2467
2468 if (parmnum < 0 && strchr(pszParmName, ':')) {
2469 /* set a parametric option */
2470 return lp_do_parameter_parametric(-1, pszParmName, pszParmValue, FLAG_CMDLINE);
2471 }
2472
2473 if (parmnum < 0) {
2474 DEBUG(0,("Unknown option '%s'\n", pszParmName));
2475 return False;
2476 }
2477
2478 /* reset the CMDLINE flag in case this has been called before */
2479 parm_table[parmnum].flags &= ~FLAG_CMDLINE;
2480
2481 if (!lp_do_parameter(-2, pszParmName, pszParmValue)) {
2482 return False;
2483 }
2484
2485 parm_table[parmnum].flags |= FLAG_CMDLINE;
2486
2487 /* we have to also set FLAG_CMDLINE on aliases */
2488 for (i=parmnum-1;i>=0 && parm_table[i].ptr == parm_table[parmnum].ptr;i--) {
2489 parm_table[i].flags |= FLAG_CMDLINE;
2490 }
2491 for (i=parmnum+1;i<NUMPARAMETERS && parm_table[i].ptr == parm_table[parmnum].ptr;i++) {
2492 parm_table[i].flags |= FLAG_CMDLINE;
2493 }
2494
2495 return True;
2496 }
2497
2498 /*
2499 set a option from the commandline in 'a=b' format. Use to support --option
2500 */
2501 BOOL lp_set_option(const char *option)
2502 {
2503 char *p, *s;
2504 BOOL ret;
2505
2506 s = strdup(option);
2507 if (!s) {
2508 return False;
2509 }
2510
2511 p = strchr(s, '=');
2512 if (!p) {
2513 free(s);
2514 return False;
2515 }
2516
2517 *p = 0;
2518
2519 ret = lp_set_cmdline(s, p+1);
2520 free(s);
2521 return ret;
2522 }
2523
2524
2525 #define BOOLSTR(b) ((b) ? "Yes" : "No")
2526
2527 /***************************************************************************
2528 Print a parameter of the specified type.
2529 ***************************************************************************/
2530
2531 static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
2532 {
2533 int i;
2534 switch (p->type)
2535 {
2536 case P_ENUM:
2537 for (i = 0; p->enum_list[i].name; i++) {
2538 if (*(int *)ptr == p->enum_list[i].value) {
2539 fprintf(f, "%s",
2540 p->enum_list[i].name);
2541 break;
2542 }
2543 }
2544 break;
2545
2546 case P_BOOL:
2547 fprintf(f, "%s", BOOLSTR(*(BOOL *)ptr));
2548 break;
2549
2550 case P_INTEGER:
2551 fprintf(f, "%d", *(int *)ptr);
2552 break;
2553
2554 case P_LIST:
2555 if ((char ***)ptr && *(char ***)ptr) {
2556 char **list = *(char ***)ptr;
2557
2558 for (; *list; list++)
2559 fprintf(f, "%s%s", *list,
2560 ((*(list+1))?", ":""));
2561 }
2562 break;
2563
2564 case P_STRING:
2565 case P_USTRING:
2566 if (*(char **)ptr) {
2567 fprintf(f, "%s", *(char **)ptr);
2568 }
2569 break;
2570 case P_SEP:
2571 break;
2572 }
2573 }
2574
2575 /***************************************************************************
2576 Check if two parameters are equal.
2577 ***************************************************************************/
2578
2579 static BOOL equal_parameter(parm_type type, void *ptr1, void *ptr2)
2580 {
2581 switch (type) {
2582 case P_BOOL:
2583 return (*((BOOL *)ptr1) == *((BOOL *)ptr2));
2584
2585 case P_INTEGER:
2586 case P_ENUM:
2587 return (*((int *)ptr1) == *((int *)ptr2));
2588
2589 case P_LIST:
2590 return str_list_equal((const char **)(*(char ***)ptr1),
2591 (const char **)(*(char ***)ptr2));
2592
2593 case P_STRING:
2594 case P_USTRING:
2595 {
2596 char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
2597 if (p1 && !*p1)
2598 p1 = NULL;
2599 if (p2 && !*p2)
2600 p2 = NULL;
2601 return (p1 == p2 || strequal(p1, p2));
2602 }
2603 case P_SEP:
2604 break;
2605 }
2606 return (False);
2607 }
2608
2609 /***************************************************************************
2610 Process a new section (service). At this stage all sections are services.
2611 Later we'll have special sections that permit server parameters to be set.
2612 Returns True on success, False on failure.
2613 ***************************************************************************/
2614
2615 static BOOL do_section(const char *pszSectionName)
2616 {
2617 BOOL bRetval;
2618 BOOL isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
2619 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
2620 bRetval = False;
2621
2622 /* if we've just struck a global section, note the fact. */
2623 bInGlobalSection = isglobal;
2624
2625 /* check for multiple global sections */
2626 if (bInGlobalSection) {
2627 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
2628 return (True);
2629 }
2630
2631 /* if we have a current service, tidy it up before moving on */
2632 bRetval = True;
2633
2634 if (iServiceIndex >= 0)
2635 bRetval = service_ok(iServiceIndex);
2636
2637 /* if all is still well, move to the next record in the services array */
2638 if (bRetval) {
2639 /* We put this here to avoid an odd message order if messages are */
2640 /* issued by the post-processing of a previous section. */
2641 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
2642
2643 if ((iServiceIndex = add_a_service(&sDefault, pszSectionName))
2644 < 0) {
2645 DEBUG(0, ("Failed to add a new service\n"));
2646 return (False);
2647 }
2648 }
2649
2650 return (bRetval);
2651 }
2652
2653
2654 /***************************************************************************
2655 Determine if a partcular base parameter is currentl set to the default value.
2656 ***************************************************************************/
2657
2658 static BOOL is_default(int i)
2659 {
2660 if (!defaults_saved)
2661 return False;
2662 switch (parm_table[i].type) {
2663 case P_LIST:
2664 return str_list_equal((const char **)parm_table[i].def.lvalue,
2665 (const char **)(*(char ***)parm_table[i].ptr));
2666 case P_STRING:
2667 case P_USTRING:
2668 return strequal(parm_table[i].def.svalue,
2669 *(char **)parm_table[i].ptr);
2670 case P_BOOL:
2671 return parm_table[i].def.bvalue ==
2672 *(BOOL *)parm_table[i].ptr;
2673 case P_INTEGER:
2674 case P_ENUM:
2675 return parm_table[i].def.ivalue ==
2676 *(int *)parm_table[i].ptr;
2677 case P_SEP:
2678 break;
2679 }
2680 return False;
2681 }
2682
2683 /***************************************************************************
2684 Display the contents of the global structure.
2685 ***************************************************************************/
2686
2687 static void dump_globals(FILE *f)
2688 {
2689 int i;
2690 struct param_opt *data;
2691
2692 fprintf(f, "# Global parameters\n[global]\n");
2693
2694 for (i = 0; parm_table[i].label; i++)
2695 if (parm_table[i].class == P_GLOBAL &&
2696 parm_table[i].ptr &&
2697 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
2698 if (defaults_saved && is_default(i))
2699 continue;
2700 fprintf(f, "\t%s = ", parm_table[i].label);
2701 print_parameter(&parm_table[i], parm_table[i].ptr, f);
2702 fprintf(f, "\n");
2703 }
2704 if (Globals.param_opt != NULL) {
2705 data = Globals.param_opt;
2706 while(data) {
2707 fprintf(f, "\t%s = %s\n", data->key, data->value);
2708 data = data->next;
2709 }
2710 }
2711
2712 }
2713
2714 /***************************************************************************
2715 Display the contents of a single services record.
2716 ***************************************************************************/
2717
2718 static void dump_a_service(service * pService, FILE * f)
2719 {
2720 int i;
2721 struct param_opt *data;
2722
2723 if (pService != &sDefault)
2724 fprintf(f, "\n[%s]\n", pService->szService);
2725
2726 for (i = 0; parm_table[i].label; i++)
2727 if (parm_table[i].class == P_LOCAL &&
2728 parm_table[i].ptr &&
2729 (*parm_table[i].label != '-') &&
2730 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
2731 int pdiff = PTR_DIFF(parm_table[i].ptr, &sDefault);
2732
2733 if (pService == &sDefault) {
2734 if (defaults_saved && is_default(i))
2735 continue;
2736 } else {
2737 if (equal_parameter(parm_table[i].type,
2738 ((char *)pService) +
2739 pdiff,
2740 ((char *)&sDefault) +
2741 pdiff))
2742 continue;
2743 }
2744
2745 fprintf(f, "\t%s = ", parm_table[i].label);
2746 print_parameter(&parm_table[i],
2747 ((char *)pService) + pdiff, f);
2748 fprintf(f, "\n");
2749 }
2750 if (pService->param_opt != NULL) {
2751 data = pService->param_opt;
2752 while(data) {
2753 fprintf(f, "\t%s = %s\n", data->key, data->value);
2754 data = data->next;
2755 }
2756 }
2757 }
2758
2759
2760 /***************************************************************************
2761 Return info about the next service in a service. snum==-1 gives the globals.
2762 Return NULL when out of parameters.
2763 ***************************************************************************/
2764
2765 struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters)
2766 {
2767 if (snum == -1) {
2768 /* do the globals */
2769 for (; parm_table[*i].label; (*i)++) {
2770 if (parm_table[*i].class == P_SEPARATOR)
2771 return &parm_table[(*i)++];
2772
2773 if (!parm_table[*i].ptr
2774 || (*parm_table[*i].label == '-'))
2775 continue;
2776
2777 if ((*i) > 0
2778 && (parm_table[*i].ptr ==
2779 parm_table[(*i) - 1].ptr))
2780 continue;
2781
2782 return &parm_table[(*i)++];
2783 }
2784 } else {
2785 service *pService = ServicePtrs[snum];
2786
2787 for (; parm_table[*i].label; (*i)++) {
2788 if (parm_table[*i].class == P_SEPARATOR)
2789 return &parm_table[(*i)++];
2790
2791 if (parm_table[*i].class == P_LOCAL &&
2792 parm_table[*i].ptr &&
2793 (*parm_table[*i].label != '-') &&
2794 ((*i) == 0 ||
2795 (parm_table[*i].ptr !=
2796 parm_table[(*i) - 1].ptr)))
2797 {
2798 int pdiff =
2799 PTR_DIFF(parm_table[*i].ptr,
2800 &sDefault);
2801
2802 if (allparameters ||
2803 !equal_parameter(parm_table[*i].type,
2804 ((char *)pService) +
2805 pdiff,
2806 ((char *)&sDefault) +
2807 pdiff))
2808 {
2809 return &parm_table[(*i)++];
2810 }
2811 }
2812 }
2813 }
2814
2815 return NULL;
2816 }
2817
2818
2819 /***************************************************************************
2820 Return TRUE if the passed service number is within range.
2821 ***************************************************************************/
2822
2823 BOOL lp_snum_ok(int iService)
2824 {
2825 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
2826 }
2827
2828 /***************************************************************************
2829 Auto-load some home services.
2830 ***************************************************************************/
2831
2832 static void lp_add_auto_services(const char *str)
2833 {
2834 return;
2835 }
2836
2837 /***************************************************************************
2838 Auto-load one printer.
2839 ***************************************************************************/
2840
2841 void lp_add_one_printer(char *name, char *comment)
2842 {
2843 int printers = lp_servicenumber(PRINTERS_NAME);
2844 int i;
2845
2846 if (lp_servicenumber(name) < 0) {
2847 lp_add_printer(name, printers);
2848 if ((i = lp_servicenumber(name)) >= 0) {
2849 string_set(&ServicePtrs[i]->comment, comment);
2850 ServicePtrs[i]->autoloaded = True;
2851 }
2852 }
2853 }
2854
2855 /***************************************************************************
2856 Announce ourselves as a print server.
2857 ***************************************************************************/
2858
2859 void update_server_announce_as_printserver(void)
2860 {
2861 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
2862 }
2863
2864 /***************************************************************************
2865 Have we loaded a services file yet?
2866 ***************************************************************************/
2867
2868 BOOL lp_loaded(void)
2869 {
2870 return (bLoaded);
2871 }
2872
2873 /***************************************************************************
2874 Unload unused services.
2875 ***************************************************************************/
2876
2877 void lp_killunused(struct smbsrv_connection *smb, BOOL (*snumused) (struct smbsrv_connection *, int))
2878 {
2879 int i;
2880 for (i = 0; i < iNumServices; i++) {
2881 if (!VALID(i))
2882 continue;
2883
2884 if (!snumused || !snumused(smb, i)) {
2885 ServicePtrs[i]->valid = False;
2886 free_service(ServicePtrs[i]);
2887 }
2888 }
2889 }
2890
2891 /***************************************************************************
2892 Unload a service.
2893 ***************************************************************************/
2894
2895 void lp_killservice(int iServiceIn)
2896 {
2897 if (VALID(iServiceIn)) {
2898 ServicePtrs[iServiceIn]->valid = False;
2899 free_service(ServicePtrs[iServiceIn]);
2900 }
2901 }
2902
2903 /*******************************************************************
2904 Set the server type we will announce as via nmbd.
2905 ********************************************************************/
2906
2907 static void set_server_role(void)
2908 {
2909 server_role = ROLE_STANDALONE;
2910
2911 switch (lp_security()) {
2912 case SEC_SHARE:
2913 if (lp_domain_logons())
2914 DEBUG(0, ("Server's Role (logon server) conflicts with share-level security\n"));
2915 break;
2916 case SEC_SERVER:
2917 case SEC_DOMAIN:
2918 case SEC_ADS:
2919 if (lp_domain_logons()) {
2920 if (Globals.bDomainMaster) /* auto or yes */
2921 server_role = ROLE_DOMAIN_PDC;
2922 else
2923 server_role = ROLE_DOMAIN_BDC;
2924 break;
2925 }
2926 server_role = ROLE_DOMAIN_MEMBER;
2927 break;
2928 case SEC_USER:
2929 if (lp_domain_logons()) {
2930
2931 if (Globals.bDomainMaster) /* auto or yes */
2932 server_role = ROLE_DOMAIN_PDC;
2933 else
2934 server_role = ROLE_DOMAIN_BDC;
2935 }
2936 break;
2937 default:
2938 DEBUG(0, ("Server's Role undefined due to unknown security mode\n"));
2939 break;
2940 }
2941
2942 DEBUG(10, ("set_server_role: role = "));
2943
2944 switch(server_role) {
2945 case ROLE_STANDALONE:
2946 DEBUGADD(10, ("ROLE_STANDALONE\n"));
2947 break;
2948 case ROLE_DOMAIN_MEMBER:
2949 DEBUGADD(10, ("ROLE_DOMAIN_MEMBER\n"));
2950 break;
2951 case ROLE_DOMAIN_BDC:
2952 DEBUGADD(10, ("ROLE_DOMAIN_BDC\n"));
2953 break;
2954 case ROLE_DOMAIN_PDC:
2955 DEBUGADD(10, ("ROLE_DOMAIN_PDC\n"));
2956 break;
2957 }
2958 }
2959
2960 /***************************************************************************
2961 Load the services array from the services file. Return True on success,
2962 False on failure.
2963 ***************************************************************************/
2964
2965 BOOL lp_load(const char *pszFname)
2966 {
2967 pstring n2;
2968 BOOL bRetval;
2969 struct param_opt *data;
2970
2971 pstrcpy(n2, pszFname);
2972 standard_sub_basic(n2,sizeof(n2));
2973
2974 add_to_file_list(pszFname, n2);
2975
2976 bRetval = False;
2977
2978 DEBUG(2, ("lp_load: refreshing parameters from %s\n", pszFname));
2979
2980 bInGlobalSection = True;
2981
2982 if (Globals.param_opt != NULL) {
2983 struct param_opt *next;
2984 for (data=Globals.param_opt; data; data=next) {
2985 next = data->next;
2986 if (data->flags & FLAG_CMDLINE) continue;
2987 free(data->key);
2988 free(data->value);
2989 DLIST_REMOVE(Globals.param_opt, data);
2990 free(data);
2991 }
2992 }
2993
2994 init_globals();
2995
2996 /* We get sections first, so have to start 'behind' to make up */
2997 iServiceIndex = -1;
2998 bRetval = pm_process(n2, do_section, do_parameter);
2999
3000 /* finish up the last section */
3001 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
3002 if (bRetval)
3003 if (iServiceIndex >= 0)
3004 bRetval = service_ok(iServiceIndex);
3005
3006 lp_add_auto_services(lp_auto_services());
3007
3008 /* When 'restrict anonymous = 2' guest connections to ipc$
3009 are denied */
3010 lp_add_hidden("IPC$", "IPC", (lp_restrict_anonymous() < 2));
3011 lp_add_hidden("ADMIN$", "DISK", False);
3012
3013 set_server_role();
3014 set_default_server_announce_type();
3015
3016 bLoaded = True;
3017
3018 /* Now we check bWINSsupport and set szWINSserver to 127.0.0.1 */
3019 /* if bWINSsupport is true and we are in the client */
3020 if (in_client && Globals.bWINSsupport) {
3021 lp_do_parameter(-1, "wins server", "127.0.0.1");
3022 }
3023
3024 init_iconv();
3025
3026 return (bRetval);
3027 }
3028
3029 /***************************************************************************
3030 Reset the max number of services.
3031 ***************************************************************************/
3032
3033 void lp_resetnumservices(void)
3034 {
3035 iNumServices = 0;
3036 }
3037
3038 /***************************************************************************
3039 Return the max number of services.
3040 ***************************************************************************/
3041
3042 int lp_numservices(void)
3043 {
3044 return (iNumServices);
3045 }
3046
3047 /***************************************************************************
3048 Display the contents of the services array in human-readable form.
3049 ***************************************************************************/
3050
3051 void lp_dump(FILE *f, BOOL show_defaults, int maxtoprint)
3052 {
3053 int iService;
3054
3055 if (show_defaults)
3056 defaults_saved = False;
3057
3058 dump_globals(f);
3059
3060 dump_a_service(&sDefault, f);
3061
3062 for (iService = 0; iService < maxtoprint; iService++)
3063 lp_dump_one(f, show_defaults, iService);
3064 }
3065
3066 /***************************************************************************
3067 Display the contents of one service in human-readable form.
3068 ***************************************************************************/
3069
3070 void lp_dump_one(FILE * f, BOOL show_defaults, int snum)
3071 {
3072 if (VALID(snum)) {
3073 if (ServicePtrs[snum]->szService[0] == '\0')
3074 return;
3075 dump_a_service(ServicePtrs[snum], f);
3076 }
3077 }
3078
3079 /***************************************************************************
3080 Return the number of the service with the given name, or -1 if it doesn't
3081 exist. Note that this is a DIFFERENT ANIMAL from the internal function
3082 getservicebyname()! This works ONLY if all services have been loaded, and
3083 does not copy the found service.
3084 ***************************************************************************/
3085
3086 int lp_servicenumber(const char *pszServiceName)
3087 {
3088 int iService;
3089 fstring serviceName;
3090
3091
3092 for (iService = iNumServices - 1; iService >= 0; iService--) {
3093 if (VALID(iService) && ServicePtrs[iService]->szService) {
3094 /*
3095 * The substitution here is used to support %U is
3096 * service names
3097 */
3098 fstrcpy(serviceName, ServicePtrs[iService]->szService);
3099 standard_sub_basic(serviceName,sizeof(serviceName));
3100 if (strequal(serviceName, pszServiceName))
3101 break;
3102 }
3103 }
3104
3105 if (iService < 0)
3106 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
3107
3108 return (iService);
3109 }
3110
3111 /*******************************************************************
3112 A useful volume label function.
3113 ********************************************************************/
3114 const char *volume_label(int snum)
3115 {
3116 const char *ret = lp_volume(snum);
3117 if (!*ret)
3118 return lp_servicename(snum);
3119 return (ret);
3120 }
3121
3122
3123 /*******************************************************************
3124 Set the server type we will announce as via nmbd.
3125 ********************************************************************/
3126
3127 static void set_default_server_announce_type(void)
3128 {
3129 default_server_announce = 0;
3130 default_server_announce |= SV_TYPE_WORKSTATION;
3131 default_server_announce |= SV_TYPE_SERVER;
3132 default_server_announce |= SV_TYPE_SERVER_UNIX;
3133
3134 switch (lp_announce_as()) {
3135 case ANNOUNCE_AS_NT_SERVER:
3136 default_server_announce |= SV_TYPE_SERVER_NT;
3137 /* fall through... */
3138 case ANNOUNCE_AS_NT_WORKSTATION:
3139 default_server_announce |= SV_TYPE_NT;
3140 break;
3141 case ANNOUNCE_AS_WIN95:
3142 default_server_announce |= SV_TYPE_WIN95_PLUS;
3143 break;
3144 case ANNOUNCE_AS_WFW:
3145 default_server_announce |= SV_TYPE_WFW;
3146 break;
3147 default:
3148 break;
3149 }
3150
3151 switch (lp_server_role()) {
3152 case ROLE_DOMAIN_MEMBER:
3153 default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
3154 break;
3155 case ROLE_DOMAIN_PDC:
3156 default_server_announce |= SV_TYPE_DOMAIN_CTRL;
3157 break;
3158 case ROLE_DOMAIN_BDC:
3159 default_server_announce |= SV_TYPE_DOMAIN_BAKCTRL;
3160 break;
3161 case ROLE_STANDALONE:
3162 default:
3163 break;
3164 }
3165 if (lp_time_server())
3166 default_server_announce |= SV_TYPE_TIME_SOURCE;
3167
3168 if (lp_host_msdfs())
3169 default_server_announce |= SV_TYPE_DFS_SERVER;
3170
3171 /* TODO: only announce us as print server when we are a print server */
3172 default_server_announce |= SV_TYPE_PRINTQ_SERVER;
3173 }
3174
3175 /***********************************************************
3176 returns role of Samba server
3177 ************************************************************/
3178
3179 int lp_server_role(void)
3180 {
3181 return server_role;
3182 }
3183
3184 /***********************************************************
3185 If we are PDC then prefer us as DMB
3186 ************************************************************/
3187
3188 BOOL lp_domain_master(void)
3189 {
3190 if (Globals.bDomainMaster == Auto)
3191 return (lp_server_role() == ROLE_DOMAIN_PDC);
3192
3193 return Globals.bDomainMaster;
3194 }
3195
3196 /***********************************************************
3197 If we are DMB then prefer us as LMB
3198 ************************************************************/
3199
3200 BOOL lp_preferred_master(void)
3201 {
3202 if (Globals.bPreferredMaster == Auto)
3203 return (lp_local_master() && lp_domain_master());
3204
3205 return Globals.bPreferredMaster;
3206 }
3207
3208 /*******************************************************************
3209 Remove a service.
3210 ********************************************************************/
3211
3212 void lp_remove_service(int snum)
3213 {
3214 ServicePtrs[snum]->valid = False;
3215 }
3216
3217 /*******************************************************************
3218 Copy a service.
3219 ********************************************************************/
3220
3221 void lp_copy_service(int snum, const char *new_name)
3222 {
3223 const char *oldname = lp_servicename(snum);
3224 do_section(new_name);
3225 if (snum >= 0) {
3226 snum = lp_servicenumber(new_name);
3227 if (snum >= 0)
3228 lp_do_parameter(snum, "copy", oldname);
3229 }
3230 }
3231
3232
3233 /*******************************************************************
3234 Get the default server type we will announce as via nmbd.
3235 ********************************************************************/
3236 int lp_default_server_announce(void)
3237 {
3238 return default_server_announce;
3239 }
3240
3241 const char *lp_printername(int snum)
3242 {
3243 const char *ret = _lp_printername(snum);
3244 if (ret == NULL || (ret != NULL && *ret == '\0'))
3245 ret = lp_const_servicename(snum);
3246
3247 return ret;
3248 }
3249
3250
3251 /*******************************************************************
3252 Return the max print jobs per queue.
3253 ********************************************************************/
3254
3255 int lp_maxprintjobs(int snum)
3256 {
3257 int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
3258 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
3259 maxjobs = PRINT_MAX_JOBID - 1;
3260
3261 return maxjobs;
3262 }