← Back to branch summary

~ubuntu-branches/ubuntu/vivid/samba/vivid

« back to all changes in this revision

Viewing changes to source4/param/loadparm.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
source4/param/loadparm.c
61
61
#include "smb_server/smb_server.h"
62
62
#include "libcli/raw/signing.h"
63
63
#include "../lib/util/dlinklist.h"
 
64
#include "../lib/util/parmlist.h"
64
65
#include "param/param.h"
65
66
#include "param/loadparm.h"
66
67
#include "libcli/raw/libcliraw.h"
79
80
struct loadparm_global
80
81
{
81
82
        enum server_role server_role;
 
83
        enum sid_generator sid_generator;
82
84
 
83
85
        const char **smb_ports;
84
86
        char *ncalrpc_dir;
88
90
        char *szLockDir;
89
91
        char *szModulesDir;
90
92
        char *szPidDir;
91
 
        char *szSetupDir;
92
93
        char *szServerString;
93
94
        char *szAutoServices;
94
95
        char *szPasswdChat;
103
104
        const char **szPasswordServers;
104
105
        char *szSocketOptions;
105
106
        char *szRealm;
 
107
        char *szRealm_upper;
 
108
        char *szRealm_lower;
106
109
        const char **szWINSservers;
107
110
        const char **szInterfaces;
108
111
        char *szSocketAddress;
123
126
        char *szTemplateHomedir;
124
127
        int bWinbindSealedPipes;
125
128
        int bIdmapTrustedOnly;
126
 
        char *swat_directory;
127
129
        int tls_enabled;
128
130
        char *tls_keyfile;
129
131
        char *tls_certfile;
131
133
        char *tls_crlfile;
132
134
        char *tls_dhpfile;
133
135
        char *logfile;
 
136
        char *loglevel;
134
137
        char *panic_action;
135
138
        int max_mux;
136
139
        int debuglevel;
182
185
        int bDisableNetbios;
183
186
        int bRpcBigEndian;
184
187
        char *szNTPSignDSocketDirectory;
 
188
        const char **szRNDCCommand;
 
189
        const char **szDNSUpdateCommand;
 
190
        const char **szSPNUpdateCommand;
 
191
        const char **szNSUpdateCommand;
185
192
        struct parmlist_entry *param_opt;
186
193
};
187
194
 
234
241
/* prototypes for the special type handlers */
235
242
static bool handle_include(struct loadparm_context *lp_ctx,
236
243
                           const char *pszParmValue, char **ptr);
 
244
static bool handle_realm(struct loadparm_context *lp_ctx,
 
245
                         const char *pszParmValue, char **ptr);
237
246
static bool handle_copy(struct loadparm_context *lp_ctx,
238
247
                        const char *pszParmValue, char **ptr);
239
248
static bool handle_debuglevel(struct loadparm_context *lp_ctx,
324
333
        {-1, NULL}
325
334
};
326
335
 
 
336
static const struct enum_list enum_sid_generator[] = {
 
337
        {SID_GENERATOR_INTERNAL, "internal"},
 
338
        {SID_GENERATOR_BACKEND, "backend"},
 
339
        {-1, NULL}
 
340
};
327
341
 
328
342
#define GLOBAL_VAR(name) offsetof(struct loadparm_global, name)
329
343
#define LOCAL_VAR(name) offsetof(struct loadparm_service, name)
330
344
 
331
345
static struct parm_struct parm_table[] = {
332
346
        {"server role", P_ENUM, P_GLOBAL, GLOBAL_VAR(server_role), NULL, enum_server_role},
 
347
        {"sid generator", P_ENUM, P_GLOBAL, GLOBAL_VAR(sid_generator), NULL, enum_sid_generator},
333
348
 
334
349
        {"dos charset", P_STRING, P_GLOBAL, GLOBAL_VAR(dos_charset), NULL, NULL},
335
350
        {"unix charset", P_STRING, P_GLOBAL, GLOBAL_VAR(unix_charset), NULL, NULL},
339
354
        {"path", P_STRING, P_LOCAL, LOCAL_VAR(szPath), NULL, NULL},
340
355
        {"directory", P_STRING, P_LOCAL, LOCAL_VAR(szPath), NULL, NULL},
341
356
        {"workgroup", P_USTRING, P_GLOBAL, GLOBAL_VAR(szWorkgroup), NULL, NULL},
342
 
        {"realm", P_STRING, P_GLOBAL, GLOBAL_VAR(szRealm), NULL, NULL},
 
357
        {"realm", P_STRING, P_GLOBAL, GLOBAL_VAR(szRealm), handle_realm, NULL},
343
358
        {"netbios name", P_USTRING, P_GLOBAL, GLOBAL_VAR(szNetbiosName), NULL, NULL},
344
359
        {"netbios aliases", P_LIST, P_GLOBAL, GLOBAL_VAR(szNetbiosAliases), NULL, NULL},
345
360
        {"netbios scope", P_USTRING, P_GLOBAL, GLOBAL_VAR(szNetbiosScope), NULL, NULL},
382
397
        {"hosts allow", P_LIST, P_LOCAL, LOCAL_VAR(szHostsallow), NULL, NULL},
383
398
        {"hosts deny", P_LIST, P_LOCAL, LOCAL_VAR(szHostsdeny), NULL, NULL},
384
399
 
385
 
        {"log level", P_INTEGER, P_GLOBAL, GLOBAL_VAR(debuglevel), handle_debuglevel, NULL},
386
 
        {"debuglevel", P_INTEGER, P_GLOBAL, GLOBAL_VAR(debuglevel), handle_debuglevel, NULL},
 
400
        {"log level", P_STRING, P_GLOBAL, GLOBAL_VAR(loglevel), handle_debuglevel, NULL},
 
401
        {"debuglevel", P_STRING, P_GLOBAL, GLOBAL_VAR(loglevel), handle_debuglevel, NULL},
387
402
        {"log file", P_STRING, P_GLOBAL, GLOBAL_VAR(logfile), handle_logfile, NULL},
388
403
 
389
404
        {"smb ports", P_LIST, P_GLOBAL, GLOBAL_VAR(smb_ports), NULL, NULL},
399
414
        {"tls cafile", P_STRING, P_GLOBAL, GLOBAL_VAR(tls_cafile), NULL, NULL},
400
415
        {"tls crlfile", P_STRING, P_GLOBAL, GLOBAL_VAR(tls_crlfile), NULL, NULL},
401
416
        {"tls dh params file", P_STRING, P_GLOBAL, GLOBAL_VAR(tls_dhpfile), NULL, NULL},
402
 
        {"swat directory", P_STRING, P_GLOBAL, GLOBAL_VAR(swat_directory), NULL, NULL},
403
417
        {"large readwrite", P_BOOL, P_GLOBAL, GLOBAL_VAR(bLargeReadwrite), NULL, NULL},
404
418
        {"server max protocol", P_ENUM, P_GLOBAL, GLOBAL_VAR(srv_maxprotocol), NULL, enum_protocol},
405
419
        {"server min protocol", P_ENUM, P_GLOBAL, GLOBAL_VAR(srv_minprotocol), NULL, enum_protocol},
468
482
        {"lock directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szLockDir), NULL, NULL},
469
483
        {"modules dir", P_STRING, P_GLOBAL, GLOBAL_VAR(szModulesDir), NULL, NULL},
470
484
        {"pid directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szPidDir), NULL, NULL}, 
471
 
        {"setup directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szSetupDir), NULL, NULL},
472
485
 
473
486
        {"socket address", P_STRING, P_GLOBAL, GLOBAL_VAR(szSocketAddress), NULL, NULL},
474
487
        {"copy", P_STRING, P_LOCAL, LOCAL_VAR(szCopy), handle_copy, NULL},
491
504
        {"idmap trusted only", P_BOOL, P_GLOBAL, GLOBAL_VAR(bIdmapTrustedOnly), NULL, NULL},
492
505
 
493
506
        {"ntp signd socket directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szNTPSignDSocketDirectory), NULL, NULL },
 
507
        {"rndc command", P_CMDLIST, P_GLOBAL, GLOBAL_VAR(szRNDCCommand), NULL, NULL },
 
508
        {"dns update command", P_CMDLIST, P_GLOBAL, GLOBAL_VAR(szDNSUpdateCommand), NULL, NULL },
 
509
        {"spn update command", P_CMDLIST, P_GLOBAL, GLOBAL_VAR(szSPNUpdateCommand), NULL, NULL },
 
510
        {"nsupdate command", P_CMDLIST, P_GLOBAL, GLOBAL_VAR(szNSUpdateCommand), NULL, NULL },
494
511
 
495
512
        {NULL, P_BOOL, P_NONE, 0, NULL, NULL}
496
513
};
502
519
        struct loadparm_global *globals;
503
520
        struct loadparm_service **services;
504
521
        struct loadparm_service *sDefault;
 
522
        struct smb_iconv_convenience *iconv_convenience;
505
523
        int iNumServices;
506
524
        struct loadparm_service *currentService;
507
525
        bool bInGlobalSection;
512
530
                time_t modtime;
513
531
        } *file_lists;
514
532
        unsigned int flags[NUMPARAMETERS];
515
 
        struct smb_iconv_convenience *iconv_convenience;
 
533
        bool loaded;
 
534
        bool refuse_free;
516
535
};
517
536
 
518
537
 
519
 
struct loadparm_service *lp_default_service(struct loadparm_context *lp_ctx)
 
538
struct loadparm_service *lpcfg_default_service(struct loadparm_context *lp_ctx)
520
539
{
521
540
        return lp_ctx->sDefault;
522
541
}
524
543
/*
525
544
  return the parameter table
526
545
*/
527
 
struct parm_struct *lp_parm_table(void)
 
546
struct parm_struct *lpcfg_parm_table(void)
528
547
{
529
548
        return parm_table;
530
549
}
583
602
   parameters from the rest of the program are defined
584
603
*/
585
604
 
 
605
/*
 
606
 * the creation of separate lpcfg_*() and lp_*() functions is to allow
 
607
 * for code compatibility between existing Samba4 and Samba3 code.
 
608
 */
 
609
 
 
610
/* this global context supports the lp_*() function varients */
 
611
static struct loadparm_context *global_loadparm_context;
 
612
 
 
613
#define lpcfg_default_service global_loadparm_context->sDefault
 
614
#define lpcfg_global_service(i) global_loadparm_context->services[i]
 
615
 
586
616
#define FN_GLOBAL_STRING(fn_name,var_name) \
587
 
 const char *fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name ? lp_string(lp_ctx->globals->var_name) : "";}
 
617
 _PUBLIC_ const char *lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name ? lp_string(lp_ctx->globals->var_name) : "";}
 
618
 
588
619
#define FN_GLOBAL_CONST_STRING(fn_name,var_name) \
589
 
 const char *fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name ? lp_ctx->globals->var_name : "";}
 
620
 _PUBLIC_ const char *lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name ? lp_ctx->globals->var_name : "";}
 
621
 
590
622
#define FN_GLOBAL_LIST(fn_name,var_name) \
591
 
 const char **fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name;}
 
623
 _PUBLIC_ const char **lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name;}
 
624
 
592
625
#define FN_GLOBAL_BOOL(fn_name,var_name) \
593
 
 bool fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return false; return lp_ctx->globals->var_name;}
594
 
#if 0 /* unused */
595
 
#define FN_GLOBAL_CHAR(fn_name,ptr) \
596
 
 char fn_name(void) {return(*(char *)(ptr));}
597
 
#endif
 
626
 _PUBLIC_ bool lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return false; return lp_ctx->globals->var_name;}
 
627
 
598
628
#define FN_GLOBAL_INTEGER(fn_name,var_name) \
599
 
 int fn_name(struct loadparm_context *lp_ctx) {return lp_ctx->globals->var_name;}
 
629
 _PUBLIC_ int lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {return lp_ctx->globals->var_name;}
600
630
 
601
631
#define FN_LOCAL_STRING(fn_name,val) \
602
 
 const char *fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return(lp_string((const char *)((service != NULL && service->val != NULL) ? service->val : sDefault->val)));}
 
632
 _PUBLIC_ const char *lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return(lp_string((const char *)((service != NULL && service->val != NULL) ? service->val : sDefault->val)));}
 
633
 
603
634
#define FN_LOCAL_LIST(fn_name,val) \
604
 
 const char **fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return(const char **)(service != NULL && service->val != NULL? service->val : sDefault->val);}
 
635
 _PUBLIC_ const char **lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return(const char **)(service != NULL && service->val != NULL? service->val : sDefault->val);}
 
636
 
605
637
#define FN_LOCAL_BOOL(fn_name,val) \
606
 
 bool fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
 
638
 _PUBLIC_ bool lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
 
639
 
607
640
#define FN_LOCAL_INTEGER(fn_name,val) \
608
 
 int fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
609
 
 
610
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_server_role, server_role)
611
 
_PUBLIC_ FN_GLOBAL_LIST(lp_smb_ports, smb_ports)
612
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_nbt_port, nbt_port)
613
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_dgram_port, dgram_port)
614
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_cldap_port, cldap_port)
615
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_krb5_port, krb5_port)
616
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_kpasswd_port, kpasswd_port)
617
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_web_port, web_port)
618
 
_PUBLIC_ FN_GLOBAL_STRING(lp_swat_directory, swat_directory)
619
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_tls_enabled, tls_enabled)
620
 
_PUBLIC_ FN_GLOBAL_STRING(lp_share_backend, szShareBackend)
621
 
_PUBLIC_ FN_GLOBAL_STRING(lp_sam_url, szSAM_URL)
622
 
_PUBLIC_ FN_GLOBAL_STRING(lp_idmap_url, szIDMAP_URL)
623
 
_PUBLIC_ FN_GLOBAL_STRING(lp_secrets_url, szSECRETS_URL)
624
 
_PUBLIC_ FN_GLOBAL_STRING(lp_spoolss_url, szSPOOLSS_URL)
625
 
_PUBLIC_ FN_GLOBAL_STRING(lp_wins_config_url, szWINS_CONFIG_URL)
626
 
_PUBLIC_ FN_GLOBAL_STRING(lp_wins_url, szWINS_URL)
627
 
_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbind_separator, szWinbindSeparator)
628
 
_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbindd_socket_directory, szWinbinddSocketDirectory)
629
 
_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbindd_privileged_socket_directory, szWinbinddPrivilegedSocketDirectory)
630
 
_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_shell, szTemplateShell)
631
 
_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_homedir, szTemplateHomedir)
632
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_winbind_sealed_pipes, bWinbindSealedPipes)
633
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_idmap_trusted_only, bIdmapTrustedOnly)
634
 
_PUBLIC_ FN_GLOBAL_STRING(lp_private_dir, szPrivateDir)
635
 
_PUBLIC_ FN_GLOBAL_STRING(lp_serverstring, szServerString)
636
 
_PUBLIC_ FN_GLOBAL_STRING(lp_lockdir, szLockDir)
637
 
_PUBLIC_ FN_GLOBAL_STRING(lp_modulesdir, szModulesDir)
638
 
_PUBLIC_ FN_GLOBAL_STRING(lp_setupdir, szSetupDir)
639
 
_PUBLIC_ FN_GLOBAL_STRING(lp_ncalrpc_dir, ncalrpc_dir)
640
 
_PUBLIC_ FN_GLOBAL_STRING(lp_dos_charset, dos_charset)
641
 
_PUBLIC_ FN_GLOBAL_STRING(lp_unix_charset, unix_charset)
642
 
_PUBLIC_ FN_GLOBAL_STRING(lp_display_charset, display_charset)
643
 
_PUBLIC_ FN_GLOBAL_STRING(lp_piddir, szPidDir)
644
 
_PUBLIC_ FN_GLOBAL_LIST(lp_dcerpc_endpoint_servers, dcerpc_ep_servers)
645
 
_PUBLIC_ FN_GLOBAL_LIST(lp_server_services, server_services)
646
 
_PUBLIC_ FN_GLOBAL_STRING(lp_ntptr_providor, ntptr_providor)
647
 
_PUBLIC_ FN_GLOBAL_STRING(lp_auto_services, szAutoServices)
648
 
_PUBLIC_ FN_GLOBAL_STRING(lp_passwd_chat, szPasswdChat)
649
 
_PUBLIC_ FN_GLOBAL_LIST(lp_passwordserver, szPasswordServers)
650
 
_PUBLIC_ FN_GLOBAL_LIST(lp_name_resolve_order, szNameResolveOrder)
651
 
_PUBLIC_ FN_GLOBAL_STRING(lp_realm, szRealm)
652
 
_PUBLIC_ FN_GLOBAL_STRING(lp_socket_options, socket_options)
653
 
_PUBLIC_ FN_GLOBAL_STRING(lp_workgroup, szWorkgroup)
654
 
_PUBLIC_ FN_GLOBAL_STRING(lp_netbios_name, szNetbiosName)
655
 
_PUBLIC_ FN_GLOBAL_STRING(lp_netbios_scope, szNetbiosScope)
656
 
_PUBLIC_ FN_GLOBAL_LIST(lp_wins_server_list, szWINSservers)
657
 
_PUBLIC_ FN_GLOBAL_LIST(lp_interfaces, szInterfaces)
658
 
_PUBLIC_ FN_GLOBAL_STRING(lp_socket_address, szSocketAddress)
659
 
_PUBLIC_ FN_GLOBAL_LIST(lp_netbios_aliases, szNetbiosAliases)
660
 
 
661
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_disable_netbios, bDisableNetbios)
662
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_wins_support, bWINSsupport)
663
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_wins_dns_proxy, bWINSdnsProxy)
664
 
_PUBLIC_ FN_GLOBAL_STRING(lp_wins_hook, szWINSHook)
665
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_local_master, bLocalMaster)
666
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_readraw, bReadRaw)
667
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_large_readwrite, bLargeReadwrite)
668
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_writeraw, bWriteRaw)
669
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_null_passwords, bNullPasswords)
670
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_obey_pam_restrictions, bObeyPamRestrictions)
671
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_encrypted_passwords, bEncryptPasswords)
672
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_time_server, bTimeServer)
673
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_bind_interfaces_only, bBindInterfacesOnly)
674
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_unicode, bUnicode)
675
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_nt_status_support, bNTStatusSupport)
676
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_lanman_auth, bLanmanAuth)
677
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_ntlm_auth, bNTLMAuth)
678
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_client_plaintext_auth, bClientPlaintextAuth)
679
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_client_lanman_auth, bClientLanManAuth)
680
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, bClientNTLMv2Auth)
681
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_client_use_spnego_principal, client_use_spnego_principal)
682
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_host_msdfs, bHostMSDfs)
683
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_unix_extensions, bUnixExtensions)
684
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_use_spnego, bUseSpnego)
685
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_rpc_big_endian, bRpcBigEndian)
686
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_max_wins_ttl, max_wins_ttl)
687
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_min_wins_ttl, min_wins_ttl)
688
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_maxmux, max_mux)
689
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_max_xmit, max_xmit)
690
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_passwordlevel, pwordlevel)
691
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_maxprotocol, srv_maxprotocol)
692
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_minprotocol, srv_minprotocol)
693
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_maxprotocol, cli_maxprotocol)
694
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_minprotocol, cli_minprotocol)
695
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_security, security)
696
 
_PUBLIC_ FN_GLOBAL_BOOL(lp_paranoid_server_security, paranoid_server_security)
697
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_announce_as, announce_as)
698
 
const char *lp_servicename(const struct loadparm_service *service)
699
 
{
700
 
        return lp_string((const char *)service->szService);
701
 
}
702
 
 
703
 
_PUBLIC_ FN_LOCAL_STRING(lp_pathname, szPath)
704
 
static FN_LOCAL_STRING(_lp_printername, szPrintername)
705
 
_PUBLIC_ FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
706
 
_PUBLIC_ FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
707
 
_PUBLIC_ FN_LOCAL_STRING(lp_comment, comment)
708
 
_PUBLIC_ FN_LOCAL_STRING(lp_fstype, fstype)
709
 
static FN_LOCAL_STRING(lp_volume, volume)
710
 
_PUBLIC_ FN_LOCAL_LIST(lp_ntvfs_handler, ntvfs_handler)
711
 
_PUBLIC_ FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
712
 
_PUBLIC_ FN_LOCAL_BOOL(lp_browseable, bBrowseable)
713
 
_PUBLIC_ FN_LOCAL_BOOL(lp_readonly, bRead_only)
714
 
_PUBLIC_ FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
715
 
_PUBLIC_ FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
716
 
_PUBLIC_ FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
717
 
_PUBLIC_ FN_LOCAL_BOOL(lp_strict_locking, bStrictLocking)
718
 
_PUBLIC_ FN_LOCAL_BOOL(lp_oplocks, bOplocks)
719
 
_PUBLIC_ FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
720
 
_PUBLIC_ FN_LOCAL_BOOL(lp_ci_filesystem, bCIFileSystem)
721
 
_PUBLIC_ FN_LOCAL_BOOL(lp_map_system, bMap_system)
722
 
_PUBLIC_ FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
723
 
_PUBLIC_ FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
724
 
_PUBLIC_ FN_LOCAL_INTEGER(lp_create_mask, iCreate_mask)
725
 
_PUBLIC_ FN_LOCAL_INTEGER(lp_force_create_mode, iCreate_force_mode)
726
 
_PUBLIC_ FN_LOCAL_INTEGER(lp_dir_mask, iDir_mask)
727
 
_PUBLIC_ FN_LOCAL_INTEGER(lp_force_dir_mode, iDir_force_mode)
728
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_server_signing, server_signing)
729
 
_PUBLIC_ FN_GLOBAL_INTEGER(lp_client_signing, client_signing)
730
 
 
731
 
_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_ntp_signd_socket_directory, szNTPSignDSocketDirectory)
 
641
 _PUBLIC_ int lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
 
642
 
 
643
FN_GLOBAL_INTEGER(server_role, server_role)
 
644
FN_GLOBAL_INTEGER(sid_generator, sid_generator)
 
645
FN_GLOBAL_LIST(smb_ports, smb_ports)
 
646
FN_GLOBAL_INTEGER(nbt_port, nbt_port)
 
647
FN_GLOBAL_INTEGER(dgram_port, dgram_port)
 
648
FN_GLOBAL_INTEGER(cldap_port, cldap_port)
 
649
FN_GLOBAL_INTEGER(krb5_port, krb5_port)
 
650
FN_GLOBAL_INTEGER(kpasswd_port, kpasswd_port)
 
651
FN_GLOBAL_INTEGER(web_port, web_port)
 
652
FN_GLOBAL_BOOL(tls_enabled, tls_enabled)
 
653
FN_GLOBAL_STRING(share_backend, szShareBackend)
 
654
FN_GLOBAL_STRING(sam_url, szSAM_URL)
 
655
FN_GLOBAL_STRING(idmap_url, szIDMAP_URL)
 
656
FN_GLOBAL_STRING(secrets_url, szSECRETS_URL)
 
657
FN_GLOBAL_STRING(spoolss_url, szSPOOLSS_URL)
 
658
FN_GLOBAL_STRING(wins_config_url, szWINS_CONFIG_URL)
 
659
FN_GLOBAL_STRING(wins_url, szWINS_URL)
 
660
FN_GLOBAL_CONST_STRING(winbind_separator, szWinbindSeparator)
 
661
FN_GLOBAL_CONST_STRING(winbindd_socket_directory, szWinbinddSocketDirectory)
 
662
FN_GLOBAL_CONST_STRING(winbindd_privileged_socket_directory, szWinbinddPrivilegedSocketDirectory)
 
663
FN_GLOBAL_CONST_STRING(template_shell, szTemplateShell)
 
664
FN_GLOBAL_CONST_STRING(template_homedir, szTemplateHomedir)
 
665
FN_GLOBAL_BOOL(winbind_sealed_pipes, bWinbindSealedPipes)
 
666
FN_GLOBAL_BOOL(idmap_trusted_only, bIdmapTrustedOnly)
 
667
FN_GLOBAL_STRING(private_dir, szPrivateDir)
 
668
FN_GLOBAL_STRING(serverstring, szServerString)
 
669
FN_GLOBAL_STRING(lockdir, szLockDir)
 
670
FN_GLOBAL_STRING(modulesdir, szModulesDir)
 
671
FN_GLOBAL_STRING(ncalrpc_dir, ncalrpc_dir)
 
672
FN_GLOBAL_STRING(dos_charset, dos_charset)
 
673
FN_GLOBAL_STRING(unix_charset, unix_charset)
 
674
FN_GLOBAL_STRING(display_charset, display_charset)
 
675
FN_GLOBAL_STRING(piddir, szPidDir)
 
676
FN_GLOBAL_LIST(rndc_command, szRNDCCommand)
 
677
FN_GLOBAL_LIST(dns_update_command, szDNSUpdateCommand)
 
678
FN_GLOBAL_LIST(spn_update_command, szSPNUpdateCommand)
 
679
FN_GLOBAL_LIST(nsupdate_command, szNSUpdateCommand)
 
680
FN_GLOBAL_LIST(dcerpc_endpoint_servers, dcerpc_ep_servers)
 
681
FN_GLOBAL_LIST(server_services, server_services)
 
682
FN_GLOBAL_STRING(ntptr_providor, ntptr_providor)
 
683
FN_GLOBAL_STRING(auto_services, szAutoServices)
 
684
FN_GLOBAL_STRING(passwd_chat, szPasswdChat)
 
685
FN_GLOBAL_LIST(passwordserver, szPasswordServers)
 
686
FN_GLOBAL_LIST(name_resolve_order, szNameResolveOrder)
 
687
FN_GLOBAL_STRING(realm, szRealm_upper)
 
688
FN_GLOBAL_STRING(dnsdomain, szRealm_lower)
 
689
FN_GLOBAL_STRING(socket_options, socket_options)
 
690
FN_GLOBAL_STRING(workgroup, szWorkgroup)
 
691
FN_GLOBAL_STRING(netbios_name, szNetbiosName)
 
692
FN_GLOBAL_STRING(netbios_scope, szNetbiosScope)
 
693
FN_GLOBAL_LIST(wins_server_list, szWINSservers)
 
694
FN_GLOBAL_LIST(interfaces, szInterfaces)
 
695
FN_GLOBAL_STRING(socket_address, szSocketAddress)
 
696
FN_GLOBAL_LIST(netbios_aliases, szNetbiosAliases)
 
697
FN_GLOBAL_BOOL(disable_netbios, bDisableNetbios)
 
698
FN_GLOBAL_BOOL(wins_support, bWINSsupport)
 
699
FN_GLOBAL_BOOL(wins_dns_proxy, bWINSdnsProxy)
 
700
FN_GLOBAL_STRING(wins_hook, szWINSHook)
 
701
FN_GLOBAL_BOOL(local_master, bLocalMaster)
 
702
FN_GLOBAL_BOOL(readraw, bReadRaw)
 
703
FN_GLOBAL_BOOL(large_readwrite, bLargeReadwrite)
 
704
FN_GLOBAL_BOOL(writeraw, bWriteRaw)
 
705
FN_GLOBAL_BOOL(null_passwords, bNullPasswords)
 
706
FN_GLOBAL_BOOL(obey_pam_restrictions, bObeyPamRestrictions)
 
707
FN_GLOBAL_BOOL(encrypted_passwords, bEncryptPasswords)
 
708
FN_GLOBAL_BOOL(time_server, bTimeServer)
 
709
FN_GLOBAL_BOOL(bind_interfaces_only, bBindInterfacesOnly)
 
710
FN_GLOBAL_BOOL(unicode, bUnicode)
 
711
FN_GLOBAL_BOOL(nt_status_support, bNTStatusSupport)
 
712
FN_GLOBAL_BOOL(lanman_auth, bLanmanAuth)
 
713
FN_GLOBAL_BOOL(ntlm_auth, bNTLMAuth)
 
714
FN_GLOBAL_BOOL(client_plaintext_auth, bClientPlaintextAuth)
 
715
FN_GLOBAL_BOOL(client_lanman_auth, bClientLanManAuth)
 
716
FN_GLOBAL_BOOL(client_ntlmv2_auth, bClientNTLMv2Auth)
 
717
FN_GLOBAL_BOOL(client_use_spnego_principal, client_use_spnego_principal)
 
718
FN_GLOBAL_BOOL(host_msdfs, bHostMSDfs)
 
719
FN_GLOBAL_BOOL(unix_extensions, bUnixExtensions)
 
720
FN_GLOBAL_BOOL(use_spnego, bUseSpnego)
 
721
FN_GLOBAL_BOOL(rpc_big_endian, bRpcBigEndian)
 
722
FN_GLOBAL_INTEGER(max_wins_ttl, max_wins_ttl)
 
723
FN_GLOBAL_INTEGER(min_wins_ttl, min_wins_ttl)
 
724
FN_GLOBAL_INTEGER(maxmux, max_mux)
 
725
FN_GLOBAL_INTEGER(max_xmit, max_xmit)
 
726
FN_GLOBAL_INTEGER(passwordlevel, pwordlevel)
 
727
FN_GLOBAL_INTEGER(srv_maxprotocol, srv_maxprotocol)
 
728
FN_GLOBAL_INTEGER(srv_minprotocol, srv_minprotocol)
 
729
FN_GLOBAL_INTEGER(cli_maxprotocol, cli_maxprotocol)
 
730
FN_GLOBAL_INTEGER(cli_minprotocol, cli_minprotocol)
 
731
FN_GLOBAL_INTEGER(security, security)
 
732
FN_GLOBAL_BOOL(paranoid_server_security, paranoid_server_security)
 
733
FN_GLOBAL_INTEGER(announce_as, announce_as)
 
734
 
 
735
FN_LOCAL_STRING(pathname, szPath)
 
736
FN_LOCAL_LIST(hostsallow, szHostsallow)
 
737
FN_LOCAL_LIST(hostsdeny, szHostsdeny)
 
738
FN_LOCAL_STRING(comment, comment)
 
739
FN_LOCAL_STRING(fstype, fstype)
 
740
FN_LOCAL_LIST(ntvfs_handler, ntvfs_handler)
 
741
FN_LOCAL_BOOL(msdfs_root, bMSDfsRoot)
 
742
FN_LOCAL_BOOL(browseable, bBrowseable)
 
743
FN_LOCAL_BOOL(readonly, bRead_only)
 
744
FN_LOCAL_BOOL(print_ok, bPrint_ok)
 
745
FN_LOCAL_BOOL(map_hidden, bMap_hidden)
 
746
FN_LOCAL_BOOL(map_archive, bMap_archive)
 
747
FN_LOCAL_BOOL(strict_locking, bStrictLocking)
 
748
FN_LOCAL_BOOL(oplocks, bOplocks)
 
749
FN_LOCAL_BOOL(strict_sync, bStrictSync)
 
750
FN_LOCAL_BOOL(ci_filesystem, bCIFileSystem)
 
751
FN_LOCAL_BOOL(map_system, bMap_system)
 
752
FN_LOCAL_INTEGER(max_connections, iMaxConnections)
 
753
FN_LOCAL_INTEGER(csc_policy, iCSCPolicy)
 
754
FN_LOCAL_INTEGER(create_mask, iCreate_mask)
 
755
FN_LOCAL_INTEGER(force_create_mode, iCreate_force_mode)
 
756
FN_LOCAL_INTEGER(dir_mask, iDir_mask)
 
757
FN_LOCAL_INTEGER(force_dir_mode, iDir_force_mode)
 
758
FN_GLOBAL_INTEGER(server_signing, server_signing)
 
759
FN_GLOBAL_INTEGER(client_signing, client_signing)
 
760
 
 
761
FN_GLOBAL_CONST_STRING(ntp_signd_socket_directory, szNTPSignDSocketDirectory)
732
762
 
733
763
/* local prototypes */
734
764
static int map_parameter(const char *pszParmName);
735
 
static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx, 
 
765
static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx,
736
766
                                        const char *pszServiceName);
737
767
static void copy_service(struct loadparm_service *pserviceDest,
738
768
                         struct loadparm_service *pserviceSource,
744
774
/* This is a helper function for parametrical options support. */
745
775
/* It returns a pointer to parametrical option value if it exists or NULL otherwise */
746
776
/* Actual parametrical functions are quite simple */
747
 
const char *lp_get_parametric(struct loadparm_context *lp_ctx,
 
777
const char *lpcfg_get_parametric(struct loadparm_context *lp_ctx,
748
778
                              struct loadparm_service *service,
749
779
                              const char *type, const char *option)
750
780
{
751
 
        char *vfskey;
752
 
        struct parmlist_entry *data;
 
781
        char *vfskey = NULL;
 
782
        struct parmlist_entry *data;
753
783
 
754
784
        if (lp_ctx == NULL)
755
785
                return NULL;
757
787
        data = (service == NULL ? lp_ctx->globals->param_opt : service->param_opt);
758
788
 
759
789
        asprintf(&vfskey, "%s:%s", type, option);
 
790
        if (vfskey == NULL) return NULL;
760
791
        strlower(vfskey);
761
792
 
762
793
        while (data) {
854
885
 * Returned value is allocated in 'lp_talloc' context
855
886
 */
856
887
 
857
 
const char *lp_parm_string(struct loadparm_context *lp_ctx,
858
 
                           struct loadparm_service *service, const char *type,
859
 
                           const char *option)
 
888
const char *lpcfg_parm_string(struct loadparm_context *lp_ctx,
 
889
                              struct loadparm_service *service, const char *type,
 
890
                              const char *option)
860
891
{
861
 
        const char *value = lp_get_parametric(lp_ctx, service, type, option);
 
892
        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
862
893
 
863
894
        if (value)
864
895
                return lp_string(value);
872
903
 * Returned value is allocated in 'lp_talloc' context
873
904
 */
874
905
 
875
 
const char **lp_parm_string_list(TALLOC_CTX *mem_ctx,
876
 
                                 struct loadparm_context *lp_ctx,
877
 
                                 struct loadparm_service *service,
878
 
                                 const char *type,
879
 
                                 const char *option, const char *separator)
 
906
const char **lpcfg_parm_string_list(TALLOC_CTX *mem_ctx,
 
907
                                    struct loadparm_context *lp_ctx,
 
908
                                    struct loadparm_service *service,
 
909
                                    const char *type,
 
910
                                    const char *option, const char *separator)
880
911
{
881
 
        const char *value = lp_get_parametric(lp_ctx, service, type, option);
 
912
        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
882
913
 
883
914
        if (value != NULL)
884
915
                return (const char **)str_list_make(mem_ctx, value, separator);
891
922
 * Parametric option has following syntax: 'Type: option = value'
892
923
 */
893
924
 
894
 
int lp_parm_int(struct loadparm_context *lp_ctx,
895
 
                struct loadparm_service *service, const char *type,
896
 
                const char *option, int default_v)
 
925
int lpcfg_parm_int(struct loadparm_context *lp_ctx,
 
926
                   struct loadparm_service *service, const char *type,
 
927
                   const char *option, int default_v)
897
928
{
898
 
        const char *value = lp_get_parametric(lp_ctx, service, type, option);
 
929
        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
899
930
 
900
931
        if (value)
901
932
                return lp_int(value);
909
940
 * Parametric option has following syntax: 'Type: option = value'.
910
941
 */
911
942
 
912
 
int lp_parm_bytes(struct loadparm_context *lp_ctx,
 
943
int lpcfg_parm_bytes(struct loadparm_context *lp_ctx,
913
944
                  struct loadparm_service *service, const char *type,
914
945
                  const char *option, int default_v)
915
946
{
916
947
        uint64_t bval;
917
948
 
918
 
        const char *value = lp_get_parametric(lp_ctx, service, type, option);
 
949
        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
919
950
 
920
951
        if (value && conv_str_size(value, &bval)) {
921
952
                if (bval <= INT_MAX) {
931
962
 * Type is a part of option before ':'
932
963
 * Parametric option has following syntax: 'Type: option = value'
933
964
 */
934
 
unsigned long lp_parm_ulong(struct loadparm_context *lp_ctx,
 
965
unsigned long lpcfg_parm_ulong(struct loadparm_context *lp_ctx,
935
966
                            struct loadparm_service *service, const char *type,
936
967
                            const char *option, unsigned long default_v)
937
968
{
938
 
        const char *value = lp_get_parametric(lp_ctx, service, type, option);
 
969
        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
939
970
 
940
971
        if (value)
941
972
                return lp_ulong(value);
944
975
}
945
976
 
946
977
 
947
 
double lp_parm_double(struct loadparm_context *lp_ctx,
 
978
double lpcfg_parm_double(struct loadparm_context *lp_ctx,
948
979
                      struct loadparm_service *service, const char *type,
949
980
                      const char *option, double default_v)
950
981
{
951
 
        const char *value = lp_get_parametric(lp_ctx, service, type, option);
 
982
        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
952
983
 
953
984
        if (value != NULL)
954
985
                return lp_double(value);
961
992
 * Parametric option has following syntax: 'Type: option = value'
962
993
 */
963
994
 
964
 
bool lp_parm_bool(struct loadparm_context *lp_ctx,
965
 
                  struct loadparm_service *service, const char *type,
966
 
                  const char *option, bool default_v)
 
995
bool lpcfg_parm_bool(struct loadparm_context *lp_ctx,
 
996
                     struct loadparm_service *service, const char *type,
 
997
                     const char *option, bool default_v)
967
998
{
968
 
        const char *value = lp_get_parametric(lp_ctx, service, type, option);
 
999
        const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
969
1000
 
970
1001
        if (value != NULL)
971
1002
                return lp_bool(value);
1013
1044
 * service.
1014
1045
 */
1015
1046
 
1016
 
struct loadparm_service *lp_add_service(struct loadparm_context *lp_ctx,
1017
 
                                     const struct loadparm_service *pservice,
1018
 
                                     const char *name)
 
1047
struct loadparm_service *lpcfg_add_service(struct loadparm_context *lp_ctx,
 
1048
                                           const struct loadparm_service *pservice,
 
1049
                                           const char *name)
1019
1050
{
1020
1051
        int i;
1021
1052
        struct loadparm_service tservice;
1022
1053
        int num_to_alloc = lp_ctx->iNumServices + 1;
1023
1054
        struct parmlist_entry *data, *pdata;
1024
1055
 
 
1056
        if (pservice == NULL) {
 
1057
                pservice = lp_ctx->sDefault;
 
1058
        }
 
1059
 
1025
1060
        tservice = *pservice;
1026
1061
 
1027
1062
        /* it might already exist */
1054
1089
                tsp = talloc_realloc(lp_ctx, lp_ctx->services, struct loadparm_service *, num_to_alloc);
1055
1090
 
1056
1091
                if (!tsp) {
1057
 
                        DEBUG(0,("lp_add_service: failed to enlarge services!\n"));
 
1092
                        DEBUG(0,("lpcfg_add_service: failed to enlarge services!\n"));
1058
1093
                        return NULL;
1059
1094
                } else {
1060
1095
                        lp_ctx->services = tsp;
1066
1101
 
1067
1102
        lp_ctx->services[i] = init_service(lp_ctx->services, lp_ctx->sDefault);
1068
1103
        if (lp_ctx->services[i] == NULL) {
1069
 
                DEBUG(0,("lp_add_service: out of memory!\n"));
 
1104
                DEBUG(0,("lpcfg_add_service: out of memory!\n"));
1070
1105
                return NULL;
1071
1106
        }
1072
1107
        copy_service(lp_ctx->services[i], &tservice, NULL);
1080
1115
 * from service ifrom.
1081
1116
 */
1082
1117
 
1083
 
bool lp_add_home(struct loadparm_context *lp_ctx,
 
1118
bool lpcfg_add_home(struct loadparm_context *lp_ctx,
1084
1119
                 const char *pszHomename,
1085
1120
                 struct loadparm_service *default_service,
1086
1121
                 const char *user, const char *pszHomedir)
1087
1122
{
1088
1123
        struct loadparm_service *service;
1089
1124
 
1090
 
        service = lp_add_service(lp_ctx, default_service, pszHomename);
 
1125
        service = lpcfg_add_service(lp_ctx, default_service, pszHomename);
1091
1126
 
1092
1127
        if (service == NULL)
1093
1128
                return false;
1096
1131
            || strequal(default_service->szPath, lp_ctx->sDefault->szPath)) {
1097
1132
                service->szPath = talloc_strdup(service, pszHomedir);
1098
1133
        } else {
1099
 
                service->szPath = string_sub_talloc(service, lp_pathname(default_service, lp_ctx->sDefault), "%H", pszHomedir); 
 
1134
                service->szPath = string_sub_talloc(service, lpcfg_pathname(default_service, lp_ctx->sDefault), "%H", pszHomedir);
1100
1135
        }
1101
1136
 
1102
1137
        if (!(*(service->comment))) {
1112
1147
}
1113
1148
 
1114
1149
/**
1115
 
 * Add the IPC service.
1116
 
 */
1117
 
 
1118
 
static bool lp_add_hidden(struct loadparm_context *lp_ctx, const char *name,
1119
 
                          const char *fstype)
1120
 
{
1121
 
        struct loadparm_service *service = lp_add_service(lp_ctx, lp_ctx->sDefault, name);
1122
 
 
1123
 
        if (service == NULL)
1124
 
                return false;
1125
 
 
1126
 
        string_set(service, &service->szPath, tmpdir());
1127
 
 
1128
 
        service->comment = talloc_asprintf(service, "%s Service (%s)",
1129
 
                                fstype, lp_ctx->globals->szServerString);
1130
 
        string_set(service, &service->fstype, fstype);
1131
 
        service->iMaxConnections = -1;
1132
 
        service->bAvailable = true;
1133
 
        service->bRead_only = true;
1134
 
        service->bPrint_ok = false;
1135
 
        service->bBrowseable = false;
1136
 
 
1137
 
        if (strcasecmp(fstype, "IPC") == 0) {
1138
 
                lp_do_service_parameter(lp_ctx, service, "ntvfs handler",
1139
 
                                        "default");
1140
 
        }
1141
 
 
1142
 
        DEBUG(3, ("adding hidden service %s\n", name));
1143
 
 
1144
 
        return true;
1145
 
}
1146
 
 
1147
 
/**
1148
1150
 * Add a new printer service, with defaults coming from service iFrom.
1149
1151
 */
1150
1152
 
1154
1156
{
1155
1157
        const char *comment = "From Printcap";
1156
1158
        struct loadparm_service *service;
1157
 
        service = lp_add_service(lp_ctx, default_service, pszPrintername);
 
1159
        service = lpcfg_add_service(lp_ctx, default_service, pszPrintername);
1158
1160
 
1159
1161
        if (service == NULL)
1160
1162
                return false;
1207
1209
/**
1208
1210
  return the parameter structure for a parameter
1209
1211
*/
1210
 
struct parm_struct *lp_parm_struct(const char *name)
 
1212
struct parm_struct *lpcfg_parm_struct(const char *name)
1211
1213
{
1212
1214
        int parmnum = map_parameter(name);
1213
1215
        if (parmnum == -1) return NULL;
1217
1219
/**
1218
1220
  return the parameter pointer for a parameter
1219
1221
*/
1220
 
void *lp_parm_ptr(struct loadparm_context *lp_ctx,
 
1222
void *lpcfg_parm_ptr(struct loadparm_context *lp_ctx,
1221
1223
                  struct loadparm_service *service, struct parm_struct *parm)
1222
1224
{
1223
1225
        if (service == NULL) {
1235
1237
 * Find a service by name. Otherwise works like get_service.
1236
1238
 */
1237
1239
 
1238
 
static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx, 
 
1240
static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx,
1239
1241
                                        const char *pszServiceName)
1240
1242
{
1241
1243
        int iService;
1328
1330
                        pdata = pdata->next;
1329
1331
                }
1330
1332
                if (not_added) {
1331
 
                        paramo = talloc(pserviceDest, struct parmlist_entry);
 
1333
                        paramo = talloc_zero(pserviceDest, struct parmlist_entry);
1332
1334
                        if (paramo == NULL)
1333
1335
                                smb_panic("OOM");
1334
1336
                        paramo->key = talloc_reference(paramo, data->key);
1448
1450
}
1449
1451
 
1450
1452
/***************************************************************************
 
1453
 Handle the "realm" parameter
 
1454
***************************************************************************/
 
1455
 
 
1456
static bool handle_realm(struct loadparm_context *lp_ctx,
 
1457
                         const char *pszParmValue, char **ptr)
 
1458
{
 
1459
        string_set(lp_ctx, ptr, pszParmValue);
 
1460
 
 
1461
        talloc_free(lp_ctx->globals->szRealm_upper);
 
1462
        talloc_free(lp_ctx->globals->szRealm_lower);
 
1463
 
 
1464
        lp_ctx->globals->szRealm_upper = strupper_talloc(lp_ctx, pszParmValue);
 
1465
        lp_ctx->globals->szRealm_lower = strlower_talloc(lp_ctx, pszParmValue);
 
1466
 
 
1467
        return true;
 
1468
}
 
1469
 
 
1470
/***************************************************************************
1451
1471
 Handle the include operation.
1452
1472
***************************************************************************/
1453
1473
 
1505
1525
static bool handle_debuglevel(struct loadparm_context *lp_ctx,
1506
1526
                        const char *pszParmValue, char **ptr)
1507
1527
{
1508
 
        DEBUGLEVEL = atoi(pszParmValue);
1509
1528
 
1510
 
        return true;
 
1529
        string_set(lp_ctx, ptr, pszParmValue);
 
1530
        return debug_parse_levels(pszParmValue);
1511
1531
}
1512
1532
 
1513
1533
static bool handle_logfile(struct loadparm_context *lp_ctx,
1514
1534
                        const char *pszParmValue, char **ptr)
1515
1535
{
1516
 
        logfile = pszParmValue;
 
1536
        debug_set_logfile(pszParmValue);
 
1537
        string_set(lp_ctx, ptr, pszParmValue);
1517
1538
        return true;
1518
1539
}
1519
1540
 
1583
1604
                }
1584
1605
        }
1585
1606
 
1586
 
        paramo = talloc(mem_ctx, struct parmlist_entry);
 
1607
        paramo = talloc_zero(mem_ctx, struct parmlist_entry);
1587
1608
        if (!paramo)
1588
1609
                smb_panic("OOM");
1589
1610
        paramo->key = talloc_strdup(paramo, name);
1602
1623
 
1603
1624
static bool set_variable(TALLOC_CTX *mem_ctx, int parmnum, void *parm_ptr,
1604
1625
                         const char *pszParmName, const char *pszParmValue,
1605
 
                         struct loadparm_context *lp_ctx)
 
1626
                         struct loadparm_context *lp_ctx, bool on_globals)
1606
1627
{
1607
1628
        int i;
1608
1629
        /* if it is a special case then go ahead */
1609
1630
        if (parm_table[parmnum].special) {
1610
 
                parm_table[parmnum].special(lp_ctx, pszParmValue,
1611
 
                                            (char **)parm_ptr);
1612
 
                return true;
 
1631
                bool ret;
 
1632
                ret = parm_table[parmnum].special(lp_ctx, pszParmValue,
 
1633
                                                  (char **)parm_ptr);
 
1634
                if (!ret) {
 
1635
                        return false;
 
1636
                }
 
1637
                goto mark_non_default;
1613
1638
        }
1614
1639
 
1615
1640
        /* now switch on the type of variable it is */
1648
1673
                        return false;
1649
1674
                }
1650
1675
 
1651
 
                case P_LIST:
 
1676
                case P_CMDLIST:
1652
1677
                        *(const char ***)parm_ptr = (const char **)str_list_make(mem_ctx,
1653
1678
                                                                  pszParmValue, NULL);
1654
1679
                        break;
 
1680
                case P_LIST:
 
1681
                {
 
1682
                        char **new_list = str_list_make(mem_ctx,
 
1683
                                                        pszParmValue, NULL);
 
1684
                        for (i=0; new_list[i]; i++) {
 
1685
                                if (new_list[i][0] == '+' && new_list[i][1]) {
 
1686
                                        *(const char ***)parm_ptr = str_list_add(*(const char ***)parm_ptr,
 
1687
                                                                                 &new_list[i][1]);
 
1688
                                } else if (new_list[i][0] == '-' && new_list[i][1]) {
 
1689
                                        if (!str_list_check(*(const char ***)parm_ptr,
 
1690
                                                            &new_list[i][1])) {
 
1691
                                                DEBUG(0, ("Unsupported value for: %s = %s, %s is not in the original list\n",
 
1692
                                                          pszParmName, pszParmValue, new_list[i]));
 
1693
                                                return false;
1655
1694
 
 
1695
                                        }
 
1696
                                        str_list_remove(*(const char ***)parm_ptr,
 
1697
                                                        &new_list[i][1]);
 
1698
                                } else {
 
1699
                                        if (i != 0) {
 
1700
                                                DEBUG(0, ("Unsupported list syntax for: %s = %s\n",
 
1701
                                                          pszParmName, pszParmValue));
 
1702
                                                return false;
 
1703
                                        }
 
1704
                                        *(const char ***)parm_ptr = (const char **) new_list;
 
1705
                                        break;
 
1706
                                }
 
1707
                        }
 
1708
                        break;
 
1709
                }
1656
1710
                case P_STRING:
1657
1711
                        string_set(mem_ctx, (char **)parm_ptr, pszParmValue);
1658
1712
                        break;
1681
1735
                        break;
1682
1736
        }
1683
1737
 
1684
 
        if (lp_ctx->flags[parmnum] & FLAG_DEFAULT) {
 
1738
mark_non_default:
 
1739
        if (on_globals && (lp_ctx->flags[parmnum] & FLAG_DEFAULT)) {
1685
1740
                lp_ctx->flags[parmnum] &= ~FLAG_DEFAULT;
1686
1741
                /* we have to also unset FLAG_DEFAULT on aliases */
1687
1742
                for (i=parmnum-1;i>=0 && parm_table[i].offset == parm_table[parmnum].offset;i--) {
1695
1750
}
1696
1751
 
1697
1752
 
1698
 
bool lp_do_global_parameter(struct loadparm_context *lp_ctx,
1699
 
                            const char *pszParmName, const char *pszParmValue)
 
1753
bool lpcfg_do_global_parameter(struct loadparm_context *lp_ctx,
 
1754
                               const char *pszParmName, const char *pszParmValue)
1700
1755
{
1701
1756
        int parmnum = map_parameter(pszParmName);
1702
1757
        void *parm_ptr;
1715
1770
                return true;
1716
1771
        }
1717
1772
 
1718
 
        parm_ptr = lp_parm_ptr(lp_ctx, NULL, &parm_table[parmnum]);
 
1773
        parm_ptr = lpcfg_parm_ptr(lp_ctx, NULL, &parm_table[parmnum]);
1719
1774
 
1720
 
        return set_variable(lp_ctx, parmnum, parm_ptr,
1721
 
                            pszParmName, pszParmValue, lp_ctx);
 
1775
        return set_variable(lp_ctx->globals, parmnum, parm_ptr,
 
1776
                            pszParmName, pszParmValue, lp_ctx, true);
1722
1777
}
1723
1778
 
1724
 
bool lp_do_service_parameter(struct loadparm_context *lp_ctx,
1725
 
                             struct loadparm_service *service,
1726
 
                             const char *pszParmName, const char *pszParmValue)
 
1779
bool lpcfg_do_service_parameter(struct loadparm_context *lp_ctx,
 
1780
                                struct loadparm_service *service,
 
1781
                                const char *pszParmName, const char *pszParmValue)
1727
1782
{
1728
1783
        void *parm_ptr;
1729
1784
        int i;
1762
1817
                        service->copymap[i] = false;
1763
1818
 
1764
1819
        return set_variable(service, parmnum, parm_ptr, pszParmName,
1765
 
                            pszParmValue, lp_ctx);
 
1820
                            pszParmValue, lp_ctx, false);
1766
1821
}
1767
1822
 
1768
1823
/**
1775
1830
        struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
1776
1831
 
1777
1832
        if (lp_ctx->bInGlobalSection)
1778
 
                return lp_do_global_parameter(lp_ctx, pszParmName,
 
1833
                return lpcfg_do_global_parameter(lp_ctx, pszParmName,
1779
1834
                                              pszParmValue);
1780
1835
        else
1781
 
                return lp_do_service_parameter(lp_ctx, lp_ctx->currentService,
1782
 
                                               pszParmName, pszParmValue);
 
1836
                return lpcfg_do_service_parameter(lp_ctx, lp_ctx->currentService,
 
1837
                                                  pszParmName, pszParmValue);
1783
1838
}
1784
1839
 
1785
1840
/*
1786
1841
  variable argument do parameter
1787
1842
*/
1788
 
bool lp_do_global_parameter_var(struct loadparm_context *lp_ctx, const char *pszParmName, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
1789
 
bool lp_do_global_parameter_var(struct loadparm_context *lp_ctx,
 
1843
bool lpcfg_do_global_parameter_var(struct loadparm_context *lp_ctx, const char *pszParmName, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
 
1844
bool lpcfg_do_global_parameter_var(struct loadparm_context *lp_ctx,
1790
1845
                                const char *pszParmName, const char *fmt, ...)
1791
1846
{
1792
1847
        char *s;
1796
1851
        va_start(ap, fmt);
1797
1852
        s = talloc_vasprintf(NULL, fmt, ap);
1798
1853
        va_end(ap);
1799
 
        ret = lp_do_global_parameter(lp_ctx, pszParmName, s);
 
1854
        ret = lpcfg_do_global_parameter(lp_ctx, pszParmName, s);
1800
1855
        talloc_free(s);
1801
1856
        return ret;
1802
1857
}
1807
1862
  parsing code. It sets the parameter then marks the parameter as unable to be modified
1808
1863
  by smb.conf processing
1809
1864
*/
1810
 
bool lp_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
1811
 
                    const char *pszParmValue)
 
1865
bool lpcfg_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
 
1866
                       const char *pszParmValue)
1812
1867
{
1813
1868
        int parmnum = map_parameter(pszParmName);
1814
1869
        int i;
1830
1885
        /* reset the CMDLINE flag in case this has been called before */
1831
1886
        lp_ctx->flags[parmnum] &= ~FLAG_CMDLINE;
1832
1887
 
1833
 
        if (!lp_do_global_parameter(lp_ctx, pszParmName, pszParmValue)) {
 
1888
        if (!lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue)) {
1834
1889
                return false;
1835
1890
        }
1836
1891
 
1850
1905
/*
1851
1906
  set a option from the commandline in 'a=b' format. Use to support --option
1852
1907
*/
1853
 
bool lp_set_option(struct loadparm_context *lp_ctx, const char *option)
 
1908
bool lpcfg_set_option(struct loadparm_context *lp_ctx, const char *option)
1854
1909
{
1855
1910
        char *p, *s;
1856
1911
        bool ret;
1868
1923
 
1869
1924
        *p = 0;
1870
1925
 
1871
 
        ret = lp_set_cmdline(lp_ctx, s, p+1);
 
1926
        ret = lpcfg_set_cmdline(lp_ctx, s, p+1);
1872
1927
        free(s);
1873
1928
        return ret;
1874
1929
}
1883
1938
static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
1884
1939
{
1885
1940
        int i;
 
1941
        const char *list_sep = ", "; /* For the seperation of lists values that we print below */
1886
1942
        switch (p->type)
1887
1943
        {
1888
1944
                case P_ENUM:
1908
1964
                        fprintf(f, "0%o", *(int *)ptr);
1909
1965
                        break;
1910
1966
 
 
1967
                case P_CMDLIST:
 
1968
                        list_sep = " ";
 
1969
                        /* fall through */
1911
1970
                case P_LIST:
1912
1971
                        if ((char ***)ptr && *(char ***)ptr) {
1913
1972
                                char **list = *(char ***)ptr;
1914
1973
 
1915
 
                                for (; *list; list++)
1916
 
                                        fprintf(f, "%s%s", *list,
1917
 
                                                ((*(list+1))?", ":""));
 
1974
                                for (; *list; list++) {
 
1975
                                        if (*(list+1) == NULL) {
 
1976
                                                /* last item, print no extra seperator after */
 
1977
                                                list_sep = "";
 
1978
                                        }
 
1979
                                        fprintf(f, "%s%s", *list, list_sep);
 
1980
                                }
1918
1981
                        }
1919
1982
                        break;
1920
1983
 
1943
2006
                case P_ENUM:
1944
2007
                        return (*((int *)ptr1) == *((int *)ptr2));
1945
2008
 
 
2009
                case P_CMDLIST:
1946
2010
                case P_LIST:
1947
2011
                        return str_list_equal((const char **)(*(char ***)ptr1),
1948
2012
                                              (const char **)(*(char ***)ptr2));
1998
2062
                /* issued by the post-processing of a previous section. */
1999
2063
                DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
2000
2064
 
2001
 
                if ((lp_ctx->currentService = lp_add_service(lp_ctx, lp_ctx->sDefault,
2002
 
                                                             pszSectionName))
 
2065
                if ((lp_ctx->currentService = lpcfg_add_service(lp_ctx, lp_ctx->sDefault,
 
2066
                                                                   pszSectionName))
2003
2067
                    == NULL) {
2004
2068
                        DEBUG(0, ("Failed to add a new service\n"));
2005
2069
                        return false;
2020
2084
        if (!defaults_saved)
2021
2085
                return false;
2022
2086
        switch (parm_table[i].type) {
 
2087
                case P_CMDLIST:
2023
2088
                case P_LIST:
2024
2089
                        return str_list_equal((const char **)parm_table[i].def.lvalue, 
2025
2090
                                              (const char **)def_ptr);
2056
2121
                if (parm_table[i].pclass == P_GLOBAL &&
2057
2122
                    parm_table[i].offset != -1 &&
2058
2123
                    (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset))) {
2059
 
                        if (!show_defaults && (lp_ctx->flags[i] & FLAG_DEFAULT)) 
 
2124
                        if (!show_defaults && (lp_ctx->flags[i] & FLAG_DEFAULT))
2060
2125
                                continue;
2061
2126
                        fprintf(f, "\t%s = ", parm_table[i].label);
2062
 
                        print_parameter(&parm_table[i], lp_parm_ptr(lp_ctx, NULL, &parm_table[i]), f);
 
2127
                        print_parameter(&parm_table[i], lpcfg_parm_ptr(lp_ctx, NULL, &parm_table[i]), f);
2063
2128
                        fprintf(f, "\n");
2064
2129
        }
2065
2130
        if (lp_ctx->globals->param_opt != NULL) {
2066
2131
                for (data = lp_ctx->globals->param_opt; data;
2067
2132
                     data = data->next) {
 
2133
                        if (!show_defaults && (data->priority & FLAG_DEFAULT)) {
 
2134
                                continue;
 
2135
                        }
2068
2136
                        fprintf(f, "\t%s = %s\n", data->key, data->value);
2069
2137
                }
2070
2138
        }
2075
2143
 * Display the contents of a single services record.
2076
2144
 */
2077
2145
 
2078
 
static void dump_a_service(struct loadparm_service * pService, struct loadparm_service *sDefault, FILE * f)
 
2146
static void dump_a_service(struct loadparm_service * pService, struct loadparm_service *sDefault, FILE * f,
 
2147
                           unsigned int *flags)
2079
2148
{
2080
2149
        int i;
2081
2150
        struct parmlist_entry *data;
2090
2159
                    (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset)))
2091
2160
                {
2092
2161
                        if (pService == sDefault) {
2093
 
                                if (defaults_saved && is_default(sDefault, i))
 
2162
                                if (flags && (flags[i] & FLAG_DEFAULT)) {
2094
2163
                                        continue;
 
2164
                                }
 
2165
                                if (defaults_saved) {
 
2166
                                        if (is_default(sDefault, i)) {
 
2167
                                                continue;
 
2168
                                        }
 
2169
                                }
2095
2170
                        } else {
2096
2171
                                if (equal_parameter(parm_table[i].type,
2097
2172
                                                    ((char *)pService) +
2114
2189
        }
2115
2190
}
2116
2191
 
2117
 
bool lp_dump_a_parameter(struct loadparm_context *lp_ctx,
2118
 
                         struct loadparm_service *service,
2119
 
                         const char *parm_name, FILE * f)
 
2192
bool lpcfg_dump_a_parameter(struct loadparm_context *lp_ctx,
 
2193
                            struct loadparm_service *service,
 
2194
                            const char *parm_name, FILE * f)
2120
2195
{
2121
2196
        struct parm_struct *parm;
2122
2197
        void *ptr;
2123
2198
 
2124
 
        parm = lp_parm_struct(parm_name);
 
2199
        parm = lpcfg_parm_struct(parm_name);
2125
2200
        if (!parm) {
2126
2201
                return false;
2127
2202
        }
2128
2203
 
2129
 
        ptr = lp_parm_ptr(lp_ctx, service,parm);
 
2204
        ptr = lpcfg_parm_ptr(lp_ctx, service,parm);
2130
2205
 
2131
2206
        print_parameter(parm, ptr, f);
2132
2207
        fprintf(f, "\n");
2139
2214
 * Return NULL when out of parameters.
2140
2215
 */
2141
2216
 
2142
 
struct parm_struct *lp_next_parameter(struct loadparm_context *lp_ctx, int snum, int *i, 
2143
 
                                      int allparameters)
 
2217
 
 
2218
struct parm_struct *lpcfg_next_parameter(struct loadparm_context *lp_ctx, int snum, int *i,
 
2219
                                         int allparameters)
2144
2220
{
2145
2221
        if (snum == -1) {
2146
2222
                /* do the globals */
2187
2263
/**
2188
2264
 * Auto-load some home services.
2189
2265
 */
2190
 
static void lp_add_auto_services(struct loadparm_context *lp_ctx,
2191
 
                                 const char *str)
 
2266
static void lpcfg_add_auto_services(struct loadparm_context *lp_ctx,
 
2267
                                    const char *str)
2192
2268
{
2193
2269
        return;
2194
2270
}
2219
2295
{
2220
2296
        struct parmlist_entry *data;
2221
2297
 
 
2298
        if (lp_ctx->refuse_free) {
 
2299
                /* someone is trying to free the
 
2300
                   global_loadparm_context.
 
2301
                   We can't allow that. */
 
2302
                return -1;
 
2303
        }
 
2304
 
2222
2305
        if (lp_ctx->globals->param_opt != NULL) {
2223
2306
                struct parmlist_entry *next;
2224
2307
                for (data = lp_ctx->globals->param_opt; data; data=next) {
2234
2317
 
2235
2318
/**
2236
2319
 * Initialise the global parameter structure.
 
2320
 *
 
2321
 * Note that most callers should use loadparm_init_global() instead
2237
2322
 */
2238
2323
struct loadparm_context *loadparm_init(TALLOC_CTX *mem_ctx)
2239
2324
{
2240
2325
        int i;
2241
2326
        char *myname;
2242
2327
        struct loadparm_context *lp_ctx;
 
2328
        struct parmlist_entry *parm;
2243
2329
 
2244
2330
        lp_ctx = talloc_zero(mem_ctx, struct loadparm_context);
2245
2331
        if (lp_ctx == NULL)
2279
2365
                }
2280
2366
        }
2281
2367
 
2282
 
        lp_do_global_parameter(lp_ctx, "share backend", "classic");
2283
 
 
2284
 
        lp_do_global_parameter(lp_ctx, "server role", "standalone");
 
2368
 
 
2369
        lpcfg_do_global_parameter(lp_ctx, "log level", "0");
 
2370
 
 
2371
        lpcfg_do_global_parameter(lp_ctx, "share backend", "classic");
 
2372
 
 
2373
        lpcfg_do_global_parameter(lp_ctx, "share backend", "classic");
 
2374
 
 
2375
        lpcfg_do_global_parameter(lp_ctx, "server role", "standalone");
2285
2376
 
2286
2377
        /* options that can be set on the command line must be initialised via
2287
 
           the slower lp_do_global_parameter() to ensure that FLAG_CMDLINE is obeyed */
 
2378
           the slower lpcfg_do_global_parameter() to ensure that FLAG_CMDLINE is obeyed */
2288
2379
#ifdef TCP_NODELAY
2289
 
        lp_do_global_parameter(lp_ctx, "socket options", "TCP_NODELAY");
 
2380
        lpcfg_do_global_parameter(lp_ctx, "socket options", "TCP_NODELAY");
2290
2381
#endif
2291
 
        lp_do_global_parameter(lp_ctx, "workgroup", DEFAULT_WORKGROUP);
 
2382
        lpcfg_do_global_parameter(lp_ctx, "workgroup", DEFAULT_WORKGROUP);
2292
2383
        myname = get_myname(lp_ctx);
2293
 
        lp_do_global_parameter(lp_ctx, "netbios name", myname);
 
2384
        lpcfg_do_global_parameter(lp_ctx, "netbios name", myname);
2294
2385
        talloc_free(myname);
2295
 
        lp_do_global_parameter(lp_ctx, "name resolve order", "wins host bcast");
2296
 
 
2297
 
        lp_do_global_parameter(lp_ctx, "fstype", "NTFS");
2298
 
 
2299
 
        lp_do_global_parameter(lp_ctx, "ntvfs handler", "unixuid default");
2300
 
        lp_do_global_parameter(lp_ctx, "max connections", "-1");
2301
 
 
2302
 
        lp_do_global_parameter(lp_ctx, "dcerpc endpoint servers", "epmapper srvsvc wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi winreg dssetup unixinfo browser");
2303
 
        lp_do_global_parameter(lp_ctx, "server services", "smb rpc nbt wrepl ldap cldap kdc drepl winbind ntp_signd kcc");
2304
 
        lp_do_global_parameter(lp_ctx, "ntptr providor", "simple_ldb");
2305
 
        lp_do_global_parameter(lp_ctx, "auth methods:domain controller", "anonymous sam_ignoredomain");
2306
 
        lp_do_global_parameter(lp_ctx, "auth methods:member server", "anonymous sam winbind");
2307
 
        lp_do_global_parameter(lp_ctx, "auth methods:standalone", "anonymous sam_ignoredomain");
2308
 
        lp_do_global_parameter(lp_ctx, "private dir", dyn_PRIVATE_DIR);
2309
 
        lp_do_global_parameter(lp_ctx, "sam database", "sam.ldb");
2310
 
        lp_do_global_parameter(lp_ctx, "idmap database", "idmap.ldb");
2311
 
        lp_do_global_parameter(lp_ctx, "secrets database", "secrets.ldb");
2312
 
        lp_do_global_parameter(lp_ctx, "spoolss database", "spoolss.ldb");
2313
 
        lp_do_global_parameter(lp_ctx, "wins config database", "wins_config.ldb");
2314
 
        lp_do_global_parameter(lp_ctx, "wins database", "wins.ldb");
2315
 
        lp_do_global_parameter(lp_ctx, "registry:HKEY_LOCAL_MACHINE", "hklm.ldb");
 
2386
        lpcfg_do_global_parameter(lp_ctx, "name resolve order", "wins host bcast");
 
2387
 
 
2388
        lpcfg_do_global_parameter(lp_ctx, "fstype", "NTFS");
 
2389
 
 
2390
        lpcfg_do_global_parameter(lp_ctx, "ntvfs handler", "unixuid default");
 
2391
        lpcfg_do_global_parameter(lp_ctx, "max connections", "-1");
 
2392
 
 
2393
        lpcfg_do_global_parameter(lp_ctx, "dcerpc endpoint servers", "epmapper srvsvc wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi winreg dssetup unixinfo browser eventlog6 backupkey");
 
2394
        lpcfg_do_global_parameter(lp_ctx, "server services", "smb rpc nbt wrepl ldap cldap kdc drepl winbind ntp_signd kcc dnsupdate web");
 
2395
        lpcfg_do_global_parameter(lp_ctx, "ntptr providor", "simple_ldb");
 
2396
        /* the winbind method for domain controllers is for both RODC
 
2397
           auth forwarding and for trusted domains */
 
2398
        lpcfg_do_global_parameter(lp_ctx, "auth methods:domain controller", "anonymous sam_ignoredomain winbind");
 
2399
        lpcfg_do_global_parameter(lp_ctx, "auth methods:member server", "anonymous sam winbind");
 
2400
        lpcfg_do_global_parameter(lp_ctx, "auth methods:standalone", "anonymous sam_ignoredomain");
 
2401
        lpcfg_do_global_parameter(lp_ctx, "private dir", dyn_PRIVATE_DIR);
 
2402
        lpcfg_do_global_parameter(lp_ctx, "sam database", "sam.ldb");
 
2403
        lpcfg_do_global_parameter(lp_ctx, "idmap database", "idmap.ldb");
 
2404
        lpcfg_do_global_parameter(lp_ctx, "secrets database", "secrets.ldb");
 
2405
        lpcfg_do_global_parameter(lp_ctx, "spoolss database", "spoolss.ldb");
 
2406
        lpcfg_do_global_parameter(lp_ctx, "wins config database", "wins_config.ldb");
 
2407
        lpcfg_do_global_parameter(lp_ctx, "wins database", "wins.ldb");
 
2408
        lpcfg_do_global_parameter(lp_ctx, "registry:HKEY_LOCAL_MACHINE", "hklm.ldb");
2316
2409
 
2317
2410
        /* This hive should be dynamically generated by Samba using
2318
2411
           data from the sam, but for the moment leave it in a tdb to
2319
2412
           keep regedt32 from popping up an annoying dialog. */
2320
 
        lp_do_global_parameter(lp_ctx, "registry:HKEY_USERS", "hku.ldb");
 
2413
        lpcfg_do_global_parameter(lp_ctx, "registry:HKEY_USERS", "hku.ldb");
2321
2414
 
2322
2415
        /* using UTF8 by default allows us to support all chars */
2323
 
        lp_do_global_parameter(lp_ctx, "unix charset", "UTF8");
 
2416
        lpcfg_do_global_parameter(lp_ctx, "unix charset", "UTF8");
2324
2417
 
2325
2418
        /* Use codepage 850 as a default for the dos character set */
2326
 
        lp_do_global_parameter(lp_ctx, "dos charset", "CP850");
 
2419
        lpcfg_do_global_parameter(lp_ctx, "dos charset", "CP850");
2327
2420
 
2328
2421
        /*
2329
2422
         * Allow the default PASSWD_CHAT to be overridden in local.h.
2330
2423
         */
2331
 
        lp_do_global_parameter(lp_ctx, "passwd chat", DEFAULT_PASSWD_CHAT);
2332
 
 
2333
 
        lp_do_global_parameter(lp_ctx, "pid directory", dyn_PIDDIR);
2334
 
        lp_do_global_parameter(lp_ctx, "lock dir", dyn_LOCKDIR);
2335
 
        lp_do_global_parameter(lp_ctx, "modules dir", dyn_MODULESDIR);
2336
 
        lp_do_global_parameter(lp_ctx, "ncalrpc dir", dyn_NCALRPCDIR);
2337
 
 
2338
 
        lp_do_global_parameter(lp_ctx, "socket address", "0.0.0.0");
2339
 
        lp_do_global_parameter_var(lp_ctx, "server string",
 
2424
        lpcfg_do_global_parameter(lp_ctx, "passwd chat", DEFAULT_PASSWD_CHAT);
 
2425
 
 
2426
        lpcfg_do_global_parameter(lp_ctx, "pid directory", dyn_PIDDIR);
 
2427
        lpcfg_do_global_parameter(lp_ctx, "lock dir", dyn_LOCKDIR);
 
2428
        lpcfg_do_global_parameter(lp_ctx, "modules dir", dyn_MODULESDIR);
 
2429
        lpcfg_do_global_parameter(lp_ctx, "ncalrpc dir", dyn_NCALRPCDIR);
 
2430
 
 
2431
        lpcfg_do_global_parameter(lp_ctx, "socket address", "0.0.0.0");
 
2432
        lpcfg_do_global_parameter_var(lp_ctx, "server string",
2340
2433
                                   "Samba %s", SAMBA_VERSION_STRING);
2341
2434
 
2342
 
        lp_do_global_parameter_var(lp_ctx, "announce version", "%d.%d",
 
2435
        lpcfg_do_global_parameter_var(lp_ctx, "announce version", "%d.%d",
2343
2436
                         DEFAULT_MAJOR_VERSION,
2344
2437
                         DEFAULT_MINOR_VERSION);
2345
2438
 
2346
 
        lp_do_global_parameter(lp_ctx, "password server", "*");
2347
 
 
2348
 
        lp_do_global_parameter(lp_ctx, "max mux", "50");
2349
 
        lp_do_global_parameter(lp_ctx, "max xmit", "12288");
2350
 
        lp_do_global_parameter(lp_ctx, "password level", "0");
2351
 
        lp_do_global_parameter(lp_ctx, "LargeReadwrite", "True");
2352
 
        lp_do_global_parameter(lp_ctx, "server min protocol", "CORE");
2353
 
        lp_do_global_parameter(lp_ctx, "server max protocol", "NT1");
2354
 
        lp_do_global_parameter(lp_ctx, "client min protocol", "CORE");
2355
 
        lp_do_global_parameter(lp_ctx, "client max protocol", "NT1");
2356
 
        lp_do_global_parameter(lp_ctx, "security", "USER");
2357
 
        lp_do_global_parameter(lp_ctx, "paranoid server security", "True");
2358
 
        lp_do_global_parameter(lp_ctx, "EncryptPasswords", "True");
2359
 
        lp_do_global_parameter(lp_ctx, "ReadRaw", "True");
2360
 
        lp_do_global_parameter(lp_ctx, "WriteRaw", "True");
2361
 
        lp_do_global_parameter(lp_ctx, "NullPasswords", "False");
2362
 
        lp_do_global_parameter(lp_ctx, "ObeyPamRestrictions", "False");
2363
 
        lp_do_global_parameter(lp_ctx, "announce as", "NT SERVER");
2364
 
 
2365
 
        lp_do_global_parameter(lp_ctx, "TimeServer", "False");
2366
 
        lp_do_global_parameter(lp_ctx, "BindInterfacesOnly", "False");
2367
 
        lp_do_global_parameter(lp_ctx, "Unicode", "True");
2368
 
        lp_do_global_parameter(lp_ctx, "ClientLanManAuth", "False");
2369
 
        lp_do_global_parameter(lp_ctx, "LanmanAuth", "False");
2370
 
        lp_do_global_parameter(lp_ctx, "NTLMAuth", "True");
2371
 
        lp_do_global_parameter(lp_ctx, "client use spnego principal", "False");
2372
 
 
2373
 
        lp_do_global_parameter(lp_ctx, "UnixExtensions", "False");
2374
 
 
2375
 
        lp_do_global_parameter(lp_ctx, "PreferredMaster", "Auto");
2376
 
        lp_do_global_parameter(lp_ctx, "LocalMaster", "True");
2377
 
 
2378
 
        lp_do_global_parameter(lp_ctx, "wins support", "False");
2379
 
        lp_do_global_parameter(lp_ctx, "dns proxy", "True");
2380
 
 
2381
 
        lp_do_global_parameter(lp_ctx, "winbind separator", "\\");
2382
 
        lp_do_global_parameter(lp_ctx, "winbind sealed pipes", "True");
2383
 
        lp_do_global_parameter(lp_ctx, "winbindd socket directory", dyn_WINBINDD_SOCKET_DIR);
2384
 
        lp_do_global_parameter(lp_ctx, "winbindd privileged socket directory", dyn_WINBINDD_PRIVILEGED_SOCKET_DIR);
2385
 
        lp_do_global_parameter(lp_ctx, "template shell", "/bin/false");
2386
 
        lp_do_global_parameter(lp_ctx, "template homedir", "/home/%WORKGROUP%/%ACCOUNTNAME%");
2387
 
        lp_do_global_parameter(lp_ctx, "idmap trusted only", "False");
2388
 
 
2389
 
        lp_do_global_parameter(lp_ctx, "client signing", "Yes");
2390
 
        lp_do_global_parameter(lp_ctx, "server signing", "auto");
2391
 
 
2392
 
        lp_do_global_parameter(lp_ctx, "use spnego", "True");
2393
 
 
2394
 
        lp_do_global_parameter(lp_ctx, "smb ports", "445 139");
2395
 
        lp_do_global_parameter(lp_ctx, "nbt port", "137");
2396
 
        lp_do_global_parameter(lp_ctx, "dgram port", "138");
2397
 
        lp_do_global_parameter(lp_ctx, "cldap port", "389");
2398
 
        lp_do_global_parameter(lp_ctx, "krb5 port", "88");
2399
 
        lp_do_global_parameter(lp_ctx, "kpasswd port", "464");
2400
 
        lp_do_global_parameter(lp_ctx, "web port", "901");
2401
 
        lp_do_global_parameter(lp_ctx, "swat directory", dyn_SWATDIR);
2402
 
 
2403
 
        lp_do_global_parameter(lp_ctx, "nt status support", "True");
2404
 
 
2405
 
        lp_do_global_parameter(lp_ctx, "max wins ttl", "518400"); /* 6 days */
2406
 
        lp_do_global_parameter(lp_ctx, "min wins ttl", "10");
2407
 
 
2408
 
        lp_do_global_parameter(lp_ctx, "tls enabled", "True");
2409
 
        lp_do_global_parameter(lp_ctx, "tls keyfile", "tls/key.pem");
2410
 
        lp_do_global_parameter(lp_ctx, "tls certfile", "tls/cert.pem");
2411
 
        lp_do_global_parameter(lp_ctx, "tls cafile", "tls/ca.pem");
2412
 
        lp_do_global_parameter_var(lp_ctx, "setup directory", "%s",
2413
 
                                   dyn_SETUPDIR);
2414
 
 
2415
 
        lp_do_global_parameter(lp_ctx, "prefork children:smb", "4");
2416
 
 
2417
 
        lp_do_global_parameter(lp_ctx, "ntp signd socket directory", dyn_NTP_SIGND_SOCKET_DIR);
 
2439
        lpcfg_do_global_parameter(lp_ctx, "password server", "*");
 
2440
 
 
2441
        lpcfg_do_global_parameter(lp_ctx, "max mux", "50");
 
2442
        lpcfg_do_global_parameter(lp_ctx, "max xmit", "12288");
 
2443
        lpcfg_do_global_parameter(lp_ctx, "password level", "0");
 
2444
        lpcfg_do_global_parameter(lp_ctx, "LargeReadwrite", "True");
 
2445
        lpcfg_do_global_parameter(lp_ctx, "server min protocol", "CORE");
 
2446
        lpcfg_do_global_parameter(lp_ctx, "server max protocol", "NT1");
 
2447
        lpcfg_do_global_parameter(lp_ctx, "client min protocol", "CORE");
 
2448
        lpcfg_do_global_parameter(lp_ctx, "client max protocol", "NT1");
 
2449
        lpcfg_do_global_parameter(lp_ctx, "security", "USER");
 
2450
        lpcfg_do_global_parameter(lp_ctx, "paranoid server security", "True");
 
2451
        lpcfg_do_global_parameter(lp_ctx, "EncryptPasswords", "True");
 
2452
        lpcfg_do_global_parameter(lp_ctx, "ReadRaw", "True");
 
2453
        lpcfg_do_global_parameter(lp_ctx, "WriteRaw", "True");
 
2454
        lpcfg_do_global_parameter(lp_ctx, "NullPasswords", "False");
 
2455
        lpcfg_do_global_parameter(lp_ctx, "ObeyPamRestrictions", "False");
 
2456
        lpcfg_do_global_parameter(lp_ctx, "announce as", "NT SERVER");
 
2457
 
 
2458
        lpcfg_do_global_parameter(lp_ctx, "TimeServer", "False");
 
2459
        lpcfg_do_global_parameter(lp_ctx, "BindInterfacesOnly", "False");
 
2460
        lpcfg_do_global_parameter(lp_ctx, "Unicode", "True");
 
2461
        lpcfg_do_global_parameter(lp_ctx, "ClientLanManAuth", "False");
 
2462
        lpcfg_do_global_parameter(lp_ctx, "ClientNTLMv2Auth", "True");
 
2463
        lpcfg_do_global_parameter(lp_ctx, "LanmanAuth", "False");
 
2464
        lpcfg_do_global_parameter(lp_ctx, "NTLMAuth", "True");
 
2465
        lpcfg_do_global_parameter(lp_ctx, "client use spnego principal", "False");
 
2466
 
 
2467
        lpcfg_do_global_parameter(lp_ctx, "UnixExtensions", "False");
 
2468
 
 
2469
        lpcfg_do_global_parameter(lp_ctx, "PreferredMaster", "Auto");
 
2470
        lpcfg_do_global_parameter(lp_ctx, "LocalMaster", "True");
 
2471
 
 
2472
        lpcfg_do_global_parameter(lp_ctx, "wins support", "False");
 
2473
        lpcfg_do_global_parameter(lp_ctx, "dns proxy", "True");
 
2474
 
 
2475
        lpcfg_do_global_parameter(lp_ctx, "winbind separator", "\\");
 
2476
        lpcfg_do_global_parameter(lp_ctx, "winbind sealed pipes", "True");
 
2477
        lpcfg_do_global_parameter(lp_ctx, "winbindd socket directory", dyn_WINBINDD_SOCKET_DIR);
 
2478
        lpcfg_do_global_parameter(lp_ctx, "winbindd privileged socket directory", dyn_WINBINDD_PRIVILEGED_SOCKET_DIR);
 
2479
        lpcfg_do_global_parameter(lp_ctx, "template shell", "/bin/false");
 
2480
        lpcfg_do_global_parameter(lp_ctx, "template homedir", "/home/%WORKGROUP%/%ACCOUNTNAME%");
 
2481
        lpcfg_do_global_parameter(lp_ctx, "idmap trusted only", "False");
 
2482
 
 
2483
        lpcfg_do_global_parameter(lp_ctx, "client signing", "Yes");
 
2484
        lpcfg_do_global_parameter(lp_ctx, "server signing", "auto");
 
2485
 
 
2486
        lpcfg_do_global_parameter(lp_ctx, "use spnego", "True");
 
2487
 
 
2488
        lpcfg_do_global_parameter(lp_ctx, "smb ports", "445 139");
 
2489
        lpcfg_do_global_parameter(lp_ctx, "nbt port", "137");
 
2490
        lpcfg_do_global_parameter(lp_ctx, "dgram port", "138");
 
2491
        lpcfg_do_global_parameter(lp_ctx, "cldap port", "389");
 
2492
        lpcfg_do_global_parameter(lp_ctx, "krb5 port", "88");
 
2493
        lpcfg_do_global_parameter(lp_ctx, "kpasswd port", "464");
 
2494
        lpcfg_do_global_parameter(lp_ctx, "web port", "901");
 
2495
 
 
2496
        lpcfg_do_global_parameter(lp_ctx, "nt status support", "True");
 
2497
 
 
2498
        lpcfg_do_global_parameter(lp_ctx, "max wins ttl", "518400"); /* 6 days */
 
2499
        lpcfg_do_global_parameter(lp_ctx, "min wins ttl", "10");
 
2500
 
 
2501
        lpcfg_do_global_parameter(lp_ctx, "tls enabled", "True");
 
2502
        lpcfg_do_global_parameter(lp_ctx, "tls keyfile", "tls/key.pem");
 
2503
        lpcfg_do_global_parameter(lp_ctx, "tls certfile", "tls/cert.pem");
 
2504
        lpcfg_do_global_parameter(lp_ctx, "tls cafile", "tls/ca.pem");
 
2505
        lpcfg_do_global_parameter(lp_ctx, "prefork children:smb", "4");
 
2506
 
 
2507
        lpcfg_do_global_parameter(lp_ctx, "ntp signd socket directory", dyn_NTP_SIGND_SOCKET_DIR);
 
2508
        lpcfg_do_global_parameter(lp_ctx, "rndc command", "/usr/sbin/rndc");
 
2509
        lpcfg_do_global_parameter_var(lp_ctx, "dns update command", "%s/samba_dnsupdate", dyn_SCRIPTSBINDIR);
 
2510
        lpcfg_do_global_parameter_var(lp_ctx, "spn update command", "%s/samba_spnupdate", dyn_SCRIPTSBINDIR);
 
2511
        lpcfg_do_global_parameter(lp_ctx, "nsupdate command", "/usr/bin/nsupdate -g");
2418
2512
 
2419
2513
        for (i = 0; parm_table[i].label; i++) {
2420
2514
                if (!(lp_ctx->flags[i] & FLAG_CMDLINE)) {
2422
2516
                }
2423
2517
        }
2424
2518
 
 
2519
        for (parm=lp_ctx->globals->param_opt; parm; parm=parm->next) {
 
2520
                if (!(parm->priority & FLAG_CMDLINE)) {
 
2521
                        parm->priority |= FLAG_DEFAULT;
 
2522
                }
 
2523
        }
 
2524
 
2425
2525
        return lp_ctx;
2426
2526
}
2427
2527
 
2428
 
const char *lp_configfile(struct loadparm_context *lp_ctx)
 
2528
/**
 
2529
 * Initialise the global parameter structure.
 
2530
 */
 
2531
struct loadparm_context *loadparm_init_global(bool load_default)
 
2532
{
 
2533
        if (global_loadparm_context == NULL) {
 
2534
                global_loadparm_context = loadparm_init(NULL);
 
2535
        }
 
2536
        if (load_default && !global_loadparm_context->loaded) {
 
2537
                lpcfg_load_default(global_loadparm_context);
 
2538
        }
 
2539
        global_loadparm_context->refuse_free = true;
 
2540
        return global_loadparm_context;
 
2541
}
 
2542
 
 
2543
const char *lpcfg_configfile(struct loadparm_context *lp_ctx)
2429
2544
{
2430
2545
        return lp_ctx->szConfigFile;
2431
2546
}
2442
2557
 * Update the internal state of a loadparm context after settings 
2443
2558
 * have changed.
2444
2559
 */
2445
 
static bool lp_update(struct loadparm_context *lp_ctx)
 
2560
static bool lpcfg_update(struct loadparm_context *lp_ctx)
2446
2561
{
2447
 
        lp_add_auto_services(lp_ctx, lp_auto_services(lp_ctx));
2448
 
 
2449
 
        lp_add_hidden(lp_ctx, "IPC$", "IPC");
2450
 
        lp_add_hidden(lp_ctx, "ADMIN$", "DISK");
 
2562
        struct debug_settings settings;
 
2563
        lpcfg_add_auto_services(lp_ctx, lpcfg_auto_services(lp_ctx));
2451
2564
 
2452
2565
        if (!lp_ctx->globals->szWINSservers && lp_ctx->globals->bWINSsupport) {
2453
 
                lp_do_global_parameter(lp_ctx, "wins server", "127.0.0.1");
 
2566
                lpcfg_do_global_parameter(lp_ctx, "wins server", "127.0.0.1");
2454
2567
        }
2455
2568
 
2456
2569
        panic_action = lp_ctx->globals->panic_action;
2457
2570
 
2458
2571
        reload_charcnv(lp_ctx);
2459
2572
 
2460
 
        /* FIXME: ntstatus_check_dos_mapping = lp_nt_status_support(lp_ctx); */
 
2573
        ZERO_STRUCT(settings);
 
2574
        /* Add any more debug-related smb.conf parameters created in
 
2575
         * future here */
 
2576
        settings.timestamp_logs = true;
 
2577
        debug_set_settings(&settings);
 
2578
 
 
2579
        /* FIXME: ntstatus_check_dos_mapping = lpcfg_nt_status_support(lp_ctx); */
2461
2580
 
2462
2581
        /* FIXME: This is a bit of a hack, but we can't use a global, since 
2463
2582
         * not everything that uses lp also uses the socket library */
2464
 
        if (lp_parm_bool(lp_ctx, NULL, "socket", "testnonblock", false)) {
 
2583
        if (lpcfg_parm_bool(lp_ctx, NULL, "socket", "testnonblock", false)) {
2465
2584
                setenv("SOCKET_TESTNONBLOCK", "1", 1);
2466
2585
        } else {
2467
2586
                unsetenv("SOCKET_TESTNONBLOCK");
2468
2587
        }
2469
2588
 
2470
2589
        /* FIXME: Check locale in environment for this: */
2471
 
        if (strcmp(lp_display_charset(lp_ctx), lp_unix_charset(lp_ctx)) != 0)
2472
 
                d_set_iconv(smb_iconv_open(lp_display_charset(lp_ctx), lp_unix_charset(lp_ctx)));
 
2590
        if (strcmp(lpcfg_display_charset(lp_ctx), lpcfg_unix_charset(lp_ctx)) != 0)
 
2591
                d_set_iconv(smb_iconv_open(lpcfg_display_charset(lp_ctx), lpcfg_unix_charset(lp_ctx)));
2473
2592
        else
2474
2593
                d_set_iconv((smb_iconv_t)-1);
2475
2594
 
2476
2595
        return true;
2477
2596
}
2478
2597
 
2479
 
bool lp_load_default(struct loadparm_context *lp_ctx)
 
2598
bool lpcfg_load_default(struct loadparm_context *lp_ctx)
2480
2599
{
2481
2600
    const char *path;
2482
2601
 
2485
2604
    if (!file_exist(path)) {
2486
2605
            /* We allow the default smb.conf file to not exist, 
2487
2606
             * basically the equivalent of an empty file. */
2488
 
            return lp_update(lp_ctx);
 
2607
            return lpcfg_update(lp_ctx);
2489
2608
    }
2490
2609
 
2491
 
    return lp_load(lp_ctx, path);
 
2610
    return lpcfg_load(lp_ctx, path);
2492
2611
}
2493
2612
 
2494
2613
/**
2496
2615
 *
2497
2616
 * Return True on success, False on failure.
2498
2617
 */
2499
 
bool lp_load(struct loadparm_context *lp_ctx, const char *filename)
 
2618
bool lpcfg_load(struct loadparm_context *lp_ctx, const char *filename)
2500
2619
{
2501
2620
        char *n2;
2502
2621
        bool bRetval;
2507
2626
 
2508
2627
        lp_ctx->bInGlobalSection = true;
2509
2628
        n2 = standard_sub_basic(lp_ctx, lp_ctx->szConfigFile);
2510
 
        DEBUG(2, ("lp_load: refreshing parameters from %s\n", n2));
 
2629
        DEBUG(2, ("lpcfg_load: refreshing parameters from %s\n", n2));
2511
2630
 
2512
2631
        add_to_file_list(lp_ctx, lp_ctx->szConfigFile, n2);
2513
2632
 
2521
2640
                if (lp_ctx->currentService != NULL)
2522
2641
                        bRetval = service_ok(lp_ctx->currentService);
2523
2642
 
2524
 
        bRetval = bRetval && lp_update(lp_ctx);
 
2643
        bRetval = bRetval && lpcfg_update(lp_ctx);
 
2644
 
 
2645
        /* we do this unconditionally, so that it happens even
 
2646
           for a missing smb.conf */
 
2647
        reload_charcnv(lp_ctx);
 
2648
 
 
2649
        if (bRetval == true) {
 
2650
                /* set this up so that any child python tasks will
 
2651
                   find the right smb.conf */
 
2652
                setenv("SMB_CONF_PATH", filename, 1);
 
2653
 
 
2654
                /* set the context used by the lp_*() function
 
2655
                   varients */
 
2656
                global_loadparm_context = lp_ctx;
 
2657
                lp_ctx->loaded = true;
 
2658
        }
2525
2659
 
2526
2660
        return bRetval;
2527
2661
}
2530
2664
 * Return the max number of services.
2531
2665
 */
2532
2666
 
2533
 
int lp_numservices(struct loadparm_context *lp_ctx)
 
2667
int lpcfg_numservices(struct loadparm_context *lp_ctx)
2534
2668
{
2535
2669
        return lp_ctx->iNumServices;
2536
2670
}
2539
2673
 * Display the contents of the services array in human-readable form.
2540
2674
 */
2541
2675
 
2542
 
void lp_dump(struct loadparm_context *lp_ctx, FILE *f, bool show_defaults,
 
2676
void lpcfg_dump(struct loadparm_context *lp_ctx, FILE *f, bool show_defaults,
2543
2677
             int maxtoprint)
2544
2678
{
2545
2679
        int iService;
2546
2680
 
2547
 
        if (show_defaults)
2548
 
                defaults_saved = false;
 
2681
        defaults_saved = !show_defaults;
2549
2682
 
2550
2683
        dump_globals(lp_ctx, f, show_defaults);
2551
2684
 
2552
 
        dump_a_service(lp_ctx->sDefault, lp_ctx->sDefault, f);
 
2685
        dump_a_service(lp_ctx->sDefault, lp_ctx->sDefault, f, lp_ctx->flags);
2553
2686
 
2554
2687
        for (iService = 0; iService < maxtoprint; iService++)
2555
 
                lp_dump_one(f, show_defaults, lp_ctx->services[iService], lp_ctx->sDefault);
 
2688
                lpcfg_dump_one(f, show_defaults, lp_ctx->services[iService], lp_ctx->sDefault);
2556
2689
}
2557
2690
 
2558
2691
/**
2559
2692
 * Display the contents of one service in human-readable form.
2560
2693
 */
2561
 
void lp_dump_one(FILE *f, bool show_defaults, struct loadparm_service *service, struct loadparm_service *sDefault)
 
2694
void lpcfg_dump_one(FILE *f, bool show_defaults, struct loadparm_service *service, struct loadparm_service *sDefault)
2562
2695
{
2563
2696
        if (service != NULL) {
2564
2697
                if (service->szService[0] == '\0')
2565
2698
                        return;
2566
 
                dump_a_service(service, sDefault, f);
 
2699
                dump_a_service(service, sDefault, f, NULL);
2567
2700
        }
2568
2701
}
2569
2702
 
2570
 
struct loadparm_service *lp_servicebynum(struct loadparm_context *lp_ctx,
 
2703
struct loadparm_service *lpcfg_servicebynum(struct loadparm_context *lp_ctx,
2571
2704
                                         int snum)
2572
2705
{
2573
2706
        return lp_ctx->services[snum];
2574
2707
}
2575
2708
 
2576
 
struct loadparm_service *lp_service(struct loadparm_context *lp_ctx,
 
2709
struct loadparm_service *lpcfg_service(struct loadparm_context *lp_ctx,
2577
2710
                                    const char *service_name)
2578
2711
{
2579
2712
        int iService;
2589
2722
                        serviceName = standard_sub_basic(
2590
2723
                                        lp_ctx->services[iService],
2591
2724
                                        lp_ctx->services[iService]->szService);
2592
 
                        if (strequal(serviceName, service_name))
 
2725
                        if (strequal(serviceName, service_name)) {
 
2726
                                talloc_free(serviceName);
2593
2727
                                return lp_ctx->services[iService];
 
2728
                        }
 
2729
                        talloc_free(serviceName);
2594
2730
                }
2595
2731
        }
2596
2732
 
2597
 
        DEBUG(7,("lp_servicenumber: couldn't find %s\n", service_name));
 
2733
        DEBUG(7,("lpcfg_servicenumber: couldn't find %s\n", service_name));
2598
2734
        return NULL;
2599
2735
}
2600
2736
 
 
2737
const char *lpcfg_servicename(const struct loadparm_service *service)
 
2738
{
 
2739
        return lp_string((const char *)service->szService);
 
2740
}
2601
2741
 
2602
2742
/**
2603
2743
 * A useful volume label function.
2604
2744
 */
2605
2745
const char *volume_label(struct loadparm_service *service, struct loadparm_service *sDefault)
2606
2746
{
2607
 
        const char *ret = lp_volume(service, sDefault);
 
2747
        const char *ret;
 
2748
        ret = lp_string((const char *)((service != NULL && service->volume != NULL) ?
 
2749
                                       service->volume : sDefault->volume));
2608
2750
        if (!*ret)
2609
 
                return lp_servicename(service);
 
2751
                return lpcfg_servicename(service);
2610
2752
        return ret;
2611
2753
}
2612
2754
 
2613
 
 
2614
2755
/**
2615
2756
 * If we are PDC then prefer us as DMB
2616
2757
 */
2617
 
const char *lp_printername(struct loadparm_service *service, struct loadparm_service *sDefault)
 
2758
const char *lpcfg_printername(struct loadparm_service *service, struct loadparm_service *sDefault)
2618
2759
{
2619
 
        const char *ret = _lp_printername(service, sDefault);
 
2760
        const char *ret;
 
2761
        ret = lp_string((const char *)((service != NULL && service->szPrintername != NULL) ?
 
2762
                                       service->szPrintername : sDefault->szPrintername));
2620
2763
        if (ret == NULL || (ret != NULL && *ret == '\0'))
2621
 
                ret = lp_servicename(service);
 
2764
                ret = lpcfg_servicename(service);
2622
2765
 
2623
2766
        return ret;
2624
2767
}
2627
2770
/**
2628
2771
 * Return the max print jobs per queue.
2629
2772
 */
2630
 
int lp_maxprintjobs(struct loadparm_service *service, struct loadparm_service *sDefault)
 
2773
int lpcfg_maxprintjobs(struct loadparm_service *service, struct loadparm_service *sDefault)
2631
2774
{
2632
2775
        int maxjobs = (service != NULL) ? service->iMaxPrintJobs : sDefault->iMaxPrintJobs;
2633
2776
        if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
2636
2779
        return maxjobs;
2637
2780
}
2638
2781
 
2639
 
struct smb_iconv_convenience *lp_iconv_convenience(struct loadparm_context *lp_ctx)
 
2782
struct smb_iconv_convenience *lpcfg_iconv_convenience(struct loadparm_context *lp_ctx)
2640
2783
{
2641
2784
        if (lp_ctx == NULL) {
2642
 
                static struct smb_iconv_convenience *fallback_ic = NULL;
2643
 
                if (fallback_ic == NULL)
2644
 
                        fallback_ic = smb_iconv_convenience_init(talloc_autofree_context(), 
2645
 
                                                  "CP850", "UTF8", true);
2646
 
                return fallback_ic;
 
2785
                return get_iconv_convenience();
2647
2786
        }
2648
2787
        return lp_ctx->iconv_convenience;
2649
2788
}
2650
2789
 
2651
2790
_PUBLIC_ void reload_charcnv(struct loadparm_context *lp_ctx)
2652
2791
{
2653
 
        talloc_unlink(lp_ctx, lp_ctx->iconv_convenience);
2654
 
        global_iconv_convenience = lp_ctx->iconv_convenience = smb_iconv_convenience_init_lp(lp_ctx, lp_ctx);
 
2792
        struct smb_iconv_convenience *old_ic = lp_ctx->iconv_convenience;
 
2793
        if (old_ic == NULL) {
 
2794
                old_ic = global_iconv_convenience;
 
2795
        }
 
2796
        lp_ctx->iconv_convenience = smb_iconv_convenience_reinit_lp(lp_ctx, lp_ctx, old_ic);
 
2797
        global_iconv_convenience = lp_ctx->iconv_convenience;
2655
2798
}
2656
2799
 
2657
 
void lp_smbcli_options(struct loadparm_context *lp_ctx,
 
2800
void lpcfg_smbcli_options(struct loadparm_context *lp_ctx,
2658
2801
                         struct smbcli_options *options)
2659
2802
{
2660
 
        options->max_xmit = lp_max_xmit(lp_ctx);
2661
 
        options->max_mux = lp_maxmux(lp_ctx);
2662
 
        options->use_spnego = lp_nt_status_support(lp_ctx) && lp_use_spnego(lp_ctx); 
2663
 
        options->signing = lp_client_signing(lp_ctx);
 
2803
        options->max_xmit = lpcfg_max_xmit(lp_ctx);
 
2804
        options->max_mux = lpcfg_maxmux(lp_ctx);
 
2805
        options->use_spnego = lpcfg_nt_status_support(lp_ctx) && lpcfg_use_spnego(lp_ctx);
 
2806
        options->signing = lpcfg_client_signing(lp_ctx);
2664
2807
        options->request_timeout = SMB_REQUEST_TIMEOUT;
2665
 
        options->ntstatus_support = lp_nt_status_support(lp_ctx);
2666
 
        options->max_protocol = lp_cli_maxprotocol(lp_ctx);
2667
 
        options->unicode = lp_unicode(lp_ctx);
 
2808
        options->ntstatus_support = lpcfg_nt_status_support(lp_ctx);
 
2809
        options->max_protocol = lpcfg_cli_maxprotocol(lp_ctx);
 
2810
        options->unicode = lpcfg_unicode(lp_ctx);
2668
2811
        options->use_oplocks = true;
2669
2812
        options->use_level2_oplocks = true;
2670
2813
}
2671
2814
 
2672
 
void lp_smbcli_session_options(struct loadparm_context *lp_ctx,
 
2815
void lpcfg_smbcli_session_options(struct loadparm_context *lp_ctx,
2673
2816
                                 struct smbcli_session_options *options)
2674
2817
{
2675
 
        options->lanman_auth = lp_client_lanman_auth(lp_ctx);
2676
 
        options->ntlmv2_auth = lp_client_ntlmv2_auth(lp_ctx);
2677
 
        options->plaintext_auth = lp_client_plaintext_auth(lp_ctx);
 
2818
        options->lanman_auth = lpcfg_client_lanman_auth(lp_ctx);
 
2819
        options->ntlmv2_auth = lpcfg_client_ntlmv2_auth(lp_ctx);
 
2820
        options->plaintext_auth = lpcfg_client_plaintext_auth(lp_ctx);
2678
2821
}
2679
2822
 
2680
 
_PUBLIC_ char *lp_tls_keyfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
 
2823
_PUBLIC_ char *lpcfg_tls_keyfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
2681
2824
{
2682
2825
        return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_keyfile);
2683
2826
}
2684
2827
 
2685
 
_PUBLIC_ char *lp_tls_certfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
 
2828
_PUBLIC_ char *lpcfg_tls_certfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
2686
2829
{
2687
2830
        return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_certfile);
2688
2831
}
2689
2832
 
2690
 
_PUBLIC_ char *lp_tls_cafile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
 
2833
_PUBLIC_ char *lpcfg_tls_cafile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
2691
2834
{
2692
2835
        return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_cafile);
2693
2836
}
2694
2837
 
2695
 
_PUBLIC_ char *lp_tls_crlfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
 
2838
_PUBLIC_ char *lpcfg_tls_crlfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
2696
2839
{
2697
2840
        return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_crlfile);
2698
2841
}
2699
2842
 
2700
 
_PUBLIC_ char *lp_tls_dhpfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
 
2843
_PUBLIC_ char *lpcfg_tls_dhpfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
2701
2844
{
2702
2845
        return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_dhpfile);
2703
2846
}
2704
2847
 
2705
 
_PUBLIC_ struct dcerpc_server_info *lp_dcerpc_server_info(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
 
2848
_PUBLIC_ struct dcerpc_server_info *lpcfg_dcerpc_server_info(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
2706
2849
{
2707
2850
        struct dcerpc_server_info *ret = talloc_zero(mem_ctx, struct dcerpc_server_info);
2708
2851
 
2709
 
        ret->domain_name = talloc_reference(mem_ctx, lp_workgroup(lp_ctx));
2710
 
        ret->version_major = lp_parm_int(lp_ctx, NULL, "server_info", "version_major", 5);
2711
 
        ret->version_minor = lp_parm_int(lp_ctx, NULL, "server_info", "version_minor", 2);
2712
 
        ret->version_build = lp_parm_int(lp_ctx, NULL, "server_info", "version_build", 3790);
 
2852
        ret->domain_name = talloc_reference(mem_ctx, lpcfg_workgroup(lp_ctx));
 
2853
        ret->version_major = lpcfg_parm_int(lp_ctx, NULL, "server_info", "version_major", 5);
 
2854
        ret->version_minor = lpcfg_parm_int(lp_ctx, NULL, "server_info", "version_minor", 2);
 
2855
        ret->version_build = lpcfg_parm_int(lp_ctx, NULL, "server_info", "version_build", 3790);
2713
2856
 
2714
2857
        return ret;
2715
2858
}
2716
2859
 
2717
 
struct gensec_settings *lp_gensec_settings(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
 
2860
struct gensec_settings *lpcfg_gensec_settings(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
2718
2861
{
2719
2862
        struct gensec_settings *settings = talloc(mem_ctx, struct gensec_settings);
2720
2863
        if (settings == NULL)
2721
2864
                return NULL;
2722
2865
        SMB_ASSERT(lp_ctx != NULL);
2723
2866
        settings->lp_ctx = talloc_reference(settings, lp_ctx);
2724
 
        settings->iconv_convenience = lp_iconv_convenience(lp_ctx);
2725
 
        settings->target_hostname = lp_parm_string(lp_ctx, NULL, "gensec", "target_hostname");
 
2867
        settings->target_hostname = lpcfg_parm_string(lp_ctx, NULL, "gensec", "target_hostname");
2726
2868
        return settings;
2727
2869
}
2728
2870