?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r20949: Looking over some lcov output, try and walk some error paths.
[Samba.git] / source / param / loadparm.c
blob98724a107dd84bd1971f0dc36ae07ed0e9fefc0c
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 "pstring.h"
59 #include "system/time.h"
60 #include "system/locale.h"
61 #include "system/network.h" /* needed for TCP_NODELAY */
62 #include "smb_server/smb_server.h"
63 #include "libcli/raw/signing.h"
64 #include "lib/util/dlinklist.h"
65 #include "param/loadparm.h"
66
67 static BOOL bLoaded = False;
68
69 #define standard_sub_basic(str,len)
70
71 /* some helpful bits */
72 #define LP_SNUM_OK(i) (((i) >= 0) && ((i) < iNumServices) && ServicePtrs[(i)]->valid)
73 #define VALID(i) ServicePtrs[i]->valid
74
75 static BOOL do_parameter(const char *, const char *, void *);
76 static BOOL do_parameter_var(const char *pszParmName, const char *fmt, ...);
77
78 static BOOL defaults_saved = False;
79
80
81 struct param_opt {
82 struct param_opt *prev, *next;
83 char *key;
84 char *value;
85 int flags;
86 };
87
88 /*
89 * This structure describes global (ie., server-wide) parameters.
90 */
91 typedef struct
92 {
93 int server_role;
94
95 char **smb_ports;
96 char *dos_charset;
97 char *unix_charset;
98 char *ncalrpc_dir;
99 char *display_charset;
100 char *szLockDir;
101 char *szModulesDir;
102 char *szPidDir;
103 char *szSetupDir;
104 char *szServerString;
105 char *szAutoServices;
106 char *szPasswdChat;
107 char *szConfigFile;
108 char *szShareBackend;
109 char *szSAM_URL;
110 char *szSECRETS_URL;
111 char *szSPOOLSS_URL;
112 char *szWINS_CONFIG_URL;
113 char *szWINS_URL;
114 char *szPrivateDir;
115 char **jsInclude;
116 char *jsonrpcServicesDir;
117 char **szPasswordServers;
118 char *szSocketOptions;
119 char *szRealm;
120 char **szWINSservers;
121 char **szInterfaces;
122 char *szSocketAddress;
123 char *szAnnounceVersion; /* This is initialised in init_globals */
124 char *szWorkgroup;
125 char *szNetbiosName;
126 char **szNetbiosAliases;
127 char *szNetbiosScope;
128 char *szDomainOtherSIDs;
129 char **szNameResolveOrder;
130 char **dcerpc_ep_servers;
131 char **server_services;
132 char *ntptr_providor;
133 char *szWinbindSeparator;
134 char *szWinbinddSocketDirectory;
135 int bWinbindSealedPipes;
136 char *webapps_directory;
137 int tls_enabled;
138 char *tls_keyfile;
139 char *tls_certfile;
140 char *tls_cafile;
141 char *tls_crlfile;
142 char *tls_dhpfile;
143 int max_mux;
144 int max_xmit;
145 int pwordlevel;
146 int srv_maxprotocol;
147 int srv_minprotocol;
148 int cli_maxprotocol;
149 int cli_minprotocol;
150 int security;
151 char **AuthMethods;
152 int paranoid_server_security;
153 int max_wins_ttl;
154 int min_wins_ttl;
155 int announce_as; /* This is initialised in init_globals */
156 int nbt_port;
157 int dgram_port;
158 int cldap_port;
159 int krb5_port;
160 int kpasswd_port;
161 int web_port;
162 char *socket_options;
163 int bWINSsupport;
164 int bWINSdnsProxy;
165 char *szWINSHook;
166 int bLocalMaster;
167 int bPreferredMaster;
168 int bEncryptPasswords;
169 int bNullPasswords;
170 int bObeyPamRestrictions;
171 int bLargeReadwrite;
172 int bReadRaw;
173 int bWriteRaw;
174 int bTimeServer;
175 int bBindInterfacesOnly;
176 int bNTSmbSupport;
177 int bNTStatusSupport;
178 int bLanmanAuth;
179 int bNTLMAuth;
180 int bUseSpnego;
181 int server_signing;
182 int client_signing;
183 int bClientPlaintextAuth;
184 int bClientLanManAuth;
185 int bClientNTLMv2Auth;
186 int client_use_spnego_principal;
187 int bHostMSDfs;
188 int bUnicode;
189 int bUnixExtensions;
190 int bDisableNetbios;
191 int bRpcBigEndian;
192 struct param_opt *param_opt;
193 }
194 global;
195
196 static global Globals;
197
198 /*
199 * This structure describes a single service.
200 */
201 typedef struct
202 {
203 int valid;
204 char *szService;
205 char *szPath;
206 char *szCopy;
207 char *szInclude;
208 char *szPrintername;
209 char **szHostsallow;
210 char **szHostsdeny;
211 char *comment;
212 char *volume;
213 char *fstype;
214 char **ntvfs_handler;
215 int iMaxPrintJobs;
216 int iMaxConnections;
217 int iCSCPolicy;
218 int bAvailable;
219 int bBrowseable;
220 int bRead_only;
221 int bPrint_ok;
222 int bMap_system;
223 int bMap_hidden;
224 int bMap_archive;
225 int bStrictLocking;
226 int *copymap;
227 int bMSDfsRoot;
228 int bStrictSync;
229 int bCIFileSystem;
230 struct param_opt *param_opt;
231
232 char dummy[3]; /* for alignment */
233 }
234 service;
235
236
237 /* This is a default service used to prime a services structure */
238 static service sDefault = {
239 True, /* valid */
240 NULL, /* szService */
241 NULL, /* szPath */
242 NULL, /* szCopy */
243 NULL, /* szInclude */
244 NULL, /* szPrintername */
245 NULL, /* szHostsallow */
246 NULL, /* szHostsdeny */
247 NULL, /* comment */
248 NULL, /* volume */
249 NULL, /* fstype */
250 NULL, /* ntvfs_handler */
251 1000, /* iMaxPrintJobs */
252 0, /* iMaxConnections */
253 0, /* iCSCPolicy */
254 True, /* bAvailable */
255 True, /* bBrowseable */
256 True, /* bRead_only */
257 False, /* bPrint_ok */
258 False, /* bMap_system */
259 False, /* bMap_hidden */
260 True, /* bMap_archive */
261 True, /* bStrictLocking */
262 NULL, /* copymap */
263 False, /* bMSDfsRoot */
264 False, /* bStrictSync */
265 False, /* bCIFileSystem */
266 NULL, /* Parametric options */
267
268 "" /* dummy */
269 };
270
271 /* local variables */
272 static service **ServicePtrs = NULL;
273 static int iNumServices = 0;
274 static int iServiceIndex = 0;
275 static BOOL bInGlobalSection = True;
276
277 #define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
278
279 /* prototypes for the special type handlers */
280 static BOOL handle_include(const char *pszParmValue, char **ptr);
281 static BOOL handle_copy(const char *pszParmValue, char **ptr);
282
283 static const struct enum_list enum_protocol[] = {
284 {PROTOCOL_SMB2, "SMB2"},
285 {PROTOCOL_NT1, "NT1"},
286 {PROTOCOL_LANMAN2, "LANMAN2"},
287 {PROTOCOL_LANMAN1, "LANMAN1"},
288 {PROTOCOL_CORE, "CORE"},
289 {PROTOCOL_COREPLUS, "COREPLUS"},
290 {PROTOCOL_COREPLUS, "CORE+"},
291 {-1, NULL}
292 };
293
294 static const struct enum_list enum_security[] = {
295 {SEC_SHARE, "SHARE"},
296 {SEC_USER, "USER"},
297 {-1, NULL}
298 };
299
300 static const struct enum_list enum_announce_as[] = {
301 {ANNOUNCE_AS_NT_SERVER, "NT"},
302 {ANNOUNCE_AS_NT_SERVER, "NT Server"},
303 {ANNOUNCE_AS_NT_WORKSTATION, "NT Workstation"},
304 {ANNOUNCE_AS_WIN95, "win95"},
305 {ANNOUNCE_AS_WFW, "WfW"},
306 {-1, NULL}
307 };
308
309 static const struct enum_list enum_bool_auto[] = {
310 {False, "No"},
311 {False, "False"},
312 {False, "0"},
313 {True, "Yes"},
314 {True, "True"},
315 {True, "1"},
316 {Auto, "Auto"},
317 {-1, NULL}
318 };
319
320 /* Client-side offline caching policy types */
321 #define CSC_POLICY_MANUAL 0
322 #define CSC_POLICY_DOCUMENTS 1
323 #define CSC_POLICY_PROGRAMS 2
324 #define CSC_POLICY_DISABLE 3
325
326 static const struct enum_list enum_csc_policy[] = {
327 {CSC_POLICY_MANUAL, "manual"},
328 {CSC_POLICY_DOCUMENTS, "documents"},
329 {CSC_POLICY_PROGRAMS, "programs"},
330 {CSC_POLICY_DISABLE, "disable"},
331 {-1, NULL}
332 };
333
334 /* SMB signing types. */
335 static const struct enum_list enum_smb_signing_vals[] = {
336 {SMB_SIGNING_OFF, "No"},
337 {SMB_SIGNING_OFF, "False"},
338 {SMB_SIGNING_OFF, "0"},
339 {SMB_SIGNING_OFF, "Off"},
340 {SMB_SIGNING_OFF, "disabled"},
341 {SMB_SIGNING_SUPPORTED, "Yes"},
342 {SMB_SIGNING_SUPPORTED, "True"},
343 {SMB_SIGNING_SUPPORTED, "1"},
344 {SMB_SIGNING_SUPPORTED, "On"},
345 {SMB_SIGNING_SUPPORTED, "enabled"},
346 {SMB_SIGNING_REQUIRED, "required"},
347 {SMB_SIGNING_REQUIRED, "mandatory"},
348 {SMB_SIGNING_REQUIRED, "force"},
349 {SMB_SIGNING_REQUIRED, "forced"},
350 {SMB_SIGNING_REQUIRED, "enforced"},
351 {SMB_SIGNING_AUTO, "auto"},
352 {-1, NULL}
353 };
354
355 static const struct enum_list enum_server_role[] = {
356 {ROLE_STANDALONE, "standalone"},
357 {ROLE_DOMAIN_MEMBER, "member server"},
358 {ROLE_DOMAIN_CONTROLLER, "domain controller"},
359 {-1, NULL}
360 };
361
362
363 /* Note: We do not initialise the defaults union - it is not allowed in ANSI C
364 *
365 * Note: We have a flag called FLAG_DEVELOPER but is not used at this time, it
366 * is implied in current control logic. This may change at some later time. A
367 * flag value of 0 means - show as development option only.
368 *
369 * The FLAG_HIDE is explicit. Paramters set this way do NOT appear in any edit
370 * screen in SWAT. This is used to exclude parameters as well as to squash all
371 * parameters that have been duplicated by pseudonyms.
372 */
373 static struct parm_struct parm_table[] = {
374 {"Base Options", P_SEP, P_SEPARATOR},
375
376 {"server role", P_ENUM, P_GLOBAL, &Globals.server_role, NULL, enum_server_role, FLAG_BASIC},
377
378 {"dos charset", P_STRING, P_GLOBAL, &Globals.dos_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
379 {"unix charset", P_STRING, P_GLOBAL, &Globals.unix_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
380 {"ncalrpc dir", P_STRING, P_GLOBAL, &Globals.ncalrpc_dir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
381 {"display charset", P_STRING, P_GLOBAL, &Globals.display_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
382 {"comment", P_STRING, P_LOCAL, &sDefault.comment, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
383 {"path", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
384 {"directory", P_STRING, P_LOCAL, &sDefault.szPath, NULL, NULL, FLAG_HIDE},
385 {"workgroup", P_USTRING, P_GLOBAL, &Globals.szWorkgroup, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
386 {"realm", P_STRING, P_GLOBAL, &Globals.szRealm, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
387 {"netbios name", P_USTRING, P_GLOBAL, &Globals.szNetbiosName, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
388 {"netbios aliases", P_LIST, P_GLOBAL, &Globals.szNetbiosAliases, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
389 {"netbios scope", P_USTRING, P_GLOBAL, &Globals.szNetbiosScope, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
390 {"server string", P_STRING, P_GLOBAL, &Globals.szServerString, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
391 {"interfaces", P_LIST, P_GLOBAL, &Globals.szInterfaces, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
392 {"bind interfaces only", P_BOOL, P_GLOBAL, &Globals.bBindInterfacesOnly, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
393 {"ntvfs handler", P_LIST, P_LOCAL, &sDefault.ntvfs_handler, NULL, NULL, FLAG_ADVANCED},
394 {"ntptr providor", P_STRING, P_GLOBAL, &Globals.ntptr_providor, NULL, NULL, FLAG_ADVANCED},
395 {"dcerpc endpoint servers", P_LIST, P_GLOBAL, &Globals.dcerpc_ep_servers, NULL, NULL, FLAG_ADVANCED},
396 {"server services", P_LIST, P_GLOBAL, &Globals.server_services, NULL, NULL, FLAG_ADVANCED},
397
398 {"Security Options", P_SEP, P_SEPARATOR},
399
400 {"security", P_ENUM, P_GLOBAL, &Globals.security, NULL, enum_security, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
401 {"auth methods", P_LIST, P_GLOBAL, &Globals.AuthMethods, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
402 {"encrypt passwords", P_BOOL, P_GLOBAL, &Globals.bEncryptPasswords, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
403 {"null passwords", P_BOOL, P_GLOBAL, &Globals.bNullPasswords, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
404 {"obey pam restrictions", P_BOOL, P_GLOBAL, &Globals.bObeyPamRestrictions, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
405 {"password server", P_LIST, P_GLOBAL, &Globals.szPasswordServers, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
406 {"sam database", P_STRING, P_GLOBAL, &Globals.szSAM_URL, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
407 {"secrets database", P_STRING, P_GLOBAL, &Globals.szSECRETS_URL, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
408 {"spoolss database", P_STRING, P_GLOBAL, &Globals.szSPOOLSS_URL, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
409 {"wins config database", P_STRING, P_GLOBAL, &Globals.szWINS_CONFIG_URL, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
410 {"wins database", P_STRING, P_GLOBAL, &Globals.szWINS_URL, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
411 {"private dir", P_STRING, P_GLOBAL, &Globals.szPrivateDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
412 {"passwd chat", P_STRING, P_GLOBAL, &Globals.szPasswdChat, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
413 {"password level", P_INTEGER, P_GLOBAL, &Globals.pwordlevel, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
414 {"lanman auth", P_BOOL, P_GLOBAL, &Globals.bLanmanAuth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
415 {"ntlm auth", P_BOOL, P_GLOBAL, &Globals.bNTLMAuth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
416 {"client NTLMv2 auth", P_BOOL, P_GLOBAL, &Globals.bClientNTLMv2Auth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
417 {"client lanman auth", P_BOOL, P_GLOBAL, &Globals.bClientLanManAuth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
418 {"client plaintext auth", P_BOOL, P_GLOBAL, &Globals.bClientPlaintextAuth, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
419 {"client use spnego principal", P_BOOL, P_GLOBAL, &Globals.client_use_spnego_principal, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
420
421 {"read only", P_BOOL, P_LOCAL, &sDefault.bRead_only, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE},
422
423 {"hosts allow", P_LIST, P_LOCAL, &sDefault.szHostsallow, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
424 {"hosts deny", P_LIST, P_LOCAL, &sDefault.szHostsdeny, NULL, NULL, FLAG_GLOBAL | FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
425
426 {"Logging Options", P_SEP, P_SEPARATOR},
427
428 {"log level", P_INTEGER, P_GLOBAL, &DEBUGLEVEL, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
429 {"debuglevel", P_INTEGER, P_GLOBAL, &DEBUGLEVEL, NULL, NULL, FLAG_HIDE},
430 {"log file", P_STRING, P_GLOBAL, &logfile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
431
432 {"Protocol Options", P_SEP, P_SEPARATOR},
433
434 {"smb ports", P_LIST, P_GLOBAL, &Globals.smb_ports, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
435 {"nbt port", P_INTEGER, P_GLOBAL, &Globals.nbt_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
436 {"dgram port", P_INTEGER, P_GLOBAL, &Globals.dgram_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
437 {"cldap port", P_INTEGER, P_GLOBAL, &Globals.cldap_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
438 {"krb5 port", P_INTEGER, P_GLOBAL, &Globals.krb5_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
439 {"kpasswd port", P_INTEGER, P_GLOBAL, &Globals.kpasswd_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
440 {"web port", P_INTEGER, P_GLOBAL, &Globals.web_port, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
441 {"tls enabled", P_BOOL, P_GLOBAL, &Globals.tls_enabled, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
442 {"tls keyfile", P_STRING, P_GLOBAL, &Globals.tls_keyfile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
443 {"tls certfile", P_STRING, P_GLOBAL, &Globals.tls_certfile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
444 {"tls cafile", P_STRING, P_GLOBAL, &Globals.tls_cafile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
445 {"tls crlfile", P_STRING, P_GLOBAL, &Globals.tls_crlfile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
446 {"tls dh params file", P_STRING, P_GLOBAL, &Globals.tls_dhpfile, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
447 {"web application directory", P_STRING, P_GLOBAL, &Globals.webapps_directory, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
448 {"large readwrite", P_BOOL, P_GLOBAL, &Globals.bLargeReadwrite, NULL, NULL, FLAG_DEVELOPER},
449 {"server max protocol", P_ENUM, P_GLOBAL, &Globals.srv_maxprotocol, NULL, enum_protocol, FLAG_DEVELOPER},
450 {"server min protocol", P_ENUM, P_GLOBAL, &Globals.srv_minprotocol, NULL, enum_protocol, FLAG_DEVELOPER},
451 {"client max protocol", P_ENUM, P_GLOBAL, &Globals.cli_maxprotocol, NULL, enum_protocol, FLAG_DEVELOPER},
452 {"client min protocol", P_ENUM, P_GLOBAL, &Globals.cli_minprotocol, NULL, enum_protocol, FLAG_DEVELOPER},
453 {"unicode", P_BOOL, P_GLOBAL, &Globals.bUnicode, NULL, NULL, FLAG_DEVELOPER},
454 {"read raw", P_BOOL, P_GLOBAL, &Globals.bReadRaw, NULL, NULL, FLAG_DEVELOPER},
455 {"write raw", P_BOOL, P_GLOBAL, &Globals.bWriteRaw, NULL, NULL, FLAG_DEVELOPER},
456 {"disable netbios", P_BOOL, P_GLOBAL, &Globals.bDisableNetbios, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
457
458 {"nt status support", P_BOOL, P_GLOBAL, &Globals.bNTStatusSupport, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
459
460 {"announce version", P_STRING, P_GLOBAL, &Globals.szAnnounceVersion, NULL, NULL, FLAG_DEVELOPER},
461 {"announce as", P_ENUM, P_GLOBAL, &Globals.announce_as, NULL, enum_announce_as, FLAG_DEVELOPER},
462 {"max mux", P_INTEGER, P_GLOBAL, &Globals.max_mux, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
463 {"max xmit", P_BYTES, P_GLOBAL, &Globals.max_xmit, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
464
465 {"name resolve order", P_LIST, P_GLOBAL, &Globals.szNameResolveOrder, NULL, NULL, FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
466 {"max wins ttl", P_INTEGER, P_GLOBAL, &Globals.max_wins_ttl, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
467 {"min wins ttl", P_INTEGER, P_GLOBAL, &Globals.min_wins_ttl, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
468 {"time server", P_BOOL, P_GLOBAL, &Globals.bTimeServer, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
469 {"unix extensions", P_BOOL, P_GLOBAL, &Globals.bUnixExtensions, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
470 {"use spnego", P_BOOL, P_GLOBAL, &Globals.bUseSpnego, NULL, NULL, FLAG_DEVELOPER},
471 {"server signing", P_ENUM, P_GLOBAL, &Globals.server_signing, NULL, enum_smb_signing_vals, FLAG_ADVANCED},
472 {"client signing", P_ENUM, P_GLOBAL, &Globals.client_signing, NULL, enum_smb_signing_vals, FLAG_ADVANCED},
473 {"rpc big endian", P_BOOL, P_GLOBAL, &Globals.bRpcBigEndian, NULL, NULL, FLAG_DEVELOPER},
474
475 {"Tuning Options", P_SEP, P_SEPARATOR},
476
477 {"max connections", P_INTEGER, P_LOCAL, &sDefault.iMaxConnections, NULL, NULL, FLAG_SHARE},
478 {"paranoid server security", P_BOOL, P_GLOBAL, &Globals.paranoid_server_security, NULL, NULL, FLAG_DEVELOPER},
479 {"socket options", P_STRING, P_GLOBAL, &Globals.socket_options, NULL, NULL, FLAG_DEVELOPER},
480
481 {"strict sync", P_BOOL, P_LOCAL, &sDefault.bStrictSync, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
482 {"case insensitive filesystem", P_BOOL, P_LOCAL, &sDefault.bCIFileSystem, NULL, NULL, FLAG_ADVANCED | FLAG_SHARE},
483
484 {"Printing Options", P_SEP, P_SEPARATOR},
485
486 {"max print jobs", P_INTEGER, P_LOCAL, &sDefault.iMaxPrintJobs, NULL, NULL, FLAG_PRINT},
487 {"printable", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_PRINT},
488 {"print ok", P_BOOL, P_LOCAL, &sDefault.bPrint_ok, NULL, NULL, FLAG_HIDE},
489
490 {"printer name", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_PRINT},
491 {"printer", P_STRING, P_LOCAL, &sDefault.szPrintername, NULL, NULL, FLAG_HIDE},
492
493 {"Filename Handling", P_SEP, P_SEPARATOR},
494
495 {"map system", P_BOOL, P_LOCAL, &sDefault.bMap_system, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
496 {"map hidden", P_BOOL, P_LOCAL, &sDefault.bMap_hidden, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
497 {"map archive", P_BOOL, P_LOCAL, &sDefault.bMap_archive, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
498
499 {"Domain Options", P_SEP, P_SEPARATOR},
500
501 {"Logon Options", P_SEP, P_SEPARATOR},
502
503
504 {"Browse Options", P_SEP, P_SEPARATOR},
505
506 {"preferred master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
507 {"prefered master", P_ENUM, P_GLOBAL, &Globals.bPreferredMaster, NULL, enum_bool_auto, FLAG_HIDE},
508 {"local master", P_BOOL, P_GLOBAL, &Globals.bLocalMaster, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_DEVELOPER},
509 {"browseable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT | FLAG_DEVELOPER},
510 {"browsable", P_BOOL, P_LOCAL, &sDefault.bBrowseable, NULL, NULL, FLAG_HIDE},
511
512 {"WINS Options", P_SEP, P_SEPARATOR},
513
514 {"wins server", P_LIST, P_GLOBAL, &Globals.szWINSservers, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
515 {"wins support", P_BOOL, P_GLOBAL, &Globals.bWINSsupport, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
516 {"dns proxy", P_BOOL, P_GLOBAL, &Globals.bWINSdnsProxy, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_WIZARD | FLAG_DEVELOPER},
517 {"wins hook", P_STRING, P_GLOBAL, &Globals.szWINSHook, NULL, NULL, FLAG_ADVANCED},
518
519 {"Locking Options", P_SEP, P_SEPARATOR},
520
521 {"csc policy", P_ENUM, P_LOCAL, &sDefault.iCSCPolicy, NULL, enum_csc_policy, FLAG_SHARE | FLAG_GLOBAL},
522
523 {"strict locking", P_BOOL, P_LOCAL, &sDefault.bStrictLocking, NULL, NULL, FLAG_SHARE | FLAG_GLOBAL},
524
525 {"Miscellaneous Options", P_SEP, P_SEPARATOR},
526
527 {"config file", P_STRING, P_GLOBAL, &Globals.szConfigFile, NULL, NULL, FLAG_HIDE},
528 {"share backend", P_STRING, P_GLOBAL, &Globals.szShareBackend, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
529 {"preload", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
530 {"auto services", P_STRING, P_GLOBAL, &Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
531 {"lock dir", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_HIDE},
532 {"lock directory", P_STRING, P_GLOBAL, &Globals.szLockDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
533 {"modules dir", P_STRING, P_GLOBAL, &Globals.szModulesDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
534 {"pid directory", P_STRING, P_GLOBAL, &Globals.szPidDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
535 {"js include", P_LIST, P_GLOBAL, &Globals.jsInclude, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
536 {"jsonrpc services directory", P_STRING, P_GLOBAL, &Globals.jsonrpcServicesDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
537 {"setup directory", P_STRING, P_GLOBAL, &Globals.szSetupDir, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
538
539 {"socket address", P_STRING, P_GLOBAL, &Globals.szSocketAddress, NULL, NULL, FLAG_DEVELOPER},
540 {"-valid", P_BOOL, P_LOCAL, &sDefault.valid, NULL, NULL, FLAG_HIDE},
541
542 {"copy", P_STRING, P_LOCAL, &sDefault.szCopy, handle_copy, NULL, FLAG_HIDE},
543 {"include", P_STRING, P_LOCAL, &sDefault.szInclude, handle_include, NULL, FLAG_HIDE},
544
545 {"available", P_BOOL, P_LOCAL, &sDefault.bAvailable, NULL, NULL, FLAG_BASIC | FLAG_ADVANCED | FLAG_SHARE | FLAG_PRINT},
546 {"volume", P_STRING, P_LOCAL, &sDefault.volume, NULL, NULL, FLAG_SHARE },
547 {"fstype", P_STRING, P_LOCAL, &sDefault.fstype, NULL, NULL, FLAG_SHARE},
548
549 {"panic action", P_STRING, P_GLOBAL, &panic_action, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
550
551 {"msdfs root", P_BOOL, P_LOCAL, &sDefault.bMSDfsRoot, NULL, NULL, FLAG_SHARE},
552 {"host msdfs", P_BOOL, P_GLOBAL, &Globals.bHostMSDfs, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
553 {"winbind separator", P_STRING, P_GLOBAL, &Globals.szWinbindSeparator, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER },
554 {"winbindd socket directory", P_STRING, P_GLOBAL, &Globals.szWinbinddSocketDirectory, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER },
555 {"winbind sealed pipes", P_BOOL, P_GLOBAL, &Globals.bWinbindSealedPipes, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER },
556
557 {NULL, P_BOOL, P_NONE, NULL, NULL, NULL, 0}
558 };
559
560
561 /*
562 return the parameter table
563 */
564 struct parm_struct *lp_parm_table(void)
565 {
566 return parm_table;
567 }
568
569 /***************************************************************************
570 Initialise the global parameter structure.
571 ***************************************************************************/
572 static void init_globals(void)
573 {
574 int i;
575 char *myname;
576
577 DEBUG(3, ("Initialising global parameters\n"));
578
579 for (i = 0; parm_table[i].label; i++) {
580 if ((parm_table[i].type == P_STRING ||
581 parm_table[i].type == P_USTRING) &&
582 parm_table[i].ptr &&
583 !(parm_table[i].flags & FLAG_CMDLINE)) {
584 string_set(parm_table[i].ptr, "");
585 }
586 }
587
588 do_parameter("config file", dyn_CONFIGFILE, NULL);
589
590 do_parameter("share backend", "classic", NULL);
591
592 do_parameter("server role", "standalone", NULL);
593
594 /* options that can be set on the command line must be initialised via
595 the slower do_parameter() to ensure that FLAG_CMDLINE is obeyed */
596 #ifdef TCP_NODELAY
597 do_parameter("socket options", "TCP_NODELAY", NULL);
598 #endif
599 do_parameter("workgroup", DEFAULT_WORKGROUP, NULL);
600 myname = get_myname();
601 do_parameter("netbios name", myname, NULL);
602 SAFE_FREE(myname);
603 do_parameter("name resolve order", "lmhosts wins host bcast", NULL);
604
605 do_parameter("fstype", FSTYPE_STRING, NULL);
606 do_parameter("ntvfs handler", "unixuid default", NULL);
607 do_parameter("max connections", "-1", NULL);
608
609 do_parameter("dcerpc endpoint servers", "epmapper srvsvc wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi winreg dssetup unixinfo", NULL);
610 do_parameter("server services", "smb rpc nbt wrepl ldap cldap web kdc winbind", NULL);
611 do_parameter("ntptr providor", "simple_ldb", NULL);
612 do_parameter("auth methods", "anonymous sam_ignoredomain", NULL);
613 do_parameter("private dir", dyn_PRIVATE_DIR, NULL);
614 do_parameter("sam database", "sam.ldb", NULL);
615 do_parameter("secrets database", "secrets.ldb", NULL);
616 do_parameter("spoolss database", "spoolss.ldb", NULL);
617 do_parameter("wins config database", "wins_config.ldb", NULL);
618 do_parameter("wins database", "wins.ldb", NULL);
619 do_parameter("registry:HKEY_LOCAL_MACHINE", "hklm.ldb", NULL);
620
621 /* This hive should be dynamically generated by Samba using
622 data from the sam, but for the moment leave it in a tdb to
623 keep regedt32 from popping up an annoying dialog. */
624 do_parameter("registry:HKEY_USERS", "hku.ldb", NULL);
625
626 /* using UTF8 by default allows us to support all chars */
627 do_parameter("unix charset", "UTF8", NULL);
628
629 /* Use codepage 850 as a default for the dos character set */
630 do_parameter("dos charset", "CP850", NULL);
631
632 /*
633 * Allow the default PASSWD_CHAT to be overridden in local.h.
634 */
635 do_parameter("passwd chat", DEFAULT_PASSWD_CHAT, NULL);
636
637 do_parameter("pid directory", dyn_PIDDIR, NULL);
638 do_parameter("lock dir", dyn_LOCKDIR, NULL);
639 do_parameter("modules dir", dyn_MODULESDIR, NULL);
640 do_parameter("ncalrpc dir", dyn_NCALRPCDIR, NULL);
641
642 do_parameter("socket address", "0.0.0.0", NULL);
643 do_parameter_var("server string", "Samba %s", SAMBA_VERSION_STRING);
644
645 do_parameter_var("announce version", "%d.%d",
646 DEFAULT_MAJOR_VERSION,
647 DEFAULT_MINOR_VERSION);
648
649 do_parameter("password server", "*", NULL);
650
651 do_parameter("max mux", "50", NULL);
652 do_parameter("max xmit", "12288", NULL);
653 do_parameter("password level", "0", NULL);
654 do_parameter("LargeReadwrite", "True", NULL);
655 do_parameter("server min protocol", "CORE", NULL);
656 do_parameter("server max protocol", "NT1", NULL);
657 do_parameter("client min protocol", "CORE", NULL);
658 do_parameter("client max protocol", "NT1", NULL);
659 do_parameter("security", "USER", NULL);
660 do_parameter("paranoid server security", "True", NULL);
661 do_parameter("EncryptPasswords", "True", NULL);
662 do_parameter("ReadRaw", "True", NULL);
663 do_parameter("WriteRaw", "True", NULL);
664 do_parameter("NullPasswords", "False", NULL);
665 do_parameter("ObeyPamRestrictions", "False", NULL);
666 do_parameter("announce as", "NT SERVER", NULL);
667
668 do_parameter("TimeServer", "False", NULL);
669 do_parameter("BindInterfacesOnly", "False", NULL);
670 do_parameter("Unicode", "True", NULL);
671 do_parameter("ClientLanManAuth", "True", NULL);
672 do_parameter("LanmanAuth", "True", NULL);
673 do_parameter("NTLMAuth", "True", NULL);
674 do_parameter("client use spnego principal", "False", NULL);
675
676 do_parameter("UnixExtensions", "False", NULL);
677
678 do_parameter("PreferredMaster", "Auto", NULL);
679 do_parameter("LocalMaster", "True", NULL);
680
681 do_parameter("wins support", "False", NULL);
682 do_parameter("dns proxy", "True", NULL);
683
684 do_parameter("winbind separator", "\\", NULL);
685 do_parameter("winbind sealed pipes", "True", NULL);
686 do_parameter("winbindd socket directory", dyn_WINBINDD_SOCKET_DIR, NULL);
687
688 do_parameter("client signing", "Yes", NULL);
689 do_parameter("server signing", "auto", NULL);
690
691 do_parameter("use spnego", "True", NULL);
692
693 do_parameter("smb ports", "445 139", NULL);
694 do_parameter("nbt port", "137", NULL);
695 do_parameter("dgram port", "138", NULL);
696 do_parameter("cldap port", "389", NULL);
697 do_parameter("krb5 port", "88", NULL);
698 do_parameter("kpasswd port", "464", NULL);
699 do_parameter("web port", "901", NULL);
700 do_parameter("web application directory", dyn_WEBAPPSDIR, NULL);
701 do_parameter("jsonrpc services directory", dyn_SERVICESDIR, NULL);
702
703 do_parameter("nt status support", "True", NULL);
704
705 do_parameter("max wins ttl", "518400", NULL); /* 6 days */
706 do_parameter("min wins ttl", "10", NULL);
707
708 do_parameter("tls enabled", "True", NULL);
709 do_parameter("tls keyfile", "tls/key.pem", NULL);
710 do_parameter("tls certfile", "tls/cert.pem", NULL);
711 do_parameter("tls cafile", "tls/ca.pem", NULL);
712 do_parameter_var("js include", "%s", dyn_JSDIR);
713 do_parameter_var("setup directory", "%s", dyn_SETUPDIR);
714
715 for (i = 0; parm_table[i].label; i++) {
716 if (!(parm_table[i].flags & FLAG_CMDLINE)) {
717 parm_table[i].flags |= FLAG_DEFAULT;
718 }
719 }
720 }
721
722 static TALLOC_CTX *lp_talloc;
723
724 /******************************************************************* a
725 Free up temporary memory - called from the main loop.
726 ********************************************************************/
727
728 void lp_talloc_free(void)
729 {
730 if (!lp_talloc)
731 return;
732 talloc_free(lp_talloc);
733 lp_talloc = NULL;
734 }
735
736 /*******************************************************************
737 Convenience routine to grab string parameters into temporary memory
738 and run standard_sub_basic on them. The buffers can be written to by
739 callers without affecting the source string.
740 ********************************************************************/
741
742 static const char *lp_string(const char *s)
743 {
744 #if 0 /* until REWRITE done to make thread-safe */
745 size_t len = s ? strlen(s) : 0;
746 char *ret;
747 #endif
748
749 /* The follow debug is useful for tracking down memory problems
750 especially if you have an inner loop that is calling a lp_*()
751 function that returns a string. Perhaps this debug should be
752 present all the time? */
753
754 #if 0
755 DEBUG(10, ("lp_string(%s)\n", s));
756 #endif
757
758 #if 0 /* until REWRITE done to make thread-safe */
759 if (!lp_talloc)
760 lp_talloc = talloc_init("lp_talloc");
761
762 ret = talloc_array(lp_talloc, char, len + 100); /* leave room for substitution */
763
764 if (!ret)
765 return NULL;
766
767 if (!s)
768 *ret = 0;
769 else
770 strlcpy(ret, s, len);
771
772 if (trim_string(ret, "\"", "\"")) {
773 if (strchr(ret,'"') != NULL)
774 strlcpy(ret, s, len);
775 }
776
777 standard_sub_basic(ret,len+100);
778 return (ret);
779 #endif
780 return s;
781 }
782
783 /*
784 In this section all the functions that are used to access the
785 parameters from the rest of the program are defined
786 */
787
788 #define FN_GLOBAL_STRING(fn_name,ptr) \
789 const char *fn_name(void) {return(lp_string(*(char **)(ptr) ? *(char **)(ptr) : ""));}
790 #define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
791 const char *fn_name(void) {return(*(const char **)(ptr) ? *(const char **)(ptr) : "");}
792 #define FN_GLOBAL_LIST(fn_name,ptr) \
793 const char **fn_name(void) {return(*(const char ***)(ptr));}
794 #define FN_GLOBAL_BOOL(fn_name,ptr) \
795 BOOL fn_name(void) {return((BOOL)*(int *)(ptr));}
796 #if 0 /* unused */
797 #define FN_GLOBAL_CHAR(fn_name,ptr) \
798 char fn_name(void) {return(*(char *)(ptr));}
799 #endif
800 #define FN_GLOBAL_INTEGER(fn_name,ptr) \
801 int fn_name(void) {return(*(int *)(ptr));}
802
803 #define FN_LOCAL_STRING(fn_name,val) \
804 const char *fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val));}
805 #define FN_LOCAL_CONST_STRING(fn_name,val) \
806 const char *fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && ServicePtrs[(i)]->val) ? ServicePtrs[(i)]->val : sDefault.val);}
807 #define FN_LOCAL_LIST(fn_name,val) \
808 const char **fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
809 #define FN_LOCAL_BOOL(fn_name,val) \
810 BOOL fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
811 #if 0 /* unused */
812 #define FN_LOCAL_CHAR(fn_name,val) \
813 char fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
814 #endif
815 #define FN_LOCAL_INTEGER(fn_name,val) \
816 int fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
817
818 _PUBLIC_ FN_GLOBAL_INTEGER(lp_server_role, &Globals.server_role)
819 _PUBLIC_ FN_GLOBAL_LIST(lp_smb_ports, &Globals.smb_ports)
820 _PUBLIC_ FN_GLOBAL_INTEGER(lp_nbt_port, &Globals.nbt_port)
821 _PUBLIC_ FN_GLOBAL_INTEGER(lp_dgram_port, &Globals.dgram_port)
822 _PUBLIC_ FN_GLOBAL_INTEGER(lp_cldap_port, &Globals.cldap_port)
823 _PUBLIC_ FN_GLOBAL_INTEGER(lp_krb5_port, &Globals.krb5_port)
824 _PUBLIC_ FN_GLOBAL_INTEGER(lp_kpasswd_port, &Globals.kpasswd_port)
825 _PUBLIC_ FN_GLOBAL_INTEGER(lp_web_port, &Globals.web_port)
826 _PUBLIC_ FN_GLOBAL_STRING(lp_dos_charset, &Globals.dos_charset)
827 _PUBLIC_ FN_GLOBAL_STRING(lp_webapps_directory, &Globals.webapps_directory)
828 _PUBLIC_ FN_GLOBAL_BOOL(lp_tls_enabled, &Globals.tls_enabled)
829 _PUBLIC_ FN_GLOBAL_STRING(lp_tls_keyfile, &Globals.tls_keyfile)
830 _PUBLIC_ FN_GLOBAL_STRING(lp_tls_certfile, &Globals.tls_certfile)
831 _PUBLIC_ FN_GLOBAL_STRING(lp_tls_cafile, &Globals.tls_cafile)
832 _PUBLIC_ FN_GLOBAL_STRING(lp_tls_crlfile, &Globals.tls_crlfile)
833 _PUBLIC_ FN_GLOBAL_STRING(lp_tls_dhpfile, &Globals.tls_dhpfile)
834 _PUBLIC_ FN_GLOBAL_STRING(lp_unix_charset, &Globals.unix_charset)
835 _PUBLIC_ FN_GLOBAL_STRING(lp_display_charset, &Globals.display_charset)
836 _PUBLIC_ FN_GLOBAL_STRING(lp_configfile, &Globals.szConfigFile)
837 _PUBLIC_ FN_GLOBAL_STRING(lp_share_backend, &Globals.szShareBackend)
838 _PUBLIC_ FN_GLOBAL_STRING(lp_sam_url, &Globals.szSAM_URL)
839 _PUBLIC_ FN_GLOBAL_STRING(lp_secrets_url, &Globals.szSECRETS_URL)
840 _PUBLIC_ FN_GLOBAL_STRING(lp_spoolss_url, &Globals.szSPOOLSS_URL)
841 _PUBLIC_ FN_GLOBAL_STRING(lp_wins_config_url, &Globals.szWINS_CONFIG_URL)
842 _PUBLIC_ FN_GLOBAL_STRING(lp_wins_url, &Globals.szWINS_URL)
843 _PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbind_separator, &Globals.szWinbindSeparator)
844 _PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbindd_socket_directory, &Globals.szWinbinddSocketDirectory)
845 _PUBLIC_ FN_GLOBAL_BOOL(lp_winbind_sealed_pipes, &Globals.bWinbindSealedPipes)
846 _PUBLIC_ FN_GLOBAL_STRING(lp_private_dir, &Globals.szPrivateDir)
847 _PUBLIC_ FN_GLOBAL_STRING(lp_serverstring, &Globals.szServerString)
848 _PUBLIC_ FN_GLOBAL_STRING(lp_lockdir, &Globals.szLockDir)
849 _PUBLIC_ FN_GLOBAL_STRING(lp_modulesdir, &Globals.szModulesDir)
850 _PUBLIC_ FN_GLOBAL_STRING(lp_setupdir, &Globals.szSetupDir)
851 _PUBLIC_ FN_GLOBAL_STRING(lp_ncalrpc_dir, &Globals.ncalrpc_dir)
852 _PUBLIC_ FN_GLOBAL_STRING(lp_piddir, &Globals.szPidDir)
853 _PUBLIC_ FN_GLOBAL_LIST(lp_dcerpc_endpoint_servers, &Globals.dcerpc_ep_servers)
854 _PUBLIC_ FN_GLOBAL_LIST(lp_server_services, &Globals.server_services)
855 _PUBLIC_ FN_GLOBAL_STRING(lp_ntptr_providor, &Globals.ntptr_providor)
856 _PUBLIC_ FN_GLOBAL_STRING(lp_auto_services, &Globals.szAutoServices)
857 _PUBLIC_ FN_GLOBAL_STRING(lp_passwd_chat, &Globals.szPasswdChat)
858 _PUBLIC_ FN_GLOBAL_LIST(lp_passwordserver, &Globals.szPasswordServers)
859 _PUBLIC_ FN_GLOBAL_LIST(lp_name_resolve_order, &Globals.szNameResolveOrder)
860 _PUBLIC_ FN_GLOBAL_STRING(lp_realm, &Globals.szRealm)
861 _PUBLIC_ FN_GLOBAL_STRING(lp_socket_options, &Globals.socket_options)
862 _PUBLIC_ FN_GLOBAL_STRING(lp_workgroup, &Globals.szWorkgroup)
863 _PUBLIC_ FN_GLOBAL_STRING(lp_netbios_name, &Globals.szNetbiosName)
864 _PUBLIC_ FN_GLOBAL_STRING(lp_netbios_scope, &Globals.szNetbiosScope)
865 _PUBLIC_ FN_GLOBAL_LIST(lp_wins_server_list, &Globals.szWINSservers)
866 _PUBLIC_ FN_GLOBAL_LIST(lp_interfaces, &Globals.szInterfaces)
867 _PUBLIC_ FN_GLOBAL_STRING(lp_socket_address, &Globals.szSocketAddress)
868 _PUBLIC_ FN_GLOBAL_LIST(lp_netbios_aliases, &Globals.szNetbiosAliases)
869
870 _PUBLIC_ FN_GLOBAL_BOOL(lp_disable_netbios, &Globals.bDisableNetbios)
871 _PUBLIC_ FN_GLOBAL_BOOL(lp_wins_support, &Globals.bWINSsupport)
872 _PUBLIC_ FN_GLOBAL_BOOL(lp_wins_dns_proxy, &Globals.bWINSdnsProxy)
873 _PUBLIC_ FN_GLOBAL_STRING(lp_wins_hook, &Globals.szWINSHook)
874 _PUBLIC_ FN_GLOBAL_BOOL(lp_local_master, &Globals.bLocalMaster)
875 _PUBLIC_ FN_GLOBAL_BOOL(lp_readraw, &Globals.bReadRaw)
876 _PUBLIC_ FN_GLOBAL_BOOL(lp_large_readwrite, &Globals.bLargeReadwrite)
877 _PUBLIC_ FN_GLOBAL_BOOL(lp_writeraw, &Globals.bWriteRaw)
878 _PUBLIC_ FN_GLOBAL_BOOL(lp_null_passwords, &Globals.bNullPasswords)
879 _PUBLIC_ FN_GLOBAL_BOOL(lp_obey_pam_restrictions, &Globals.bObeyPamRestrictions)
880 _PUBLIC_ FN_GLOBAL_BOOL(lp_encrypted_passwords, &Globals.bEncryptPasswords)
881 _PUBLIC_ FN_GLOBAL_BOOL(lp_time_server, &Globals.bTimeServer)
882 _PUBLIC_ FN_GLOBAL_BOOL(lp_bind_interfaces_only, &Globals.bBindInterfacesOnly)
883 _PUBLIC_ FN_GLOBAL_BOOL(lp_unicode, &Globals.bUnicode)
884 _PUBLIC_ FN_GLOBAL_BOOL(lp_nt_status_support, &Globals.bNTStatusSupport)
885 _PUBLIC_ FN_GLOBAL_BOOL(lp_lanman_auth, &Globals.bLanmanAuth)
886 _PUBLIC_ FN_GLOBAL_BOOL(lp_ntlm_auth, &Globals.bNTLMAuth)
887 _PUBLIC_ FN_GLOBAL_BOOL(lp_client_plaintext_auth, &Globals.bClientPlaintextAuth)
888 _PUBLIC_ FN_GLOBAL_BOOL(lp_client_lanman_auth, &Globals.bClientLanManAuth)
889 _PUBLIC_ FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, &Globals.bClientNTLMv2Auth)
890 _PUBLIC_ FN_GLOBAL_BOOL(lp_client_use_spnego_principal, &Globals.client_use_spnego_principal)
891 _PUBLIC_ FN_GLOBAL_BOOL(lp_host_msdfs, &Globals.bHostMSDfs)
892 _PUBLIC_ FN_GLOBAL_BOOL(lp_unix_extensions, &Globals.bUnixExtensions)
893 _PUBLIC_ FN_GLOBAL_BOOL(lp_use_spnego, &Globals.bUseSpnego)
894 _PUBLIC_ FN_GLOBAL_BOOL(lp_rpc_big_endian, &Globals.bRpcBigEndian)
895 _PUBLIC_ FN_GLOBAL_INTEGER(lp_max_wins_ttl, &Globals.max_wins_ttl)
896 _PUBLIC_ FN_GLOBAL_INTEGER(lp_min_wins_ttl, &Globals.min_wins_ttl)
897 _PUBLIC_ FN_GLOBAL_INTEGER(lp_maxmux, &Globals.max_mux)
898 _PUBLIC_ FN_GLOBAL_INTEGER(lp_max_xmit, &Globals.max_xmit)
899 _PUBLIC_ FN_GLOBAL_INTEGER(lp_passwordlevel, &Globals.pwordlevel)
900 _PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_maxprotocol, &Globals.srv_maxprotocol)
901 _PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_minprotocol, &Globals.srv_minprotocol)
902 _PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_maxprotocol, &Globals.cli_maxprotocol)
903 _PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_minprotocol, &Globals.cli_minprotocol)
904 _PUBLIC_ FN_GLOBAL_INTEGER(lp_security, &Globals.security)
905 _PUBLIC_ FN_GLOBAL_LIST(lp_auth_methods, &Globals.AuthMethods)
906 _PUBLIC_ FN_GLOBAL_BOOL(lp_paranoid_server_security, &Globals.paranoid_server_security)
907 _PUBLIC_ FN_GLOBAL_INTEGER(lp_announce_as, &Globals.announce_as)
908 _PUBLIC_ FN_GLOBAL_LIST(lp_js_include, &Globals.jsInclude)
909 _PUBLIC_ FN_GLOBAL_STRING(lp_jsonrpc_services_dir, &Globals.jsonrpcServicesDir)
910 _PUBLIC_
911 _PUBLIC_
912 _PUBLIC_ FN_LOCAL_STRING(lp_servicename, szService)
913 _PUBLIC_ FN_LOCAL_CONST_STRING(lp_const_servicename, szService)
914 _PUBLIC_ FN_LOCAL_STRING(lp_pathname, szPath)
915 static FN_LOCAL_STRING(_lp_printername, szPrintername)
916 _PUBLIC_ FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
917 _PUBLIC_ FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
918 _PUBLIC_ FN_LOCAL_STRING(lp_comment, comment)
919 _PUBLIC_ FN_LOCAL_STRING(lp_fstype, fstype)
920 static FN_LOCAL_STRING(lp_volume, volume)
921 _PUBLIC_ FN_LOCAL_LIST(lp_ntvfs_handler, ntvfs_handler)
922 _PUBLIC_ FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
923 _PUBLIC_ FN_LOCAL_BOOL(lp_browseable, bBrowseable)
924 _PUBLIC_ FN_LOCAL_BOOL(lp_readonly, bRead_only)
925 _PUBLIC_ FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
926 _PUBLIC_ FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
927 _PUBLIC_ FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
928 _PUBLIC_ FN_LOCAL_BOOL(lp_strict_locking, bStrictLocking)
929 _PUBLIC_ FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
930 _PUBLIC_ FN_LOCAL_BOOL(lp_ci_filesystem, bCIFileSystem)
931 _PUBLIC_ FN_LOCAL_BOOL(lp_map_system, bMap_system)
932 _PUBLIC_ FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
933 _PUBLIC_ FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
934 _PUBLIC_ FN_GLOBAL_INTEGER(lp_server_signing, &Globals.server_signing)
935 _PUBLIC_ FN_GLOBAL_INTEGER(lp_client_signing, &Globals.client_signing)
936
937 /* local prototypes */
938
939 static int map_parameter(const char *pszParmName);
940 static int getservicebyname(const char *pszServiceName,
941 service * pserviceDest);
942 static void copy_service(service * pserviceDest,
943 service * pserviceSource, int *pcopymapDest);
944 static BOOL service_ok(int iService);
945 static BOOL do_section(const char *pszSectionName, void *);
946 static void init_copymap(service * pservice);
947
948 /* This is a helper function for parametrical options support. */
949 /* It returns a pointer to parametrical option value if it exists or NULL otherwise */
950 /* Actual parametrical functions are quite simple */
951 const char *lp_get_parametric(int lookup_service, const char *type, const char *option)
952 {
953 char *vfskey;
954 struct param_opt *data;
955
956 if (lookup_service >= iNumServices) return NULL;
957
958 data = (lookup_service < 0) ?
959 Globals.param_opt : ServicePtrs[lookup_service]->param_opt;
960
961 asprintf(&vfskey, "%s:%s", type, option);
962 strlower(vfskey);
963
964 while (data) {
965 if (strcmp(data->key, vfskey) == 0) {
966 free(vfskey);
967 return data->value;
968 }
969 data = data->next;
970 }
971
972 if (lookup_service >= 0) {
973 /* Try to fetch the same option but from globals */
974 /* but only if we are not already working with Globals */
975 data = Globals.param_opt;
976 while (data) {
977 if (strcmp(data->key, vfskey) == 0) {
978 free(vfskey);
979 return data->value;
980 }
981 data = data->next;
982 }
983 }
984
985 free(vfskey);
986
987 return NULL;
988 }
989
990
991 /*******************************************************************
992 convenience routine to return int parameters.
993 ********************************************************************/
994 static int lp_int(const char *s)
995 {
996
997 if (!s) {
998 DEBUG(0,("lp_int(%s): is called with NULL!\n",s));
999 return (-1);
1000 }
1001
1002 return strtol(s, NULL, 0);
1003 }
1004
1005 /*******************************************************************
1006 convenience routine to return unsigned long parameters.
1007 ********************************************************************/
1008 static int lp_ulong(const char *s)
1009 {
1010
1011 if (!s) {
1012 DEBUG(0,("lp_int(%s): is called with NULL!\n",s));
1013 return (-1);
1014 }
1015
1016 return strtoul(s, NULL, 0);
1017 }
1018
1019 /*******************************************************************
1020 convenience routine to return boolean parameters.
1021 ********************************************************************/
1022 static BOOL lp_bool(const char *s)
1023 {
1024 BOOL ret = False;
1025
1026 if (!s) {
1027 DEBUG(0,("lp_bool(%s): is called with NULL!\n",s));
1028 return False;
1029 }
1030
1031 if (!set_boolean(s, &ret)) {
1032 DEBUG(0,("lp_bool(%s): value is not boolean!\n",s));
1033 return False;
1034 }
1035
1036 return ret;
1037 }
1038
1039
1040 /* Return parametric option from a given service. Type is a part of option before ':' */
1041 /* Parametric option has following syntax: 'Type: option = value' */
1042 /* Returned value is allocated in 'lp_talloc' context */
1043
1044 const char *lp_parm_string(int lookup_service, const char *type, const char *option)
1045 {
1046 const char *value = lp_get_parametric(lookup_service, type, option);
1047
1048 if (value)
1049 return lp_string(value);
1050
1051 return NULL;
1052 }
1053
1054 /* Return parametric option from a given service. Type is a part of option before ':' */
1055 /* Parametric option has following syntax: 'Type: option = value' */
1056 /* Returned value is allocated in 'lp_talloc' context */
1057
1058 const char **lp_parm_string_list(int lookup_service, const char *type, const char *option,
1059 const char *separator)
1060 {
1061 const char *value = lp_get_parametric(lookup_service, type, option);
1062
1063 if (value)
1064 return str_list_make(talloc_autofree_context(), value, separator);
1065
1066 return NULL;
1067 }
1068
1069 /* Return parametric option from a given service. Type is a part of option before ':' */
1070 /* Parametric option has following syntax: 'Type: option = value' */
1071
1072 int lp_parm_int(int lookup_service, const char *type, const char *option, int default_v)
1073 {
1074 const char *value = lp_get_parametric(lookup_service, type, option);
1075
1076 if (value)
1077 return lp_int(value);
1078
1079 return default_v;
1080 }
1081
1082 /* Return parametric option from a given service. Type is a part of
1083 * option before ':'.
1084 * Parametric option has following syntax: 'Type: option = value'.
1085 */
1086
1087 int lp_parm_bytes(int lookup_service, const char *type, const char *option, int default_v)
1088 {
1089 uint64_t bval;
1090
1091 const char *value = lp_get_parametric(lookup_service, type, option);
1092
1093 if (value && conv_str_size(value, &bval)) {
1094 if (bval <= INT_MAX) {
1095 return (int)bval;
1096 }
1097 }
1098
1099 return default_v;
1100 }
1101
1102 /* Return parametric option from a given service. Type is a part of option before ':' */
1103 /* Parametric option has following syntax: 'Type: option = value' */
1104
1105 unsigned long lp_parm_ulong(int lookup_service, const char *type, const char *option, unsigned long default_v)
1106 {
1107 const char *value = lp_get_parametric(lookup_service, type, option);
1108
1109 if (value)
1110 return lp_ulong(value);
1111
1112 return default_v;
1113 }
1114
1115 /* Return parametric option from a given service. Type is a part of option before ':' */
1116 /* Parametric option has following syntax: 'Type: option = value' */
1117
1118 BOOL lp_parm_bool(int lookup_service, const char *type, const char *option, BOOL default_v)
1119 {
1120 const char *value = lp_get_parametric(lookup_service, type, option);
1121
1122 if (value)
1123 return lp_bool(value);
1124
1125 return default_v;
1126 }
1127
1128
1129 /***************************************************************************
1130 Initialise a service to the defaults.
1131 ***************************************************************************/
1132
1133 static void init_service(service * pservice)
1134 {
1135 memset((char *)pservice, '\0', sizeof(service));
1136 copy_service(pservice, &sDefault, NULL);
1137 }
1138
1139 /***************************************************************************
1140 Free the dynamically allocated parts of a service struct.
1141 ***************************************************************************/
1142
1143 static void free_service(service *pservice)
1144 {
1145 int i;
1146 struct param_opt *data, *pdata;
1147 if (!pservice)
1148 return;
1149
1150 if (pservice->szService)
1151 DEBUG(5, ("free_service: Freeing service %s\n",
1152 pservice->szService));
1153
1154 string_free(&pservice->szService);
1155 SAFE_FREE(pservice->copymap);
1156
1157 for (i = 0; parm_table[i].label; i++) {
1158 if ((parm_table[i].type == P_STRING ||
1159 parm_table[i].type == P_USTRING) &&
1160 parm_table[i].class == P_LOCAL) {
1161 string_free((char **)
1162 (((char *)pservice) +
1163 PTR_DIFF(parm_table[i].ptr, &sDefault)));
1164 } else if (parm_table[i].type == P_LIST &&
1165 parm_table[i].class == P_LOCAL) {
1166 char ***listp = (char ***)(((char *)pservice) +
1167 PTR_DIFF(parm_table[i].ptr, &sDefault));
1168 talloc_free(*listp);
1169 *listp = NULL;
1170 }
1171 }
1172
1173 DEBUG(5,("Freeing parametrics:\n"));
1174 data = pservice->param_opt;
1175 while (data) {
1176 DEBUG(5,("[%s = %s]\n", data->key, data->value));
1177 string_free(&data->key);
1178 string_free(&data->value);
1179 pdata = data->next;
1180 SAFE_FREE(data);
1181 data = pdata;
1182 }
1183
1184 ZERO_STRUCTP(pservice);
1185 }
1186
1187 /***************************************************************************
1188 Add a new service to the services array initialising it with the given
1189 service.
1190 ***************************************************************************/
1191
1192 static int add_a_service(const service *pservice, const char *name)
1193 {
1194 int i;
1195 service tservice;
1196 int num_to_alloc = iNumServices + 1;
1197 struct param_opt *data, *pdata;
1198
1199 tservice = *pservice;
1200
1201 /* it might already exist */
1202 if (name) {
1203 i = getservicebyname(name, NULL);
1204 if (i >= 0) {
1205 /* Clean all parametric options for service */
1206 /* They will be added during parsing again */
1207 data = ServicePtrs[i]->param_opt;
1208 while (data) {
1209 string_free(&data->key);
1210 string_free(&data->value);
1211 pdata = data->next;
1212 SAFE_FREE(data);
1213 data = pdata;
1214 }
1215 ServicePtrs[i]->param_opt = NULL;
1216 return (i);
1217 }
1218 }
1219
1220 /* find an invalid one */
1221 for (i = 0; i < iNumServices; i++)
1222 if (!ServicePtrs[i]->valid)
1223 break;
1224
1225 /* if not, then create one */
1226 if (i == iNumServices) {
1227 service **tsp;
1228
1229 tsp = realloc_p(ServicePtrs, service *, num_to_alloc);
1230
1231 if (!tsp) {
1232 DEBUG(0,("add_a_service: failed to enlarge ServicePtrs!\n"));
1233 return (-1);
1234 }
1235 else {
1236 ServicePtrs = tsp;
1237 ServicePtrs[iNumServices] = malloc_p(service);
1238 }
1239 if (!ServicePtrs[iNumServices]) {
1240 DEBUG(0,("add_a_service: out of memory!\n"));
1241 return (-1);
1242 }
1243
1244 iNumServices++;
1245 } else
1246 free_service(ServicePtrs[i]);
1247
1248 ServicePtrs[i]->valid = True;
1249
1250 init_service(ServicePtrs[i]);
1251 copy_service(ServicePtrs[i], &tservice, NULL);
1252 if (name)
1253 string_set(&ServicePtrs[i]->szService, name);
1254 return (i);
1255 }
1256
1257 /***************************************************************************
1258 Add a new home service, with the specified home directory, defaults coming
1259 from service ifrom.
1260 ***************************************************************************/
1261
1262 BOOL lp_add_home(const char *pszHomename, int iDefaultService,
1263 const char *user, const char *pszHomedir)
1264 {
1265 int i;
1266 pstring newHomedir;
1267
1268 i = add_a_service(ServicePtrs[iDefaultService], pszHomename);
1269
1270 if (i < 0)
1271 return (False);
1272
1273 if (!(*(ServicePtrs[iDefaultService]->szPath))
1274 || strequal(ServicePtrs[iDefaultService]->szPath, lp_pathname(-1))) {
1275 pstrcpy(newHomedir, pszHomedir);
1276 } else {
1277 pstrcpy(newHomedir, lp_pathname(iDefaultService));
1278 string_sub(newHomedir,"%H", pszHomedir, sizeof(newHomedir));
1279 }
1280
1281 string_set(&ServicePtrs[i]->szPath, newHomedir);
1282
1283 if (!(*(ServicePtrs[i]->comment))) {
1284 pstring comment;
1285 slprintf(comment, sizeof(comment) - 1,
1286 "Home directory of %s", user);
1287 string_set(&ServicePtrs[i]->comment, comment);
1288 }
1289 ServicePtrs[i]->bAvailable = sDefault.bAvailable;
1290 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
1291
1292 DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n", pszHomename,
1293 user, newHomedir));
1294
1295 return (True);
1296 }
1297
1298 /***************************************************************************
1299 Add a new service, based on an old one.
1300 ***************************************************************************/
1301
1302 int lp_add_service(const char *pszService, int iDefaultService)
1303 {
1304 return (add_a_service(ServicePtrs[iDefaultService], pszService));
1305 }
1306
1307 /***************************************************************************
1308 Add the IPC service.
1309 ***************************************************************************/
1310
1311 static BOOL lp_add_hidden(const char *name, const char *fstype)
1312 {
1313 pstring comment;
1314 int i = add_a_service(&sDefault, name);
1315
1316 if (i < 0)
1317 return (False);
1318
1319 slprintf(comment, sizeof(comment) - 1,
1320 "%s Service (%s)", fstype, Globals.szServerString);
1321
1322 string_set(&ServicePtrs[i]->szPath, tmpdir());
1323 string_set(&ServicePtrs[i]->comment, comment);
1324 string_set(&ServicePtrs[i]->fstype, fstype);
1325 ServicePtrs[i]->iMaxConnections = -1;
1326 ServicePtrs[i]->bAvailable = True;
1327 ServicePtrs[i]->bRead_only = True;
1328 ServicePtrs[i]->bPrint_ok = False;
1329 ServicePtrs[i]->bBrowseable = False;
1330
1331 if (strcasecmp(fstype, "IPC") == 0) {
1332 lp_do_parameter(i, "ntvfs handler", "default");
1333 }
1334
1335 DEBUG(3, ("adding hidden service %s\n", name));
1336
1337 return (True);
1338 }
1339
1340 /***************************************************************************
1341 Add a new printer service, with defaults coming from service iFrom.
1342 ***************************************************************************/
1343
1344 BOOL lp_add_printer(const char *pszPrintername, int iDefaultService)
1345 {
1346 const char *comment = "From Printcap";
1347 int i = add_a_service(ServicePtrs[iDefaultService], pszPrintername);
1348
1349 if (i < 0)
1350 return (False);
1351
1352 /* note that we do NOT default the availability flag to True - */
1353 /* we take it from the default service passed. This allows all */
1354 /* dynamic printers to be disabled by disabling the [printers] */
1355 /* entry (if/when the 'available' keyword is implemented!). */
1356
1357 /* the printer name is set to the service name. */
1358 string_set(&ServicePtrs[i]->szPrintername, pszPrintername);
1359 string_set(&ServicePtrs[i]->comment, comment);
1360 ServicePtrs[i]->bBrowseable = sDefault.bBrowseable;
1361 /* Printers cannot be read_only. */
1362 ServicePtrs[i]->bRead_only = False;
1363 /* Printer services must be printable. */
1364 ServicePtrs[i]->bPrint_ok = True;
1365
1366 DEBUG(3, ("adding printer service %s\n", pszPrintername));
1367
1368 return (True);
1369 }
1370
1371 /***************************************************************************
1372 Map a parameter's string representation to something we can use.
1373 Returns False if the parameter string is not recognised, else TRUE.
1374 ***************************************************************************/
1375
1376 static int map_parameter(const char *pszParmName)
1377 {
1378 int iIndex;
1379
1380 if (*pszParmName == '-')
1381 return (-1);
1382
1383 for (iIndex = 0; parm_table[iIndex].label; iIndex++)
1384 if (strwicmp(parm_table[iIndex].label, pszParmName) == 0)
1385 return (iIndex);
1386
1387 /* Warn only if it isn't parametric option */
1388 if (strchr(pszParmName, ':') == NULL)
1389 DEBUG(0, ("Unknown parameter encountered: \"%s\"\n", pszParmName));
1390 /* We do return 'fail' for parametric options as well because they are
1391 stored in different storage
1392 */
1393 return (-1);
1394 }
1395
1396
1397 /*
1398 return the parameter structure for a parameter
1399 */
1400 struct parm_struct *lp_parm_struct(const char *name)
1401 {
1402 int parmnum = map_parameter(name);
1403 if (parmnum == -1) return NULL;
1404 return &parm_table[parmnum];
1405 }
1406
1407 /*
1408 return the parameter pointer for a parameter
1409 */
1410 void *lp_parm_ptr(int snum, struct parm_struct *parm)
1411 {
1412 if (snum == -1) {
1413 return parm->ptr;
1414 }
1415 return ((char *)ServicePtrs[snum]) + PTR_DIFF(parm->ptr, &sDefault);
1416 }
1417
1418 /***************************************************************************
1419 Find a service by name. Otherwise works like get_service.
1420 ***************************************************************************/
1421
1422 static int getservicebyname(const char *pszServiceName, service * pserviceDest)
1423 {
1424 int iService;
1425
1426 for (iService = iNumServices - 1; iService >= 0; iService--)
1427 if (VALID(iService) &&
1428 strwicmp(ServicePtrs[iService]->szService, pszServiceName) == 0) {
1429 if (pserviceDest != NULL)
1430 copy_service(pserviceDest, ServicePtrs[iService], NULL);
1431 break;
1432 }
1433
1434 return (iService);
1435 }
1436
1437 /***************************************************************************
1438 Copy a service structure to another.
1439 If pcopymapDest is NULL then copy all fields
1440 ***************************************************************************/
1441
1442 static void copy_service(service * pserviceDest, service * pserviceSource, int *pcopymapDest)
1443 {
1444 int i;
1445 BOOL bcopyall = (pcopymapDest == NULL);
1446 struct param_opt *data, *pdata, *paramo;
1447 BOOL not_added;
1448
1449 for (i = 0; parm_table[i].label; i++)
1450 if (parm_table[i].ptr && parm_table[i].class == P_LOCAL &&
1451 (bcopyall || pcopymapDest[i])) {
1452 void *def_ptr = parm_table[i].ptr;
1453 void *src_ptr =
1454 ((char *)pserviceSource) + PTR_DIFF(def_ptr,
1455 &sDefault);
1456 void *dest_ptr =
1457 ((char *)pserviceDest) + PTR_DIFF(def_ptr,
1458 &sDefault);
1459
1460 switch (parm_table[i].type) {
1461 case P_BOOL:
1462 *(int *)dest_ptr = *(int *)src_ptr;
1463 break;
1464
1465 case P_INTEGER:
1466 case P_ENUM:
1467 *(int *)dest_ptr = *(int *)src_ptr;
1468 break;
1469
1470 case P_STRING:
1471 string_set(dest_ptr,
1472 *(char **)src_ptr);
1473 break;
1474
1475 case P_USTRING:
1476 string_set(dest_ptr,
1477 *(char **)src_ptr);
1478 strupper(*(char **)dest_ptr);
1479 break;
1480 case P_LIST:
1481 *(const char ***)dest_ptr = str_list_copy(talloc_autofree_context(),
1482 *(const char ***)src_ptr);
1483 break;
1484 default:
1485 break;
1486 }
1487 }
1488
1489 if (bcopyall) {
1490 init_copymap(pserviceDest);
1491 if (pserviceSource->copymap)
1492 memcpy((void *)pserviceDest->copymap,
1493 (void *)pserviceSource->copymap,
1494 sizeof(int) * NUMPARAMETERS);
1495 }
1496
1497 data = pserviceSource->param_opt;
1498 while (data) {
1499 not_added = True;
1500 pdata = pserviceDest->param_opt;
1501 /* Traverse destination */
1502 while (pdata) {
1503 /* If we already have same option, override it */
1504 if (strcmp(pdata->key, data->key) == 0) {
1505 string_free(&pdata->value);
1506 pdata->value = strdup(data->value);
1507 not_added = False;
1508 break;
1509 }
1510 pdata = pdata->next;
1511 }
1512 if (not_added) {
1513 paramo = malloc_p(struct param_opt);
1514 if (!paramo)
1515 smb_panic("OOM");
1516 paramo->key = strdup(data->key);
1517 paramo->value = strdup(data->value);
1518 DLIST_ADD(pserviceDest->param_opt, paramo);
1519 }
1520 data = data->next;
1521 }
1522 }
1523
1524 /***************************************************************************
1525 Check a service for consistency. Return False if the service is in any way
1526 incomplete or faulty, else True.
1527 ***************************************************************************/
1528
1529 static BOOL service_ok(int iService)
1530 {
1531 BOOL bRetval;
1532
1533 bRetval = True;
1534 if (ServicePtrs[iService]->szService[0] == '\0') {
1535 DEBUG(0, ("The following message indicates an internal error:\n"));
1536 DEBUG(0, ("No service name in service entry.\n"));
1537 bRetval = False;
1538 }
1539
1540 /* The [printers] entry MUST be printable. I'm all for flexibility, but */
1541 /* I can't see why you'd want a non-printable printer service... */
1542 if (strwicmp(ServicePtrs[iService]->szService, PRINTERS_NAME) == 0) {
1543 if (!ServicePtrs[iService]->bPrint_ok) {
1544 DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
1545 ServicePtrs[iService]->szService));
1546 ServicePtrs[iService]->bPrint_ok = True;
1547 }
1548 /* [printers] service must also be non-browsable. */
1549 if (ServicePtrs[iService]->bBrowseable)
1550 ServicePtrs[iService]->bBrowseable = False;
1551 }
1552
1553 /* If a service is flagged unavailable, log the fact at level 0. */
1554 if (!ServicePtrs[iService]->bAvailable)
1555 DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
1556 ServicePtrs[iService]->szService));
1557
1558 return (bRetval);
1559 }
1560
1561 static struct file_lists {
1562 struct file_lists *next;
1563 char *name;
1564 char *subfname;
1565 time_t modtime;
1566 } *file_lists = NULL;
1567
1568 /*******************************************************************
1569 Keep a linked list of all config files so we know when one has changed
1570 it's date and needs to be reloaded.
1571 ********************************************************************/
1572
1573 static void add_to_file_list(const char *fname, const char *subfname)
1574 {
1575 struct file_lists *f = file_lists;
1576
1577 while (f) {
1578 if (f->name && !strcmp(f->name, fname))
1579 break;
1580 f = f->next;
1581 }
1582
1583 if (!f) {
1584 f = malloc_p(struct file_lists);
1585 if (!f)
1586 return;
1587 f->next = file_lists;
1588 f->name = strdup(fname);
1589 if (!f->name) {
1590 SAFE_FREE(f);
1591 return;
1592 }
1593 f->subfname = strdup(subfname);
1594 if (!f->subfname) {
1595 SAFE_FREE(f);
1596 return;
1597 }
1598 file_lists = f;
1599 f->modtime = file_modtime(subfname);
1600 } else {
1601 time_t t = file_modtime(subfname);
1602 if (t)
1603 f->modtime = t;
1604 }
1605 }
1606
1607 /*******************************************************************
1608 Check if a config file has changed date.
1609 ********************************************************************/
1610
1611 BOOL lp_file_list_changed(void)
1612 {
1613 struct file_lists *f = file_lists;
1614 DEBUG(6, ("lp_file_list_changed()\n"));
1615
1616 while (f) {
1617 pstring n2;
1618 time_t mod_time;
1619
1620 pstrcpy(n2, f->name);
1621 standard_sub_basic(n2,sizeof(n2));
1622
1623 DEBUGADD(6, ("file %s -> %s last mod_time: %s\n",
1624 f->name, n2, ctime(&f->modtime)));
1625
1626 mod_time = file_modtime(n2);
1627
1628 if (mod_time && ((f->modtime != mod_time) || (f->subfname == NULL) || (strcmp(n2, f->subfname) != 0))) {
1629 DEBUGADD(6,
1630 ("file %s modified: %s\n", n2,
1631 ctime(&mod_time)));
1632 f->modtime = mod_time;
1633 SAFE_FREE(f->subfname);
1634 f->subfname = strdup(n2);
1635 return (True);
1636 }
1637 f = f->next;
1638 }
1639 return (False);
1640 }
1641
1642 /***************************************************************************
1643 Handle the include operation.
1644 ***************************************************************************/
1645
1646 static BOOL handle_include(const char *pszParmValue, char **ptr)
1647 {
1648 pstring fname;
1649 pstrcpy(fname, pszParmValue);
1650
1651 standard_sub_basic(fname,sizeof(fname));
1652
1653 add_to_file_list(pszParmValue, fname);
1654
1655 string_set(ptr, fname);
1656
1657 if (file_exist(fname))
1658 return (pm_process(fname, do_section, do_parameter, NULL));
1659
1660 DEBUG(2, ("Can't find include file %s\n", fname));
1661
1662 return (False);
1663 }
1664
1665 /***************************************************************************
1666 Handle the interpretation of the copy parameter.
1667 ***************************************************************************/
1668
1669 static BOOL handle_copy(const char *pszParmValue, char **ptr)
1670 {
1671 BOOL bRetval;
1672 int iTemp;
1673 service serviceTemp;
1674
1675 string_set(ptr, pszParmValue);
1676
1677 init_service(&serviceTemp);
1678
1679 bRetval = False;
1680
1681 DEBUG(3, ("Copying service from service %s\n", pszParmValue));
1682
1683 if ((iTemp = getservicebyname(pszParmValue, &serviceTemp)) >= 0) {
1684 if (iTemp == iServiceIndex) {
1685 DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
1686 } else {
1687 copy_service(ServicePtrs[iServiceIndex],
1688 &serviceTemp,
1689 ServicePtrs[iServiceIndex]->copymap);
1690 bRetval = True;
1691 }
1692 } else {
1693 DEBUG(0, ("Unable to copy service - source not found: %s\n", pszParmValue));
1694 bRetval = False;
1695 }
1696
1697 free_service(&serviceTemp);
1698 return (bRetval);
1699 }
1700
1701 /***************************************************************************
1702 Initialise a copymap.
1703 ***************************************************************************/
1704
1705 static void init_copymap(service * pservice)
1706 {
1707 int i;
1708 SAFE_FREE(pservice->copymap);
1709 pservice->copymap = malloc_array_p(int, NUMPARAMETERS);
1710 if (!pservice->copymap)
1711 DEBUG(0,
1712 ("Couldn't allocate copymap!! (size %d)\n",
1713 (int)NUMPARAMETERS));
1714 else
1715 for (i = 0; i < NUMPARAMETERS; i++)
1716 pservice->copymap[i] = True;
1717 }
1718
1719 #if 0 /* not used anywhere */
1720 /***************************************************************************
1721 Return the local pointer to a parameter given the service number and the
1722 pointer into the default structure.
1723 ***************************************************************************/
1724
1725 void *lp_local_ptr(int snum, void *ptr)
1726 {
1727 return (void *)(((char *)ServicePtrs[snum]) + PTR_DIFF(ptr, &sDefault));
1728 }
1729 #endif
1730
1731 /***************************************************************************
1732 Process a parametric option
1733 ***************************************************************************/
1734 static BOOL lp_do_parameter_parametric(int snum, const char *pszParmName, const char *pszParmValue, int flags)
1735 {
1736 struct param_opt *paramo, *data;
1737 char *name;
1738
1739 while (isspace((unsigned char)*pszParmName)) {
1740 pszParmName++;
1741 }
1742
1743 name = strdup(pszParmName);
1744 if (!name) return False;
1745
1746 strlower(name);
1747
1748 if (snum < 0) {
1749 data = Globals.param_opt;
1750 } else {
1751 data = ServicePtrs[snum]->param_opt;
1752 }
1753
1754 /* Traverse destination */
1755 for (paramo=data; paramo; paramo=paramo->next) {
1756 /* If we already have the option set, override it unless
1757 it was a command line option and the new one isn't */
1758 if (strcmp(paramo->key, name) == 0) {
1759 if ((paramo->flags & FLAG_CMDLINE) &&
1760 !(flags & FLAG_CMDLINE)) {
1761 return True;
1762 }
1763
1764 free(paramo->value);
1765 paramo->value = strdup(pszParmValue);
1766 paramo->flags = flags;
1767 free(name);
1768 return True;
1769 }
1770 }
1771
1772 paramo = malloc_p(struct param_opt);
1773 if (!paramo)
1774 smb_panic("OOM");
1775 paramo->key = strdup(name);
1776 paramo->value = strdup(pszParmValue);
1777 paramo->flags = flags;
1778 if (snum < 0) {
1779 DLIST_ADD(Globals.param_opt, paramo);
1780 } else {
1781 DLIST_ADD(ServicePtrs[snum]->param_opt, paramo);
1782 }
1783
1784 free(name);
1785
1786 return True;
1787 }
1788
1789 /***************************************************************************
1790 Process a parameter for a particular service number. If snum < 0
1791 then assume we are in the globals.
1792 ***************************************************************************/
1793 BOOL lp_do_parameter(int snum, const char *pszParmName, const char *pszParmValue)
1794 {
1795 int parmnum, i;
1796 void *parm_ptr = NULL; /* where we are going to store the result */
1797 void *def_ptr = NULL;
1798
1799 parmnum = map_parameter(pszParmName);
1800
1801 if (parmnum < 0) {
1802 if (strchr(pszParmName, ':')) {
1803 return lp_do_parameter_parametric(snum, pszParmName, pszParmValue, 0);
1804 }
1805 DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
1806 return (True);
1807 }
1808
1809 if (parm_table[parmnum].flags & FLAG_DEPRECATED) {
1810 DEBUG(1, ("WARNING: The \"%s\" option is deprecated\n",
1811 pszParmName));
1812 }
1813
1814 /* if the flag has been set on the command line, then don't allow override,
1815 but don't report an error */
1816 if (parm_table[parmnum].flags & FLAG_CMDLINE) {
1817 return True;
1818 }
1819
1820 def_ptr = parm_table[parmnum].ptr;
1821
1822 /* we might point at a service, the default service or a global */
1823 if (snum < 0) {
1824 parm_ptr = def_ptr;
1825 } else {
1826 if (parm_table[parmnum].class == P_GLOBAL) {
1827 DEBUG(0,
1828 ("Global parameter %s found in service section!\n",
1829 pszParmName));
1830 return (True);
1831 }
1832 parm_ptr =
1833 ((char *)ServicePtrs[snum]) + PTR_DIFF(def_ptr,
1834 &sDefault);
1835 }
1836
1837 if (snum >= 0) {
1838 if (!ServicePtrs[snum]->copymap)
1839 init_copymap(ServicePtrs[snum]);
1840
1841 /* this handles the aliases - set the copymap for other entries with
1842 the same data pointer */
1843 for (i = 0; parm_table[i].label; i++)
1844 if (parm_table[i].ptr == parm_table[parmnum].ptr)
1845 ServicePtrs[snum]->copymap[i] = False;
1846 }
1847
1848 /* if it is a special case then go ahead */
1849 if (parm_table[parmnum].special) {
1850 parm_table[parmnum].special(pszParmValue, (char **)parm_ptr);
1851 return (True);
1852 }
1853
1854 /* now switch on the type of variable it is */
1855 switch (parm_table[parmnum].type)
1856 {
1857 case P_BOOL: {
1858 BOOL b;
1859 if (!set_boolean(pszParmValue, &b)) {
1860 DEBUG(0,("lp_do_parameter(%s): value is not boolean!\n", pszParmValue));
1861 return False;
1862 }
1863 *(int *)parm_ptr = b;
1864 }
1865 break;
1866
1867 case P_INTEGER:
1868 *(int *)parm_ptr = atoi(pszParmValue);
1869 break;
1870
1871 case P_BYTES:
1872 {
1873 uint64_t val;
1874 if (conv_str_size(pszParmValue, &val)) {
1875 if (val <= INT_MAX) {
1876 *(int *)parm_ptr = (int)val;
1877 break;
1878 }
1879 }
1880
1881 DEBUG(0,("lp_do_parameter(%s): value is not "
1882 "a valid size specifier!\n", pszParmValue));
1883 return False;
1884 }
1885
1886 case P_LIST:
1887 *(const char ***)parm_ptr = str_list_make(talloc_autofree_context(),
1888 pszParmValue, NULL);
1889 break;
1890
1891 case P_STRING:
1892 string_set(parm_ptr, pszParmValue);
1893 break;
1894
1895 case P_USTRING:
1896 string_set(parm_ptr, pszParmValue);
1897 strupper(*(char **)parm_ptr);
1898 break;
1899
1900 case P_ENUM:
1901 for (i = 0; parm_table[parmnum].enum_list[i].name; i++) {
1902 if (strequal
1903 (pszParmValue,
1904 parm_table[parmnum].enum_list[i].name)) {
1905 *(int *)parm_ptr =
1906 parm_table[parmnum].
1907 enum_list[i].value;
1908 break;
1909 }
1910 }
1911 if (!parm_table[parmnum].enum_list[i].name) {
1912 DEBUG(0,("Unknown enumerated value '%s' for '%s'\n",
1913 pszParmValue, pszParmName));
1914 return False;
1915 }
1916 break;
1917 case P_SEP:
1918 break;
1919 }
1920
1921 if (parm_table[parmnum].flags & FLAG_DEFAULT) {
1922 parm_table[parmnum].flags &= ~FLAG_DEFAULT;
1923 /* we have to also unset FLAG_DEFAULT on aliases */
1924 for (i=parmnum-1;i>=0 && parm_table[i].ptr == parm_table[parmnum].ptr;i--) {
1925 parm_table[i].flags &= ~FLAG_DEFAULT;
1926 }
1927 for (i=parmnum+1;i<NUMPARAMETERS && parm_table[i].ptr == parm_table[parmnum].ptr;i++) {
1928 parm_table[i].flags &= ~FLAG_DEFAULT;
1929 }
1930 }
1931
1932 return (True);
1933 }
1934
1935 /***************************************************************************
1936 Process a parameter.
1937 ***************************************************************************/
1938
1939 static BOOL do_parameter(const char *pszParmName, const char *pszParmValue, void *userdata)
1940 {
1941 return (lp_do_parameter(bInGlobalSection ? -2 : iServiceIndex,
1942 pszParmName, pszParmValue));
1943 }
1944
1945 /*
1946 variable argument do parameter
1947 */
1948 static BOOL do_parameter_var(const char *pszParmName, const char *fmt, ...) PRINTF_ATTRIBUTE(2, 3);
1949
1950 static BOOL do_parameter_var(const char *pszParmName, const char *fmt, ...)
1951 {
1952 char *s;
1953 BOOL ret;
1954 va_list ap;
1955
1956 va_start(ap, fmt);
1957 s = talloc_vasprintf(NULL, fmt, ap);
1958 va_end(ap);
1959 ret = do_parameter(pszParmName, s, NULL);
1960 talloc_free(s);
1961 return ret;
1962 }
1963
1964
1965 /*
1966 set a parameter from the commandline - this is called from command line parameter
1967 parsing code. It sets the parameter then marks the parameter as unable to be modified
1968 by smb.conf processing
1969 */
1970 BOOL lp_set_cmdline(const char *pszParmName, const char *pszParmValue)
1971 {
1972 int parmnum = map_parameter(pszParmName);
1973 int i;
1974
1975 while (isspace((unsigned char)*pszParmValue)) pszParmValue++;
1976
1977
1978 if (parmnum < 0 && strchr(pszParmName, ':')) {
1979 /* set a parametric option */
1980 return lp_do_parameter_parametric(-1, pszParmName, pszParmValue, FLAG_CMDLINE);
1981 }
1982
1983 if (parmnum < 0) {
1984 DEBUG(0,("Unknown option '%s'\n", pszParmName));
1985 return False;
1986 }
1987
1988 /* reset the CMDLINE flag in case this has been called before */
1989 parm_table[parmnum].flags &= ~FLAG_CMDLINE;
1990
1991 if (!lp_do_parameter(-2, pszParmName, pszParmValue)) {
1992 return False;
1993 }
1994
1995 parm_table[parmnum].flags |= FLAG_CMDLINE;
1996
1997 /* we have to also set FLAG_CMDLINE on aliases */
1998 for (i=parmnum-1;i>=0 && parm_table[i].ptr == parm_table[parmnum].ptr;i--) {
1999 parm_table[i].flags |= FLAG_CMDLINE;
2000 }
2001 for (i=parmnum+1;i<NUMPARAMETERS && parm_table[i].ptr == parm_table[parmnum].ptr;i++) {
2002 parm_table[i].flags |= FLAG_CMDLINE;
2003 }
2004
2005 return True;
2006 }
2007
2008 /*
2009 set a option from the commandline in 'a=b' format. Use to support --option
2010 */
2011 BOOL lp_set_option(const char *option)
2012 {
2013 char *p, *s;
2014 BOOL ret;
2015
2016 s = strdup(option);
2017 if (!s) {
2018 return False;
2019 }
2020
2021 p = strchr(s, '=');
2022 if (!p) {
2023 free(s);
2024 return False;
2025 }
2026
2027 *p = 0;
2028
2029 ret = lp_set_cmdline(s, p+1);
2030 free(s);
2031 return ret;
2032 }
2033
2034
2035 #define BOOLSTR(b) ((b) ? "Yes" : "No")
2036
2037 /***************************************************************************
2038 Print a parameter of the specified type.
2039 ***************************************************************************/
2040
2041 static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
2042 {
2043 int i;
2044 switch (p->type)
2045 {
2046 case P_ENUM:
2047 for (i = 0; p->enum_list[i].name; i++) {
2048 if (*(int *)ptr == p->enum_list[i].value) {
2049 fprintf(f, "%s",
2050 p->enum_list[i].name);
2051 break;
2052 }
2053 }
2054 break;
2055
2056 case P_BOOL:
2057 fprintf(f, "%s", BOOLSTR((BOOL)*(int *)ptr));
2058 break;
2059
2060 case P_INTEGER:
2061 case P_BYTES:
2062 fprintf(f, "%d", *(int *)ptr);
2063 break;
2064
2065 case P_LIST:
2066 if ((char ***)ptr && *(char ***)ptr) {
2067 char **list = *(char ***)ptr;
2068
2069 for (; *list; list++)
2070 fprintf(f, "%s%s", *list,
2071 ((*(list+1))?", ":""));
2072 }
2073 break;
2074
2075 case P_STRING:
2076 case P_USTRING:
2077 if (*(char **)ptr) {
2078 fprintf(f, "%s", *(char **)ptr);
2079 }
2080 break;
2081 case P_SEP:
2082 break;
2083 }
2084 }
2085
2086 /***************************************************************************
2087 Check if two parameters are equal.
2088 ***************************************************************************/
2089
2090 static BOOL equal_parameter(parm_type type, void *ptr1, void *ptr2)
2091 {
2092 switch (type) {
2093 case P_BOOL:
2094 return (*((int *)ptr1) == *((int *)ptr2));
2095
2096 case P_INTEGER:
2097 case P_BYTES:
2098 case P_ENUM:
2099 return (*((int *)ptr1) == *((int *)ptr2));
2100
2101 case P_LIST:
2102 return str_list_equal((const char **)(*(char ***)ptr1),
2103 (const char **)(*(char ***)ptr2));
2104
2105 case P_STRING:
2106 case P_USTRING:
2107 {
2108 char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
2109 if (p1 && !*p1)
2110 p1 = NULL;
2111 if (p2 && !*p2)
2112 p2 = NULL;
2113 return (p1 == p2 || strequal(p1, p2));
2114 }
2115 case P_SEP:
2116 break;
2117 }
2118 return (False);
2119 }
2120
2121 /***************************************************************************
2122 Process a new section (service). At this stage all sections are services.
2123 Later we'll have special sections that permit server parameters to be set.
2124 Returns True on success, False on failure.
2125 ***************************************************************************/
2126
2127 static BOOL do_section(const char *pszSectionName, void *userdata)
2128 {
2129 BOOL bRetval;
2130 BOOL isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
2131 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
2132 bRetval = False;
2133
2134 /* if we've just struck a global section, note the fact. */
2135 bInGlobalSection = isglobal;
2136
2137 /* check for multiple global sections */
2138 if (bInGlobalSection) {
2139 DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
2140 return (True);
2141 }
2142
2143 /* if we have a current service, tidy it up before moving on */
2144 bRetval = True;
2145
2146 if (iServiceIndex >= 0)
2147 bRetval = service_ok(iServiceIndex);
2148
2149 /* if all is still well, move to the next record in the services array */
2150 if (bRetval) {
2151 /* We put this here to avoid an odd message order if messages are */
2152 /* issued by the post-processing of a previous section. */
2153 DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
2154
2155 if ((iServiceIndex = add_a_service(&sDefault, pszSectionName))
2156 < 0) {
2157 DEBUG(0, ("Failed to add a new service\n"));
2158 return (False);
2159 }
2160 }
2161
2162 return (bRetval);
2163 }
2164
2165
2166 /***************************************************************************
2167 Determine if a partcular base parameter is currentl set to the default value.
2168 ***************************************************************************/
2169
2170 static BOOL is_default(int i)
2171 {
2172 if (!defaults_saved)
2173 return False;
2174 switch (parm_table[i].type) {
2175 case P_LIST:
2176 return str_list_equal((const char **)parm_table[i].def.lvalue,
2177 (const char **)(*(char ***)parm_table[i].ptr));
2178 case P_STRING:
2179 case P_USTRING:
2180 return strequal(parm_table[i].def.svalue,
2181 *(char **)parm_table[i].ptr);
2182 case P_BOOL:
2183 return parm_table[i].def.bvalue ==
2184 *(int *)parm_table[i].ptr;
2185 case P_INTEGER:
2186 case P_BYTES:
2187 case P_ENUM:
2188 return parm_table[i].def.ivalue ==
2189 *(int *)parm_table[i].ptr;
2190 case P_SEP:
2191 break;
2192 }
2193 return False;
2194 }
2195
2196 /***************************************************************************
2197 Display the contents of the global structure.
2198 ***************************************************************************/
2199
2200 static void dump_globals(FILE *f, BOOL show_defaults)
2201 {
2202 int i;
2203 struct param_opt *data;
2204
2205 fprintf(f, "# Global parameters\n[global]\n");
2206
2207 for (i = 0; parm_table[i].label; i++)
2208 if (parm_table[i].class == P_GLOBAL &&
2209 parm_table[i].ptr &&
2210 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
2211 if (!show_defaults && (parm_table[i].flags & FLAG_DEFAULT))
2212 continue;
2213 fprintf(f, "\t%s = ", parm_table[i].label);
2214 print_parameter(&parm_table[i], parm_table[i].ptr, f);
2215 fprintf(f, "\n");
2216 }
2217 if (Globals.param_opt != NULL) {
2218 data = Globals.param_opt;
2219 while(data) {
2220 fprintf(f, "\t%s = %s\n", data->key, data->value);
2221 data = data->next;
2222 }
2223 }
2224
2225 }
2226
2227 /***************************************************************************
2228 Display the contents of a single services record.
2229 ***************************************************************************/
2230
2231 static void dump_a_service(service * pService, FILE * f)
2232 {
2233 int i;
2234 struct param_opt *data;
2235
2236 if (pService != &sDefault)
2237 fprintf(f, "\n[%s]\n", pService->szService);
2238
2239 for (i = 0; parm_table[i].label; i++)
2240 if (parm_table[i].class == P_LOCAL &&
2241 parm_table[i].ptr &&
2242 (*parm_table[i].label != '-') &&
2243 (i == 0 || (parm_table[i].ptr != parm_table[i - 1].ptr))) {
2244 int pdiff = PTR_DIFF(parm_table[i].ptr, &sDefault);
2245
2246 if (pService == &sDefault) {
2247 if (defaults_saved && is_default(i))
2248 continue;
2249 } else {
2250 if (equal_parameter(parm_table[i].type,
2251 ((char *)pService) +
2252 pdiff,
2253 ((char *)&sDefault) +
2254 pdiff))
2255 continue;
2256 }
2257
2258 fprintf(f, "\t%s = ", parm_table[i].label);
2259 print_parameter(&parm_table[i],
2260 ((char *)pService) + pdiff, f);
2261 fprintf(f, "\n");
2262 }
2263 if (pService->param_opt != NULL) {
2264 data = pService->param_opt;
2265 while(data) {
2266 fprintf(f, "\t%s = %s\n", data->key, data->value);
2267 data = data->next;
2268 }
2269 }
2270 }
2271
2272 BOOL lp_dump_a_parameter(int snum, char *parm_name, FILE * f, BOOL isGlobal)
2273 {
2274 service * pService = ServicePtrs[snum];
2275 struct parm_struct *parm;
2276 void *ptr;
2277
2278 parm = lp_parm_struct(parm_name);
2279 if (!parm) {
2280 return False;
2281 }
2282
2283 if (isGlobal)
2284 ptr = parm->ptr;
2285 else
2286 ptr = ((char *)pService) +
2287 PTR_DIFF(parm->ptr, &sDefault);
2288
2289 print_parameter(parm,
2290 ptr, f);
2291 fprintf(f, "\n");
2292 return True;
2293 }
2294
2295 /***************************************************************************
2296 Return info about the next service in a service. snum==-1 gives the globals.
2297 Return NULL when out of parameters.
2298 ***************************************************************************/
2299
2300 struct parm_struct *lp_next_parameter(int snum, int *i, int allparameters)
2301 {
2302 if (snum == -1) {
2303 /* do the globals */
2304 for (; parm_table[*i].label; (*i)++) {
2305 if (parm_table[*i].class == P_SEPARATOR)
2306 return &parm_table[(*i)++];
2307
2308 if (!parm_table[*i].ptr
2309 || (*parm_table[*i].label == '-'))
2310 continue;
2311
2312 if ((*i) > 0
2313 && (parm_table[*i].ptr ==
2314 parm_table[(*i) - 1].ptr))
2315 continue;
2316
2317 return &parm_table[(*i)++];
2318 }
2319 } else {
2320 service *pService = ServicePtrs[snum];
2321
2322 for (; parm_table[*i].label; (*i)++) {
2323 if (parm_table[*i].class == P_SEPARATOR)
2324 return &parm_table[(*i)++];
2325
2326 if (parm_table[*i].class == P_LOCAL &&
2327 parm_table[*i].ptr &&
2328 (*parm_table[*i].label != '-') &&
2329 ((*i) == 0 ||
2330 (parm_table[*i].ptr !=
2331 parm_table[(*i) - 1].ptr)))
2332 {
2333 int pdiff =
2334 PTR_DIFF(parm_table[*i].ptr,
2335 &sDefault);
2336
2337 if (allparameters ||
2338 !equal_parameter(parm_table[*i].type,
2339 ((char *)pService) +
2340 pdiff,
2341 ((char *)&sDefault) +
2342 pdiff))
2343 {
2344 return &parm_table[(*i)++];
2345 }
2346 }
2347 }
2348 }
2349
2350 return NULL;
2351 }
2352
2353
2354 /***************************************************************************
2355 Return TRUE if the passed service number is within range.
2356 ***************************************************************************/
2357
2358 BOOL lp_snum_ok(int iService)
2359 {
2360 return (LP_SNUM_OK(iService) && ServicePtrs[iService]->bAvailable);
2361 }
2362
2363 /***************************************************************************
2364 Auto-load some home services.
2365 ***************************************************************************/
2366
2367 static void lp_add_auto_services(const char *str)
2368 {
2369 return;
2370 }
2371
2372 /***************************************************************************
2373 Have we loaded a services file yet?
2374 ***************************************************************************/
2375
2376 BOOL lp_loaded(void)
2377 {
2378 return (bLoaded);
2379 }
2380
2381 /***************************************************************************
2382 Unload unused services.
2383 ***************************************************************************/
2384
2385 void lp_killunused(struct smbsrv_connection *smb, BOOL (*snumused) (struct smbsrv_connection *, int))
2386 {
2387 int i;
2388 for (i = 0; i < iNumServices; i++) {
2389 if (!VALID(i))
2390 continue;
2391
2392 if (!snumused || !snumused(smb, i)) {
2393 ServicePtrs[i]->valid = False;
2394 free_service(ServicePtrs[i]);
2395 }
2396 }
2397 }
2398
2399 /***************************************************************************
2400 Unload a service.
2401 ***************************************************************************/
2402
2403 void lp_killservice(int iServiceIn)
2404 {
2405 if (VALID(iServiceIn)) {
2406 ServicePtrs[iServiceIn]->valid = False;
2407 free_service(ServicePtrs[iServiceIn]);
2408 }
2409 }
2410
2411 /***************************************************************************
2412 Load the services array from the services file. Return True on success,
2413 False on failure.
2414 ***************************************************************************/
2415
2416 BOOL lp_load(void)
2417 {
2418 pstring n2;
2419 BOOL bRetval;
2420 struct param_opt *data;
2421
2422 bRetval = False;
2423
2424 bInGlobalSection = True;
2425
2426 if (Globals.param_opt != NULL) {
2427 struct param_opt *next;
2428 for (data=Globals.param_opt; data; data=next) {
2429 next = data->next;
2430 if (data->flags & FLAG_CMDLINE) continue;
2431 free(data->key);
2432 free(data->value);
2433 DLIST_REMOVE(Globals.param_opt, data);
2434 free(data);
2435 }
2436 }
2437
2438 init_globals();
2439
2440 pstrcpy(n2, lp_configfile());
2441 standard_sub_basic(n2,sizeof(n2));
2442 DEBUG(2, ("lp_load: refreshing parameters from %s\n", n2));
2443
2444 add_to_file_list(lp_configfile(), n2);
2445
2446 /* We get sections first, so have to start 'behind' to make up */
2447 iServiceIndex = -1;
2448 bRetval = pm_process(n2, do_section, do_parameter, NULL);
2449
2450 /* finish up the last section */
2451 DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
2452 if (bRetval)
2453 if (iServiceIndex >= 0)
2454 bRetval = service_ok(iServiceIndex);
2455
2456 lp_add_auto_services(lp_auto_services());
2457
2458 lp_add_hidden("IPC$", "IPC");
2459 lp_add_hidden("ADMIN$", "DISK");
2460
2461 bLoaded = True;
2462
2463 if (!Globals.szWINSservers && Globals.bWINSsupport) {
2464 lp_do_parameter(-1, "wins server", "127.0.0.1");
2465 }
2466
2467 init_iconv();
2468
2469 return (bRetval);
2470 }
2471
2472 /***************************************************************************
2473 Reset the max number of services.
2474 ***************************************************************************/
2475
2476 void lp_resetnumservices(void)
2477 {
2478 iNumServices = 0;
2479 }
2480
2481 /***************************************************************************
2482 Return the max number of services.
2483 ***************************************************************************/
2484
2485 int lp_numservices(void)
2486 {
2487 return (iNumServices);
2488 }
2489
2490 /***************************************************************************
2491 Display the contents of the services array in human-readable form.
2492 ***************************************************************************/
2493
2494 void lp_dump(FILE *f, BOOL show_defaults, int maxtoprint)
2495 {
2496 int iService;
2497
2498 if (show_defaults)
2499 defaults_saved = False;
2500
2501 dump_globals(f, show_defaults);
2502
2503 dump_a_service(&sDefault, f);
2504
2505 for (iService = 0; iService < maxtoprint; iService++)
2506 lp_dump_one(f, show_defaults, iService);
2507 }
2508
2509 /***************************************************************************
2510 Display the contents of one service in human-readable form.
2511 ***************************************************************************/
2512
2513 void lp_dump_one(FILE * f, BOOL show_defaults, int snum)
2514 {
2515 if (VALID(snum)) {
2516 if (ServicePtrs[snum]->szService[0] == '\0')
2517 return;
2518 dump_a_service(ServicePtrs[snum], f);
2519 }
2520 }
2521
2522 /***************************************************************************
2523 Return the number of the service with the given name, or -1 if it doesn't
2524 exist. Note that this is a DIFFERENT ANIMAL from the internal function
2525 getservicebyname()! This works ONLY if all services have been loaded, and
2526 does not copy the found service.
2527 ***************************************************************************/
2528
2529 int lp_servicenumber(const char *pszServiceName)
2530 {
2531 int iService;
2532 fstring serviceName;
2533
2534
2535 for (iService = iNumServices - 1; iService >= 0; iService--) {
2536 if (VALID(iService) && ServicePtrs[iService]->szService) {
2537 /*
2538 * The substitution here is used to support %U is
2539 * service names
2540 */
2541 fstrcpy(serviceName, ServicePtrs[iService]->szService);
2542 standard_sub_basic(serviceName,sizeof(serviceName));
2543 if (strequal(serviceName, pszServiceName))
2544 break;
2545 }
2546 }
2547
2548 if (iService < 0)
2549 DEBUG(7,("lp_servicenumber: couldn't find %s\n", pszServiceName));
2550
2551 return (iService);
2552 }
2553
2554 int lp_find_valid_service(const char *pszServiceName)
2555 {
2556 int iService;
2557
2558 iService = lp_servicenumber(pszServiceName);
2559
2560 if (iService >= 0 && !lp_snum_ok(iService)) {
2561 DEBUG(0,("lp_find_valid_service: Invalid snum %d for '%s'\n",iService, pszServiceName));
2562 iService = -1;
2563 }
2564
2565 if (iService == -1) {
2566 DEBUG(3,("lp_find_valid_service: failed to find service '%s'\n", pszServiceName));
2567 }
2568
2569 return iService;
2570 }
2571
2572 /*******************************************************************
2573 A useful volume label function.
2574 ********************************************************************/
2575 const char *volume_label(int snum)
2576 {
2577 const char *ret = lp_volume(snum);
2578 if (!*ret)
2579 return lp_servicename(snum);
2580 return (ret);
2581 }
2582
2583
2584 /***********************************************************
2585 If we are PDC then prefer us as DMB
2586 ************************************************************/
2587
2588 BOOL lp_domain_logons(void)
2589 {
2590 return (lp_server_role() == ROLE_DOMAIN_CONTROLLER);
2591 }
2592
2593 /*******************************************************************
2594 Remove a service.
2595 ********************************************************************/
2596
2597 void lp_remove_service(int snum)
2598 {
2599 ServicePtrs[snum]->valid = False;
2600 }
2601
2602 /*******************************************************************
2603 Copy a service.
2604 ********************************************************************/
2605
2606 void lp_copy_service(int snum, const char *new_name)
2607 {
2608 const char *oldname = lp_servicename(snum);
2609 do_section(new_name, NULL);
2610 if (snum >= 0) {
2611 snum = lp_servicenumber(new_name);
2612 if (snum >= 0)
2613 lp_do_parameter(snum, "copy", oldname);
2614 }
2615 }
2616
2617 const char *lp_printername(int snum)
2618 {
2619 const char *ret = _lp_printername(snum);
2620 if (ret == NULL || (ret != NULL && *ret == '\0'))
2621 ret = lp_const_servicename(snum);
2622
2623 return ret;
2624 }
2625
2626
2627 /*******************************************************************
2628 Return the max print jobs per queue.
2629 ********************************************************************/
2630
2631 int lp_maxprintjobs(int snum)
2632 {
2633 int maxjobs = LP_SNUM_OK(snum) ? ServicePtrs[snum]->iMaxPrintJobs : sDefault.iMaxPrintJobs;
2634 if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
2635 maxjobs = PRINT_MAX_JOBID - 1;
2636
2637 return maxjobs;
2638 }
Samba GIT mirror