=================================
- Release Notes for Samba 3.4.0pre1
-
+ Release Notes for Samba 3.6.0pre1
+ July 28, 2010
=================================
-This is the first preview release of Samba 3.4. This is *not*
+
+This is the first preview release of Samba 3.6. This is *not*
intended for production environments and is designed for testing
purposes only. Please report any defects via the Samba bug reporting
system at https://bugzilla.samba.org/.
-Major enhancements in Samba 3.4.0 include:
-Authentication Changes:
-o Changed the way smbd handles untrusted domain names given during user
- authentication
+Major enhancements in Samba 3.6.0 include:
+
+
+SMB2 support
+------------
+
+
+Internal Winbind passdb changes
+-------------------------------
+
+Winbind has been changed to use the internal samr and lsa rpc pipe to get
+local user and group information instead of calling passdb functions. The
+reason is to use more of our infrastructure and test this infrastructure by
+using it. With this approach more code in Winbind is shared.
+
+
+######################################################################
+Changes
+#######
+
+smb.conf changes
+----------------
-Authentication Changes
-======================
+ Parameter Name Description Default
+ -------------- ----------- -------
-Previously, when Samba was a domain member and a client was connecting using an
-untrusted domain name, such as BOGUS\user smbd would remap the untrusted
-domain to the primary domain smbd was a member of and attempt authentication
-using that DOMAIN\user name. This differed from how a Windows member server
-would behave. Now, smbd will replace the BOGUS name with it's SAM name. In
-the case where smbd is acting as a PDC this will be DOMAIN\user. In the case
-where smbd is acting as a domain member server this will be WORKSTATION\user.
-Thus, smbd will never assume that an incoming user name which is not qualified
-with the same primary domain, is part of smbd's primary domain.
+ log writeable files on exit New No
+ ctdb locktime warn threshold New 0
+ smb2 max read New 1048576
+ smb2 max write New 1048576
+ smb2 max trans New 1048576
+ username map cache time New 0
+ async smb echo handler New No
-While this behavior matches Windows, it may break some workflows which depended
-on smbd to always pass through bogus names to the DC for verification. A new
-parameter "map untrusted to domain" can be enabled to revert to the legacy
-behavior.
######################################################################
Reporting bugs & Development Discussion
If you do report problems then please try to send high quality
feedback. If you don't provide vital information to help us track down
the problem then you will probably be ignored. All bug reports should
-be filed under the Samba 3.4 product in the project's Bugzilla
+be filed under the Samba 3.6 product in the project's Bugzilla
database (https://bugzilla.samba.org/).
int torture_setting_int(struct torture_context *test, const char *name,
int default_value)
{
- return lp_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
+ return lpcfg_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
}
unsigned long torture_setting_ulong(struct torture_context *test,
const char *name,
unsigned long default_value)
{
- return lp_parm_ulong(test->lp_ctx, NULL, "torture", name,
+ return lpcfg_parm_ulong(test->lp_ctx, NULL, "torture", name,
default_value);
}
double torture_setting_double(struct torture_context *test, const char *name,
double default_value)
{
- return lp_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
+ return lpcfg_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
}
bool torture_setting_bool(struct torture_context *test, const char *name,
bool default_value)
{
- return lp_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
+ return lpcfg_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
}
const char *torture_setting_string(struct torture_context *test,
SMB_ASSERT(test != NULL);
SMB_ASSERT(test->lp_ctx != NULL);
- ret = lp_parm_string(test->lp_ctx, NULL, "torture", name);
+ ret = lpcfg_parm_string(test->lp_ctx, NULL, "torture", name);
if (ret == NULL)
return default_value;
{
iconv_t cd;
- if (!lp_parm_bool(tctx->lp_ctx, NULL, "iconv", "native", true))
+ if (!lpcfg_parm_bool(tctx->lp_ctx, NULL, "iconv", "native", true))
torture_skip(tctx, "system iconv disabled - skipping test");
cd = iconv_open("UTF-16LE", "UCS-4LE");
"failed to open %s to UTF-16LE",
charset));
}
- cd2 = smb_iconv_open_ex(test, charset, "UTF-16LE", lp_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
- cd3 = smb_iconv_open_ex(test, "UTF-16LE", charset, lp_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
+ cd2 = smb_iconv_open_ex(test, charset, "UTF-16LE", lpcfg_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
+ cd3 = smb_iconv_open_ex(test, "UTF-16LE", charset, lpcfg_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
last_charset = charset;
}
size_t size, size2;
codepoint_t c;
- size = push_codepoint_convenience(lp_iconv_convenience(tctx->lp_ctx), (char *)buf, codepoint);
+ size = push_codepoint_convenience(lpcfg_iconv_convenience(tctx->lp_ctx), (char *)buf, codepoint);
torture_assert(tctx, size != -1 || (codepoint >= 0xd800 && codepoint <= 0x10000),
"Invalid Codepoint range");
buf[size+2] = random();
buf[size+3] = random();
- c = next_codepoint_convenience(lp_iconv_convenience(tctx->lp_ctx), (char *)buf, &size2);
+ c = next_codepoint_convenience(lpcfg_iconv_convenience(tctx->lp_ctx), (char *)buf, &size2);
torture_assert(tctx, c == codepoint,
talloc_asprintf(tctx,
const char **list = (const char **)str_list_make_empty(tctx);
const char **list_dup = (const char **)str_list_make_empty(tctx);
- count = lp_parm_int(tctx->lp_ctx, NULL, "list_unique", "count", 9);
- num_dups = lp_parm_int(tctx->lp_ctx, NULL, "list_unique", "dups", 7);
+ count = lpcfg_parm_int(tctx->lp_ctx, NULL, "list_unique", "count", 9);
+ num_dups = lpcfg_parm_int(tctx->lp_ctx, NULL, "list_unique", "dups", 7);
torture_comment(tctx, "test_list_unique_2() with %d elements and %d dups\n", count, num_dups);
for (i = 0; i < count; i++) {
exit(1);
}
- load_interfaces(NULL, lp_interfaces(cmdline_lp_ctx), &ifaces);
+ load_interfaces(NULL, lpcfg_interfaces(cmdline_lp_ctx), &ifaces);
ev = s4_event_context_init(talloc_autofree_context());
while (poptPeekArg(pc)) {
const char *name = poptGetArg(pc);
- ret &= process_one(cmdline_lp_ctx, ev, ifaces, name, lp_nbt_port(cmdline_lp_ctx));
+ ret &= process_one(cmdline_lp_ctx, ev, ifaces, name, lpcfg_nbt_port(cmdline_lp_ctx));
}
talloc_free(ev);
E_md4hash(oldpass, old_nt_hash);
E_md4hash(newpass, new_nt_hash);
- if (lp_client_lanman_auth(tctx->lp_ctx) &&
+ if (lpcfg_client_lanman_auth(tctx->lp_ctx) &&
E_deshash(newpass, new_lanman_hash) &&
E_deshash(oldpass, old_lanman_hash)) {
struct loadparm_context *lp_ctx)
{
cli_credentials_set_username(cred, "", CRED_UNINITIALISED);
- cli_credentials_set_domain(cred, lp_workgroup(lp_ctx), CRED_UNINITIALISED);
- cli_credentials_set_workstation(cred, lp_netbios_name(lp_ctx), CRED_UNINITIALISED);
- cli_credentials_set_realm(cred, lp_realm(lp_ctx), CRED_UNINITIALISED);
+ cli_credentials_set_domain(cred, lpcfg_workgroup(lp_ctx), CRED_UNINITIALISED);
+ cli_credentials_set_workstation(cred, lpcfg_netbios_name(lp_ctx), CRED_UNINITIALISED);
+ cli_credentials_set_realm(cred, lpcfg_realm(lp_ctx), CRED_UNINITIALISED);
}
/**
cred->machine_account_pending = false;
filter = talloc_asprintf(cred, SECRETS_PRIMARY_DOMAIN_FILTER,
cli_credentials_get_domain(cred));
- status = cli_credentials_set_secrets(cred, event_context_find(cred), lp_ctx, NULL,
+ status = cli_credentials_set_secrets(cred, event_context_find(cred), lp_ctx, NULL,
SECRETS_PRIMARY_DOMAIN_DN,
filter, &error_string);
if (!NT_STATUS_IS_OK(status)) {
filter = talloc_asprintf(cred, SECRETS_KRBTGT_SEARCH,
cli_credentials_get_realm(cred),
cli_credentials_get_domain(cred));
- status = cli_credentials_set_secrets(cred, event_ctx, lp_ctx, NULL,
+ status = cli_credentials_set_secrets(cred, event_ctx, lp_ctx, NULL,
SECRETS_PRINCIPALS_DN,
filter, &error_string);
if (!NT_STATUS_IS_OK(status)) {
cli_credentials_get_realm(cred),
cli_credentials_get_domain(cred),
serviceprincipal);
- status = cli_credentials_set_secrets(cred, event_ctx, lp_ctx, NULL,
+ status = cli_credentials_set_secrets(cred, event_ctx, lp_ctx, NULL,
SECRETS_PRINCIPALS_DN, filter,
&error_string);
if (!NT_STATUS_IS_OK(status)) {
return 0;
}
- ret = smb_krb5_init_context(cred, event_ctx, lp_ctx,
+ ret = smb_krb5_init_context(cred, event_ctx, lp_ctx,
&cred->smb_krb5_context);
if (ret) {
cred->smb_krb5_context = NULL;
return ENOMEM;
}
- ret = cli_credentials_get_krb5_context(cred, event_ctx, lp_ctx,
+ ret = cli_credentials_get_krb5_context(cred, event_ctx, lp_ctx,
&ccc->smb_krb5_context);
if (ret) {
(*error_string) = error_message(ret);
return ENOMEM;
}
- ret = cli_credentials_get_krb5_context(cred, event_ctx, lp_ctx,
+ ret = cli_credentials_get_krb5_context(cred, event_ctx, lp_ctx,
&ccc->smb_krb5_context);
if (ret) {
talloc_free(ccc);
return 0;
}
- ret = cli_credentials_get_ccache(cred, event_ctx, lp_ctx,
+ ret = cli_credentials_get_ccache(cred, event_ctx, lp_ctx,
&ccache, error_string);
if (ret) {
DEBUG(1, ("Failed to get CCACHE for GSSAPI client: %s\n", error_message(ret)));
return EINVAL;
}
- ret = cli_credentials_get_krb5_context(cred, event_ctx, lp_ctx,
+ ret = cli_credentials_get_krb5_context(cred, event_ctx, lp_ctx,
&smb_krb5_context);
if (ret) {
return ret;
_PUBLIC_ int cli_credentials_update_keytab(struct cli_credentials *cred,
struct tevent_context *event_ctx,
- struct loadparm_context *lp_ctx)
+ struct loadparm_context *lp_ctx)
{
krb5_error_code ret;
struct keytab_container *ktc;
if (!PyArg_ParseTuple(args, "|O", &py_lp_ctx))
return NULL;
- lp_ctx = lp_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
- if (lp_ctx == NULL)
+ lp_ctx = lpcfg_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
+ if (lp_ctx == NULL)
return NULL;
cli_credentials_guess(creds, lp_ctx);
if (!PyArg_ParseTuple(args, "|O", &py_lp_ctx))
return NULL;
- lp_ctx = lp_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
- if (lp_ctx == NULL)
+ lp_ctx = lpcfg_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
+ if (lp_ctx == NULL)
return NULL;
status = cli_credentials_set_machine_account(creds, lp_ctx);
if (!PyArg_ParseTuple(args, "|Os", &py_lp_ctx, &ccache_name))
return NULL;
- lp_ctx = lp_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
- if (lp_ctx == NULL)
+ lp_ctx = lpcfg_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
+ if (lp_ctx == NULL)
return NULL;
event_ctx = tevent_context_init(NULL);
bool gensec_security_ops_enabled(struct gensec_security_ops *ops, struct gensec_security *security)
{
- return lp_parm_bool(security->settings->lp_ctx, NULL, "gensec", ops->name, ops->enabled);
+ return lpcfg_parm_bool(security->settings->lp_ctx, NULL, "gensec", ops->name, ops->enabled);
}
/* Sometimes we want to force only kerberos, sometimes we want to
int gensec_setting_int(struct gensec_settings *settings, const char *mechanism, const char *name, int default_value)
{
- return lp_parm_int(settings->lp_ctx, NULL, mechanism, name, default_value);
+ return lpcfg_parm_int(settings->lp_ctx, NULL, mechanism, name, default_value);
}
bool gensec_setting_bool(struct gensec_settings *settings, const char *mechanism, const char *name, bool default_value)
{
- return lp_parm_bool(settings->lp_ctx, NULL, mechanism, name, default_value);
+ return lpcfg_parm_bool(settings->lp_ctx, NULL, mechanism, name, default_value);
}
/*
return NT_STATUS_INTERNAL_ERROR;
}
- realm = lp_realm(gensec_security->settings->lp_ctx);
+ realm = lpcfg_realm(gensec_security->settings->lp_ctx);
if (realm != NULL) {
ret = gsskrb5_set_default_realm(realm);
if (ret) {
gensec_gssapi_state = talloc_get_type(gensec_security->private_data, struct gensec_gssapi_state);
principal = gensec_get_target_principal(gensec_security);
- if (principal && lp_client_use_spnego_principal(gensec_security->settings->lp_ctx)) {
+ if (principal && lpcfg_client_use_spnego_principal(gensec_security->settings->lp_ctx)) {
name_type = GSS_C_NULL_OID;
} else {
principal = talloc_asprintf(gensec_gssapi_state, "%s/%s@%s",
gensec_get_target_service(gensec_security),
- hostname, lp_realm(gensec_security->settings->lp_ctx));
+ hostname, lpcfg_realm(gensec_security->settings->lp_ctx));
name_type = GSS_C_NT_USER_NAME;
}
ret = cli_credentials_set_client_gss_creds(session_info->credentials,
gensec_security->event_ctx,
- gensec_security->settings->lp_ctx,
+ gensec_security->settings->lp_ctx,
gensec_gssapi_state->delegated_cred_handle,
CRED_SPECIFIED, &error_string);
if (ret) {
}
s->target_hostname = PyString_AsString(py_hostname);
- s->lp_ctx = lp_from_py_object(s, py_lp_ctx);
+ s->lp_ctx = lpcfg_from_py_object(s, py_lp_ctx);
return s;
}
workstation = bind_schannel.oem_netbios_computer.a;
domain = bind_schannel.oem_netbios_domain.a;
- if (strcasecmp_m(domain, lp_workgroup(gensec_security->settings->lp_ctx)) != 0) {
+ if (strcasecmp_m(domain, lpcfg_workgroup(gensec_security->settings->lp_ctx)) != 0) {
DEBUG(3, ("Request for schannel to incorrect domain: %s != our domain %s\n",
- domain, lp_workgroup(gensec_security->settings->lp_ctx)));
+ domain, lpcfg_workgroup(gensec_security->settings->lp_ctx)));
return NT_STATUS_LOGON_FAILURE;
}
status = schannel_get_creds_state(out_mem_ctx,
- lp_private_dir(gensec_security->settings->lp_ctx),
+ lpcfg_private_dir(gensec_security->settings->lp_ctx),
workstation, &creds);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(3, ("Could not find session key for attempted schannel connection from %s: %s\n",
if (spnego.negTokenInit.targetPrincipal) {
DEBUG(5, ("Server claims it's principal name is %s\n", spnego.negTokenInit.targetPrincipal));
- if (lp_client_use_spnego_principal(gensec_security->settings->lp_ctx)) {
+ if (lpcfg_client_use_spnego_principal(gensec_security->settings->lp_ctx)) {
gensec_set_target_principal(gensec_security, spnego.negTokenInit.targetPrincipal);
}
}
return ret;
}
- realm = lp_realm(lp_ctx);
+ realm = lpcfg_realm(lp_ctx);
if (realm != NULL) {
ret = krb5_set_default_realm(krb5_ctx, realm);
if (ret) {
/* Set options in kerberos */
krb5_set_dns_canonicalize_hostname((*smb_krb5_context)->krb5_context,
- lp_parm_bool(lp_ctx, NULL, "krb5", "set_dns_canonicalize", false));
+ lpcfg_parm_bool(lp_ctx, NULL, "krb5", "set_dns_canonicalize", false));
return 0;
}
state->method = NULL;
if (!user_info->mapped_state) {
- nt_status = map_user_info(req, lp_workgroup(auth_ctx->lp_ctx),
+ nt_status = map_user_info(req, lpcfg_workgroup(auth_ctx->lp_ctx),
user_info, &user_info_tmp);
if (tevent_req_nterror(req, nt_status)) {
return tevent_req_post(req, ev);
static const char **auth_methods_from_lp(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
{
const char **auth_methods = NULL;
- switch (lp_server_role(lp_ctx)) {
+ switch (lpcfg_server_role(lp_ctx)) {
case ROLE_STANDALONE:
- auth_methods = lp_parm_string_list(mem_ctx, lp_ctx, NULL, "auth methods", "standalone", NULL);
+ auth_methods = lpcfg_parm_string_list(mem_ctx, lp_ctx, NULL, "auth methods", "standalone", NULL);
break;
case ROLE_DOMAIN_MEMBER:
- auth_methods = lp_parm_string_list(mem_ctx, lp_ctx, NULL, "auth methods", "member server", NULL);
+ auth_methods = lpcfg_parm_string_list(mem_ctx, lp_ctx, NULL, "auth methods", "member server", NULL);
break;
case ROLE_DOMAIN_CONTROLLER:
- auth_methods = lp_parm_string_list(mem_ctx, lp_ctx, NULL, "auth methods", "domain controller", NULL);
+ auth_methods = lpcfg_parm_string_list(mem_ctx, lp_ctx, NULL, "auth methods", "domain controller", NULL);
break;
}
return auth_methods;
const struct auth_usersupplied_info *user_info,
struct auth_serversupplied_info **_server_info)
{
- return auth_anonymous_server_info(mem_ctx, lp_netbios_name(ctx->auth_ctx->lp_ctx), _server_info);
+ return auth_anonymous_server_info(mem_ctx, lpcfg_netbios_name(ctx->auth_ctx->lp_ctx), _server_info);
}
static const struct auth_operations anonymous_auth_ops = {
*lm_sess_key = data_blob(NULL, 0);
*user_sess_key = data_blob(NULL, 0);
status = hash_password_check(mem_ctx,
- lp_lanman_auth(auth_context->lp_ctx),
+ lpcfg_lanman_auth(auth_context->lp_ctx),
user_info->password.hash.lanman,
user_info->password.hash.nt,
user_info->mapped.account_name,
case AUTH_PASSWORD_RESPONSE:
status = ntlm_password_check(mem_ctx,
- lp_lanman_auth(auth_context->lp_ctx),
- lp_ntlm_auth(auth_context->lp_ctx),
+ lpcfg_lanman_auth(auth_context->lp_ctx),
+ lpcfg_ntlm_auth(auth_context->lp_ctx),
user_info->logon_parameters,
&auth_context->challenge.data,
&user_info->password.response.lanman,
return nt_status;
}
- nt_status = authsam_make_server_info(tmp_ctx, ctx->auth_ctx->sam_ctx, lp_netbios_name(ctx->auth_ctx->lp_ctx),
- lp_sam_name(ctx->auth_ctx->lp_ctx),
+ nt_status = authsam_make_server_info(tmp_ctx, ctx->auth_ctx->sam_ctx, lpcfg_netbios_name(ctx->auth_ctx->lp_ctx),
+ lpcfg_sam_name(ctx->auth_ctx->lp_ctx),
domain_dn,
msg,
user_sess_key, lm_sess_key,
return NT_STATUS_NOT_IMPLEMENTED;
}
- is_local_name = lp_is_myname(ctx->auth_ctx->lp_ctx,
+ is_local_name = lpcfg_is_myname(ctx->auth_ctx->lp_ctx,
user_info->mapped.domain_name);
- is_my_domain = lp_is_mydomain(ctx->auth_ctx->lp_ctx,
+ is_my_domain = lpcfg_is_mydomain(ctx->auth_ctx->lp_ctx,
user_info->mapped.domain_name);
/* check whether or not we service this domain/workgroup name */
- switch (lp_server_role(ctx->auth_ctx->lp_ctx)) {
+ switch (lpcfg_server_role(ctx->auth_ctx->lp_ctx)) {
case ROLE_STANDALONE:
return NT_STATUS_OK;
return NT_STATUS_OK;
}
- DEBUG(6,("authsam_check_password: lp_server_role() has an undefined value\n"));
+ DEBUG(6,("authsam_check_password: lpcfg_server_role() has an undefined value\n"));
return NT_STATUS_NOT_IMPLEMENTED;
}
}
nt_status = authsam_make_server_info(tmp_ctx, auth_context->sam_ctx,
- lp_netbios_name(auth_context->lp_ctx),
- lp_workgroup(auth_context->lp_ctx),
+ lpcfg_netbios_name(auth_context->lp_ctx),
+ lpcfg_workgroup(auth_context->lp_ctx),
domain_dn,
msg,
user_sess_key, lm_sess_key,
/* Make a connection to the target server, found by 'password server' in smb.conf */
- lp_smbcli_options(ctx->auth_ctx->lp_ctx, &smb_options);
+ lpcfg_smbcli_options(ctx->auth_ctx->lp_ctx, &smb_options);
/* Make a negprot, WITHOUT SPNEGO, so we get a challenge nice an easy */
io.in.options.use_spnego = false;
/* Hope we don't get * (the default), as this won't work... */
- host_list = lp_passwordserver(ctx->auth_ctx->lp_ctx);
+ host_list = lpcfg_passwordserver(ctx->auth_ctx->lp_ctx);
if (!host_list) {
return NT_STATUS_INTERNAL_ERROR;
}
if (strequal(io.in.dest_host, "*")) {
return NT_STATUS_INTERNAL_ERROR;
}
- io.in.dest_ports = lp_smb_ports(ctx->auth_ctx->lp_ctx);
- io.in.socket_options = lp_socket_options(ctx->auth_ctx->lp_ctx);
- io.in.gensec_settings = lp_gensec_settings(mem_ctx, ctx->auth_ctx->lp_ctx);
+ io.in.dest_ports = lpcfg_smb_ports(ctx->auth_ctx->lp_ctx);
+ io.in.socket_options = lpcfg_socket_options(ctx->auth_ctx->lp_ctx);
+ io.in.gensec_settings = lpcfg_gensec_settings(mem_ctx, ctx->auth_ctx->lp_ctx);
io.in.called_name = strupper_talloc(mem_ctx, io.in.dest_host);
/* We don't want to get as far as the session setup */
io.in.credentials = cli_credentials_init_anon(mem_ctx);
cli_credentials_set_workstation(io.in.credentials,
- lp_netbios_name(ctx->auth_ctx->lp_ctx),
+ lpcfg_netbios_name(ctx->auth_ctx->lp_ctx),
CRED_SPECIFIED);
io.in.service = NULL;
io.in.options = smb_options;
- lp_smbcli_session_options(ctx->auth_ctx->lp_ctx, &io.in.session_options);
+ lpcfg_smbcli_session_options(ctx->auth_ctx->lp_ctx, &io.in.session_options);
- status = smb_composite_connect(&io, mem_ctx, lp_resolve_context(ctx->auth_ctx->lp_ctx),
+ status = smb_composite_connect(&io, mem_ctx, lpcfg_resolve_context(ctx->auth_ctx->lp_ctx),
ctx->auth_ctx->event_ctx);
NT_STATUS_NOT_OK_RETURN(status);
session_setup.in.credentials = creds;
session_setup.in.workgroup = ""; /* Only used with SPNEGO, which we are not doing */
- session_setup.in.gensec_settings = lp_gensec_settings(session, ctx->auth_ctx->lp_ctx);
+ session_setup.in.gensec_settings = lpcfg_gensec_settings(session, ctx->auth_ctx->lp_ctx);
/* Check password with remove server - this should be async some day */
nt_status = smb_composite_sesssetup(session, &session_setup);
return pam_to_nt_status(pam_error);
}
-static NTSTATUS check_unix_password(TALLOC_CTX *ctx, struct loadparm_context *lp_ctx,
+static NTSTATUS check_unix_password(TALLOC_CTX *ctx, struct loadparm_context *lp_ctx,
const struct auth_usersupplied_info *user_info, struct passwd **pws)
{
struct smb_pam_user_info *info;
return nt_status;
}
- nt_status = smb_pam_auth(pamh, lp_null_passwords(lp_ctx), user_info->mapped.account_name);
+ nt_status = smb_pam_auth(pamh, lpcfg_null_passwords(lp_ctx), user_info->mapped.account_name);
if (!NT_STATUS_IS_OK(nt_status)) {
smb_pam_end(pamh);
return nt_status;
char *crypted;
struct passwd *pws;
NTSTATUS nt_status;
- int level = lp_passwordlevel(lp_ctx);
+ int level = lpcfg_passwordlevel(lp_ctx);
*ret_passwd = NULL;
#endif
if (crypted[0] == '\0') {
- if (!lp_null_passwords(lp_ctx)) {
+ if (!lpcfg_null_passwords(lp_ctx)) {
DEBUG(2, ("Disallowing %s with null password\n", username));
return NT_STATUS_LOGON_FAILURE;
}
return nt_status;
}
- nt_status = authunix_make_server_info(mem_ctx, lp_netbios_name(ctx->auth_ctx->lp_ctx),
+ nt_status = authunix_make_server_info(mem_ctx, lpcfg_netbios_name(ctx->auth_ctx->lp_ctx),
user_info, pwd, server_info);
if (!NT_STATUS_IS_OK(nt_status)) {
talloc_free(check_ctx);
}
chall_blob = data_blob_talloc(mem_ctx, chal, 8);
- if (lp_client_ntlmv2_auth(auth_context->lp_ctx)) {
- DATA_BLOB names_blob = NTLMv2_generate_names_blob(mem_ctx, lp_netbios_name(auth_context->lp_ctx), lp_workgroup(auth_context->lp_ctx));
+ if (lpcfg_client_ntlmv2_auth(auth_context->lp_ctx)) {
+ DATA_BLOB names_blob = NTLMv2_generate_names_blob(mem_ctx, lpcfg_netbios_name(auth_context->lp_ctx), lpcfg_workgroup(auth_context->lp_ctx));
DATA_BLOB lmv2_response, ntlmv2_response, lmv2_session_key, ntlmv2_session_key;
if (!SMBNTLMv2encrypt_hash(user_info_temp,
SMBOWFencrypt(user_info_in->password.hash.nt->hash, chal, blob.data);
user_info_temp->password.response.nt = blob;
- if (lp_client_lanman_auth(auth_context->lp_ctx) && user_info_in->password.hash.lanman) {
+ if (lpcfg_client_lanman_auth(auth_context->lp_ctx) && user_info_in->password.hash.lanman) {
DATA_BLOB lm_blob = data_blob_talloc(mem_ctx, NULL, 24);
SMBOWFencrypt(user_info_in->password.hash.lanman->hash, chal, blob.data);
user_info_temp->password.response.lanman = lm_blob;
if (ntlmssp_state->use_nt_response) {
flags |= CLI_CRED_NTLM_AUTH;
}
- if (lp_client_lanman_auth(gensec_security->settings->lp_ctx)) {
+ if (lpcfg_client_lanman_auth(gensec_security->settings->lp_ctx)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
}
if ((ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_LM_KEY)
- && lp_client_lanman_auth(gensec_security->settings->lp_ctx) && lm_session_key.length == 16) {
+ && lpcfg_client_lanman_auth(gensec_security->settings->lp_ctx) && lm_session_key.length == 16) {
DATA_BLOB new_session_key = data_blob_talloc(mem_ctx, NULL, 16);
if (lm_response.length == 24) {
SMBsesskeygen_lm_sess_key(lm_session_key.data, lm_response.data,
ntlmssp_state->role = NTLMSSP_CLIENT;
- ntlmssp_state->domain = lp_workgroup(gensec_security->settings->lp_ctx);
+ ntlmssp_state->domain = lpcfg_workgroup(gensec_security->settings->lp_ctx);
ntlmssp_state->unicode = gensec_setting_bool(gensec_security->settings, "ntlmssp_client", "unicode", true);
ntlmssp_state->use_nt_response = gensec_setting_bool(gensec_security->settings, "ntlmssp_client", "send_nt_reponse", true);
- ntlmssp_state->allow_lm_key = (lp_client_lanman_auth(gensec_security->settings->lp_ctx)
+ ntlmssp_state->allow_lm_key = (lpcfg_client_lanman_auth(gensec_security->settings->lp_ctx)
&& (gensec_setting_bool(gensec_security->settings, "ntlmssp_client", "allow_lm_key", false)
|| gensec_setting_bool(gensec_security->settings, "ntlmssp_client", "lm_key", false)));
- ntlmssp_state->use_ntlmv2 = lp_client_ntlmv2_auth(gensec_security->settings->lp_ctx);
+ ntlmssp_state->use_ntlmv2 = lpcfg_client_ntlmv2_auth(gensec_security->settings->lp_ctx);
ntlmssp_state->expected_state = NTLMSSP_INITIAL;
ntlmssp_state->expected_state = NTLMSSP_NEGOTIATE;
- ntlmssp_state->allow_lm_key = (lp_lanman_auth(gensec_security->settings->lp_ctx)
+ ntlmssp_state->allow_lm_key = (lpcfg_lanman_auth(gensec_security->settings->lp_ctx)
&& gensec_setting_bool(gensec_security->settings, "ntlmssp_server", "allow_lm_key", false));
ntlmssp_state->neg_flags =
ntlmssp_state->may_set_challenge = auth_ntlmssp_may_set_challenge;
ntlmssp_state->set_challenge = auth_ntlmssp_set_challenge;
ntlmssp_state->check_password = auth_ntlmssp_check_password;
- if (lp_server_role(gensec_security->settings->lp_ctx) == ROLE_STANDALONE) {
+ if (lpcfg_server_role(gensec_security->settings->lp_ctx) == ROLE_STANDALONE) {
ntlmssp_state->server.is_standalone = true;
} else {
ntlmssp_state->server.is_standalone = false;
}
- ntlmssp_state->server.netbios_name = lp_netbios_name(gensec_security->settings->lp_ctx);
+ ntlmssp_state->server.netbios_name = lpcfg_netbios_name(gensec_security->settings->lp_ctx);
- ntlmssp_state->server.netbios_domain = lp_workgroup(gensec_security->settings->lp_ctx);
+ ntlmssp_state->server.netbios_domain = lpcfg_workgroup(gensec_security->settings->lp_ctx);
{
char dnsdomname[MAXHOSTNAMELEN], dnsname[MAXHOSTNAMELEN];
/* Find out the DNS domain name */
dnsdomname[0] = '\0';
- safe_strcpy(dnsdomname, lp_dnsdomain(gensec_security->settings->lp_ctx), sizeof(dnsdomname) - 1);
+ safe_strcpy(dnsdomname, lpcfg_dnsdomain(gensec_security->settings->lp_ctx), sizeof(dnsdomname) - 1);
/* Find out the DNS host name */
safe_strcpy(dnsname, ntlmssp_state->server.netbios_name, sizeof(dnsname) - 1);
if (!PyArg_ParseTuple(args, "|O", &py_lp_ctx))
return NULL;
- lp_ctx = lp_from_py_object(NULL, py_lp_ctx); /* FIXME: Leaks memory */
+ lp_ctx = lpcfg_from_py_object(NULL, py_lp_ctx); /* FIXME: Leaks memory */
if (lp_ctx == NULL)
return NULL;
if (!PyArg_ParseTuple(args, "|O", &py_lp_ctx))
return NULL;
- lp_ctx = lp_from_py_object(NULL, py_lp_ctx); /* FIXME: leaks memory */
+ lp_ctx = lpcfg_from_py_object(NULL, py_lp_ctx); /* FIXME: leaks memory */
if (lp_ctx == NULL)
return NULL;
if (!PyArg_ParseTuple(args, "OO", &py_lp_ctx, &py_sid))
return NULL;
- lp_ctx = lp_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
+ lp_ctx = lpcfg_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
if (lp_ctx == NULL)
return NULL;
nt_status = gensec_server_start(mem_ctx,
event_ctx,
- lp_gensec_settings(mem_ctx, lp_ctx),
+ lpcfg_gensec_settings(mem_ctx, lp_ctx),
auth_context,
&gensec_ctx);
if (!NT_STATUS_IS_OK(nt_status)) {
#include "auth/session_proto.h"
_PUBLIC_ struct auth_session_info *anonymous_session(TALLOC_CTX *mem_ctx,
- struct loadparm_context *lp_ctx)
+ struct loadparm_context *lp_ctx)
{
NTSTATUS nt_status;
struct auth_session_info *session_info = NULL;
* trusted/prvilaged account), including the local machine account as
* the off-host credentials
*/
-_PUBLIC_ struct auth_session_info *system_session(struct loadparm_context *lp_ctx)
+_PUBLIC_ struct auth_session_info *system_session(struct loadparm_context *lp_ctx)
{
static struct auth_session_info *static_session;
NTSTATUS nt_status;
struct auth_session_info *session_info = NULL;
TALLOC_CTX *mem_ctx = talloc_new(parent_ctx);
- nt_status = auth_system_server_info(mem_ctx, lp_netbios_name(lp_ctx),
+ nt_status = auth_system_server_info(mem_ctx, lpcfg_netbios_name(lp_ctx),
&server_info);
if (!NT_STATUS_IS_OK(nt_status)) {
talloc_free(mem_ctx);
/*
Create a system session, but with anonymous credentials (so we do not need to open secrets.ldb)
*/
-_PUBLIC_ struct auth_session_info *system_session_anon(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+_PUBLIC_ struct auth_session_info *system_session_anon(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
{
NTSTATUS nt_status;
struct auth_session_info *session_info = NULL;
{
return _auth_system_session_info(parent_ctx,
lp_ctx,
- lp_parm_bool(lp_ctx, NULL, "system", "anonymous", false),
+ lpcfg_parm_bool(lp_ctx, NULL, "system", "anonymous", false),
_session_info);
}
struct auth_session_info *session_info = NULL;
TALLOC_CTX *mem_ctx = talloc_new(parent_ctx);
- nt_status = auth_domain_admin_server_info(mem_ctx, lp_netbios_name(lp_ctx),
- lp_workgroup(lp_ctx), domain_sid,
+ nt_status = auth_domain_admin_server_info(mem_ctx, lpcfg_netbios_name(lp_ctx),
+ lpcfg_workgroup(lp_ctx), domain_sid,
&server_info);
if (!NT_STATUS_IS_OK(nt_status)) {
talloc_free(mem_ctx);
TALLOC_CTX *mem_ctx = talloc_new(parent_ctx);
nt_status = auth_anonymous_server_info(mem_ctx,
- lp_netbios_name(lp_ctx),
+ lpcfg_netbios_name(lp_ctx),
&server_info);
if (!NT_STATUS_IS_OK(nt_status)) {
talloc_free(mem_ctx);
ret = tsocket_address_inet_from_strings(cldapd,
"ip",
address,
- lp_cldap_port(lp_ctx),
+ lpcfg_cldap_port(lp_ctx),
&socket_address);
if (ret != 0) {
status = map_nt_error_from_unix(errno);
DEBUG(0,("invalid address %s:%d - %s:%s\n",
- address, lp_cldap_port(lp_ctx),
+ address, lpcfg_cldap_port(lp_ctx),
gai_strerror(ret), nt_errstr(status)));
return status;
}
/* if we are allowing incoming packets from any address, then
we need to bind to the wildcard address */
- if (!lp_bind_interfaces_only(lp_ctx)) {
+ if (!lpcfg_bind_interfaces_only(lp_ctx)) {
status = cldapd_add_socket(cldapd, lp_ctx, "0.0.0.0");
NT_STATUS_NOT_OK_RETURN(status);
}
NTSTATUS status;
struct interface *ifaces;
- load_interfaces(task, lp_interfaces(task->lp_ctx), &ifaces);
+ load_interfaces(task, lpcfg_interfaces(task->lp_ctx), &ifaces);
if (iface_count(ifaces) == 0) {
task_server_terminate(task, "cldapd: no network interfaces configured", false);
return;
}
- switch (lp_server_role(task->lp_ctx)) {
+ switch (lpcfg_server_role(task->lp_ctx)) {
case ROLE_STANDALONE:
task_server_terminate(task, "cldap_server: no CLDAP server required in standalone configuration",
false);
const char *none_attrs[] = {NULL};
struct ldb_result *dom_res = NULL, *user_res = NULL;
int ret;
- const char **services = lp_server_services(lp_ctx);
+ const char **services = lpcfg_server_services(lp_ctx);
uint32_t server_type;
const char *pdc_name;
struct GUID domain_uuid;
}
/* Lookup using long or short domainname */
- if (domain && (strcasecmp_m(domain, lp_dnsdomain(lp_ctx)) == 0)) {
+ if (domain && (strcasecmp_m(domain, lpcfg_dnsdomain(lp_ctx)) == 0)) {
domain_dn = ldb_get_default_basedn(sam_ctx);
}
- if (netbios_domain && (strcasecmp_m(netbios_domain, lp_sam_name(lp_ctx)) == 0)) {
+ if (netbios_domain && (strcasecmp_m(netbios_domain, lpcfg_sam_name(lp_ctx)) == 0)) {
domain_dn = ldb_get_default_basedn(sam_ctx);
}
if (domain_dn) {
"objectClass=domain");
if (ret != LDB_SUCCESS) {
DEBUG(2,("Error finding domain '%s'/'%s' in sam: %s\n",
- lp_dnsdomain(lp_ctx),
+ lpcfg_dnsdomain(lp_ctx),
ldb_dn_get_linearized(domain_dn),
ldb_errstring(sam_ctx)));
return NT_STATUS_NO_SUCH_DOMAIN;
#endif
pdc_name = talloc_asprintf(mem_ctx, "\\\\%s",
- lp_netbios_name(lp_ctx));
+ lpcfg_netbios_name(lp_ctx));
NT_STATUS_HAVE_NO_MEMORY(pdc_name);
domain_uuid = samdb_result_guid(dom_res->msgs[0], "objectGUID");
- dns_domain = lp_dnsdomain(lp_ctx);
+ dns_domain = lpcfg_dnsdomain(lp_ctx);
forest_domain = samdb_forest_name(sam_ctx, mem_ctx);
NT_STATUS_HAVE_NO_MEMORY(forest_domain);
pdc_dns_name = talloc_asprintf(mem_ctx, "%s.%s",
strlower_talloc(mem_ctx,
- lp_netbios_name(lp_ctx)),
+ lpcfg_netbios_name(lp_ctx)),
dns_domain);
NT_STATUS_HAVE_NO_MEMORY(pdc_dns_name);
- flatname = lp_workgroup(lp_ctx);
+ flatname = lpcfg_workgroup(lp_ctx);
server_site = samdb_server_site_name(sam_ctx, mem_ctx);
NT_STATUS_HAVE_NO_MEMORY(server_site);
client_site = samdb_client_site_name(sam_ctx, mem_ctx,
src_address, NULL);
NT_STATUS_HAVE_NO_MEMORY(client_site);
- load_interfaces(mem_ctx, lp_interfaces(lp_ctx), &ifaces);
+ load_interfaces(mem_ctx, lpcfg_interfaces(lp_ctx), &ifaces);
/*
* TODO: the caller should pass the address which the client
* used to trigger this call, as the client is able to reach
}
if ((domain == NULL) && (domain_guid == NULL) && (domain_sid == NULL)) {
- domain = lp_dnsdomain(cldapd->task->lp_ctx);
+ domain = lpcfg_dnsdomain(cldapd->task->lp_ctx);
}
if (version == -1) {
obs = check_arg_numeric("obs");
count = check_arg_numeric("count");
- lp_smbcli_options(lp_ctx, &options);
- lp_smbcli_session_options(lp_ctx, &session_options);
+ lpcfg_smbcli_options(lp_ctx, &options);
+ lpcfg_smbcli_session_options(lp_ctx, &session_options);
/* Allocate IO buffer. We need more than the max IO size because we
* could accumulate a remainder if ibs and obs don't match.
DEBUG(4, ("IO buffer size is %llu, max xmit is %d\n",
(unsigned long long)iomax, options.max_xmit));
- if (!(ifile = open_file(lp_resolve_context(lp_ctx), ev, "if",
- lp_smb_ports(lp_ctx), &options,
- lp_socket_options(lp_ctx),
+ if (!(ifile = open_file(lpcfg_resolve_context(lp_ctx), ev, "if",
+ lpcfg_smb_ports(lp_ctx), &options,
+ lpcfg_socket_options(lp_ctx),
&session_options,
- lp_gensec_settings(lp_ctx, lp_ctx)))) {
+ lpcfg_gensec_settings(lp_ctx, lp_ctx)))) {
return(FILESYS_EXIT_CODE);
}
- if (!(ofile = open_file(lp_resolve_context(lp_ctx), ev, "of",
- lp_smb_ports(lp_ctx), &options,
- lp_socket_options(lp_ctx),
+ if (!(ofile = open_file(lpcfg_resolve_context(lp_ctx), ev, "of",
+ lpcfg_smb_ports(lp_ctx), &options,
+ lpcfg_socket_options(lp_ctx),
&session_options,
- lp_gensec_settings(lp_ctx, lp_ctx)))) {
+ lpcfg_gensec_settings(lp_ctx, lp_ctx)))) {
return(FILESYS_EXIT_CODE);
}
poptFreeContext(pc);
- lp_smbcli_options(cmdline_lp_ctx, &smb_options);
- lp_smbcli_session_options(cmdline_lp_ctx, &smb_session_options);
+ lpcfg_smbcli_options(cmdline_lp_ctx, &smb_options);
+ lpcfg_smbcli_session_options(cmdline_lp_ctx, &smb_session_options);
ev_ctx = s4_event_context_init(talloc_autofree_context());
if (query_host) {
rc = do_host_query(cmdline_lp_ctx, ev_ctx, query_host,
- lp_workgroup(cmdline_lp_ctx));
+ lpcfg_workgroup(cmdline_lp_ctx));
return rc;
}
if (message) {
- rc = do_message_op(lp_netbios_name(cmdline_lp_ctx), desthost,
- lp_smb_ports(cmdline_lp_ctx), dest_ip,
+ rc = do_message_op(lpcfg_netbios_name(cmdline_lp_ctx), desthost,
+ lpcfg_smb_ports(cmdline_lp_ctx), dest_ip,
name_type, ev_ctx,
- lp_resolve_context(cmdline_lp_ctx),
+ lpcfg_resolve_context(cmdline_lp_ctx),
&smb_options,
- lp_socket_options(cmdline_lp_ctx));
+ lpcfg_socket_options(cmdline_lp_ctx));
return rc;
}
- if (!do_connect(ctx, ev_ctx, lp_resolve_context(cmdline_lp_ctx),
- desthost, lp_smb_ports(cmdline_lp_ctx), service,
- lp_socket_options(cmdline_lp_ctx),
+ if (!do_connect(ctx, ev_ctx, lpcfg_resolve_context(cmdline_lp_ctx),
+ desthost, lpcfg_smb_ports(cmdline_lp_ctx), service,
+ lpcfg_socket_options(cmdline_lp_ctx),
cmdline_credentials, &smb_options, &smb_session_options,
- lp_gensec_settings(ctx, cmdline_lp_ctx)))
+ lpcfg_gensec_settings(ctx, cmdline_lp_ctx)))
return 1;
if (base_directory) {
return count;
}
-NTSTATUS samdb_result_passwords(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx, struct ldb_message *msg,
+NTSTATUS samdb_result_passwords(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx, struct ldb_message *msg,
struct samr_Password **lm_pwd, struct samr_Password **nt_pwd)
{
struct samr_Password *lmPwdHash, *ntPwdHash;
/* Ensure that if we have turned off LM
* authentication, that we never use the LM hash, even
* if we store it */
- if (lp_lanman_auth(lp_ctx)) {
+ if (lpcfg_lanman_auth(lp_ctx)) {
unsigned int num_lm;
num_lm = samdb_result_hashes(mem_ctx, msg, "dBCSPwd", &lmPwdHash);
if (num_lm == 0) {
int fd;
unsigned int i;
const char *attrs[] = { "sAMAccountName", NULL };
- const char *realm = lp_realm(service->task->lp_ctx);
+ const char *realm = lpcfg_realm(service->task->lp_ctx);
TALLOC_CTX *tmp_ctx = talloc_new(service);
- const char * const *rndc_command = lp_rndc_command(service->task->lp_ctx);
+ const char * const *rndc_command = lpcfg_rndc_command(service->task->lp_ctx);
/* abort any pending script run */
TALLOC_FREE(service->confupdate.subreq);
return;
}
- path = lp_parm_string(service->task->lp_ctx, NULL, "dnsupdate", "path");
+ path = lpcfg_parm_string(service->task->lp_ctx, NULL, "dnsupdate", "path");
if (path == NULL) {
path = private_path(tmp_ctx, service->task->lp_ctx, "named.conf.update");
}
- path_static = lp_parm_string(service->task->lp_ctx, NULL, "dnsupdate", "extra_static_grant_rules");
+ path_static = lpcfg_parm_string(service->task->lp_ctx, NULL, "dnsupdate", "extra_static_grant_rules");
if (path_static == NULL) {
path_static = private_path(tmp_ctx, service->task->lp_ctx, "named.conf.update.static");
}
*/
static void dnsupdate_check_names(struct dnsupdate_service *service)
{
- const char * const *dns_update_command = lp_dns_update_command(service->task->lp_ctx);
- const char * const *spn_update_command = lp_spn_update_command(service->task->lp_ctx);
+ const char * const *dns_update_command = lpcfg_dns_update_command(service->task->lp_ctx);
+ const char * const *spn_update_command = lpcfg_spn_update_command(service->task->lp_ctx);
/* kill any existing child */
TALLOC_FREE(service->nameupdate.subreq);
NTSTATUS status;
struct dnsupdate_service *service;
- if (lp_server_role(task->lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
+ if (lpcfg_server_role(task->lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
/* not useful for non-DC */
return;
}
return;
}
- service->confupdate.interval = lp_parm_int(task->lp_ctx, NULL,
+ service->confupdate.interval = lpcfg_parm_int(task->lp_ctx, NULL,
"dnsupdate", "config interval", 60); /* in seconds */
- service->nameupdate.interval = lp_parm_int(task->lp_ctx, NULL,
+ service->nameupdate.interval = lpcfg_parm_int(task->lp_ctx, NULL,
"dnsupdate", "name interval", 600); /* in seconds */
dnsupdate_rebuild(service);
uint32_t tombstoneLifetime;
time_t t = time(NULL);
- if (t - s->last_deleted_check < lp_parm_int(s->task->lp_ctx, NULL, "kccsrv",
+ if (t - s->last_deleted_check < lpcfg_parm_int(s->task->lp_ctx, NULL, "kccsrv",
"check_deleted_interval", 600)) {
return NT_STATUS_OK;
}
r1->other_info = talloc_zero(reps, struct repsFromTo1OtherInfo);
r1->other_info->dns_name = talloc_asprintf(r1->other_info, "%s._msdcs.%s",
GUID_string(mem_ctx, &ntds_guid),
- lp_dnsdomain(s->task->lp_ctx));
+ lpcfg_dnsdomain(s->task->lp_ctx));
r1->source_dsa_obj_guid = ntds_guid;
r1->source_dsa_invocation_id = invocation_id;
r1->replica_flags =
struct kccsrv_service *service;
uint32_t periodic_startup_interval;
- switch (lp_server_role(task->lp_ctx)) {
+ switch (lpcfg_server_role(task->lp_ctx)) {
case ROLE_STANDALONE:
task_server_terminate(task, "kccsrv: no KCC required in standalone configuration", false);
return;
return;
}
- periodic_startup_interval = lp_parm_int(task->lp_ctx, NULL, "kccsrv",
+ periodic_startup_interval = lpcfg_parm_int(task->lp_ctx, NULL, "kccsrv",
"periodic_startup_interval", 15); /* in seconds */
- service->periodic.interval = lp_parm_int(task->lp_ctx, NULL, "kccsrv",
+ service->periodic.interval = lpcfg_parm_int(task->lp_ctx, NULL, "kccsrv",
"periodic_interval", 300); /* in seconds */
status = kccsrv_periodic_schedule(service, periodic_startup_interval);
ntds_dns_name = talloc_asprintf(r, "%s._msdcs.%s",
ntds_guid_str,
- lp_dnsdomain(service->task->lp_ctx));
+ lpcfg_dnsdomain(service->task->lp_ctx));
if (tevent_req_nomem(ntds_dns_name, req)) {
return;
}
sdsa->repsFrom1->other_info->dns_name =
talloc_asprintf(sdsa->repsFrom1->other_info, "%s._msdcs.%s",
GUID_string(sdsa->repsFrom1->other_info, &sdsa->repsFrom1->source_dsa_obj_guid),
- lp_dnsdomain(service->task->lp_ctx));
+ lpcfg_dnsdomain(service->task->lp_ctx));
if (!sdsa->repsFrom1->other_info->dns_name) {
talloc_free(sdsa);
return WERR_NOMEM;
bool am_rodc;
int ret;
- switch (lp_server_role(task->lp_ctx)) {
+ switch (lpcfg_server_role(task->lp_ctx)) {
case ROLE_STANDALONE:
task_server_terminate(task, "dreplsrv: no DSDB replication required in standalone configuration",
false);
return;
}
- periodic_startup_interval = lp_parm_int(task->lp_ctx, NULL, "dreplsrv", "periodic_startup_interval", 15); /* in seconds */
- service->periodic.interval = lp_parm_int(task->lp_ctx, NULL, "dreplsrv", "periodic_interval", 300); /* in seconds */
+ periodic_startup_interval = lpcfg_parm_int(task->lp_ctx, NULL, "dreplsrv", "periodic_startup_interval", 15); /* in seconds */
+ service->periodic.interval = lpcfg_parm_int(task->lp_ctx, NULL, "dreplsrv", "periodic_interval", 300); /* in seconds */
status = dreplsrv_periodic_schedule(service, periodic_startup_interval);
if (!W_ERROR_IS_OK(status)) {
/* if we are a RODC then we do not send DSReplicaSync*/
ret = samdb_rodc(service->samdb, &am_rodc);
if (ret == LDB_SUCCESS && !am_rodc) {
- service->notify.interval = lp_parm_int(task->lp_ctx, NULL, "dreplsrv",
+ service->notify.interval = lpcfg_parm_int(task->lp_ctx, NULL, "dreplsrv",
"notify_interval", 5); /* in seconds */
status = dreplsrv_notify_schedule(service, service->notify.interval);
if (!W_ERROR_IS_OK(status)) {
}
data->password_attrs = NULL;
- data->acl_perform = lp_parm_bool(ldb_get_opaque(ldb, "loadparm"),
+ data->acl_perform = lpcfg_parm_bool(ldb_get_opaque(ldb, "loadparm"),
NULL, "acl", "perform", false);
ldb_module_set_private(module, data);
}
data->password_attrs = NULL;
- data->acl_perform = lp_parm_bool(ldb_get_opaque(ldb, "loadparm"),
+ data->acl_perform = lpcfg_parm_bool(ldb_get_opaque(ldb, "loadparm"),
NULL, "acl", "perform", false);
ldb_module_set_private(module, data);
data->partitions[i]->ctrl->dn) != 0)) {
char *ref = talloc_asprintf(ac,
"ldap://%s/%s%s",
- lp_dnsdomain(lp_ctx),
+ lpcfg_dnsdomain(lp_ctx),
ldb_dn_get_linearized(data->partitions[i]->ctrl->dn),
req->op.search.scope == LDB_SCOPE_ONELEVEL ? "??base" : "");
return ret;
}
- if (lp_lanman_auth(lp_ctx)) {
+ if (lpcfg_lanman_auth(lp_ctx)) {
ret = setup_lm_fields(io);
if (ret != LDB_SUCCESS) {
return ret;
return LDB_ERR_UNWILLING_TO_PERFORM;
}
- if (lp_lanman_auth(lp_ctx) && (lm_hash != NULL)) {
+ if (lpcfg_lanman_auth(lp_ctx) && (lm_hash != NULL)) {
io->n.lm_hash = talloc(io->ac, struct samr_Password);
memcpy(io->n.lm_hash->hash, lm_hash->data, MIN(lm_hash->length,
sizeof(io->n.lm_hash->hash)));
}
- if (lp_lanman_auth(lp_ctx) && (old_lm_hash != NULL)) {
+ if (lpcfg_lanman_auth(lp_ctx) && (old_lm_hash != NULL)) {
io->og.lm_hash = talloc(io->ac, struct samr_Password);
memcpy(io->og.lm_hash->hash, old_lm_hash->data, MIN(old_lm_hash->length,
sizeof(io->og.lm_hash->hash)));
lp_ctx = talloc_get_type(ldb_get_opaque(ldb, "loadparm"),
struct loadparm_context);
- ac->status->domain_data.dns_domain = lp_dnsdomain(lp_ctx);
- ac->status->domain_data.realm = lp_realm(lp_ctx);
- ac->status->domain_data.netbios_domain = lp_sam_name(lp_ctx);
+ ac->status->domain_data.dns_domain = lpcfg_dnsdomain(lp_ctx);
+ ac->status->domain_data.realm = lpcfg_realm(lp_ctx);
+ ac->status->domain_data.netbios_domain = lpcfg_sam_name(lp_ctx);
ac->status->reject_reason = SAM_PWD_CHANGE_NO_ERROR;
referral = talloc_asprintf(req,
"ldap://%s/%s",
- lp_dnsdomain(lp_ctx),
+ lpcfg_dnsdomain(lp_ctx),
ldb_dn_get_linearized(msg->dn));
ret = ldb_module_send_referral(req, referral);
return ldb_module_done(req, NULL, NULL, ret);
(struct loadparm_context *)ldb_get_opaque(ldb, "loadparm");
TALLOC_CTX *tmp_ctx = talloc_new(module);
- msg = messaging_client_init(tmp_ctx, lp_messaging_path(tmp_ctx, lp_ctx),
+ msg = messaging_client_init(tmp_ctx, lpcfg_messaging_path(tmp_ctx, lp_ctx),
ldb_get_event_context(ldb));
if (!msg) {
DEBUG(3,(__location__ ": Failed to create messaging context\n"));
DSDB_FLAG_NEXT_MODULE |
DSDB_SEARCH_SEARCH_ALL_PARTITIONS,
"(&(objectClass=sambaDomain)(sambaDomainName=%s))",
- lp_sam_name(ldb_get_opaque(ldb, "loadparm")));
+ lpcfg_sam_name(ldb_get_opaque(ldb, "loadparm")));
if (ret != LDB_SUCCESS) {
ldb_asprintf_errstring(ldb,
__location__
}
if ( ! ac->sid) {
- sid_generator = lp_sid_generator(lp_ctx);
+ sid_generator = lpcfg_sid_generator(lp_ctx);
if (sid_generator == SID_GENERATOR_INTERNAL) {
ret = samldb_add_step(ac, samldb_allocate_sid);
if (ret != LDB_SUCCESS) return ret;
that we always get the same pointer in ldb_wrap_connect()
*/
struct cli_credentials *samdb_credentials(struct tevent_context *event_ctx,
- struct loadparm_context *lp_ctx)
+ struct loadparm_context *lp_ctx)
{
static struct cli_credentials *static_credentials;
struct cli_credentials *cred;
struct auth_session_info *session_info)
{
struct ldb_context *ldb;
- ldb = ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx,
- lp_sam_url(lp_ctx), session_info,
- samdb_credentials(ev_ctx, lp_ctx),
+ ldb = ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx,
+ lpcfg_sam_url(lp_ctx), session_info,
+ samdb_credentials(ev_ctx, lp_ctx),
0);
if (!ldb) {
return NULL;
struct tevent_context *ev_ctx,
struct loadparm_context *lp_ctx)
{
- return ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx, "privilege.ldb",
+ return ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx, "privilege.ldb",
NULL, NULL, 0);
}
unsigned int i;
krb5_error_code ret = 0;
krb5_boolean is_computer = FALSE;
- char *realm = strupper_talloc(mem_ctx, lp_realm(lp_ctx));
+ char *realm = strupper_talloc(mem_ctx, lpcfg_realm(lp_ctx));
struct samba_kdc_entry *p;
NTTIME acct_expiry;
* their probably patheticly insecure password) */
if (entry_ex->entry.flags.server
- && lp_parm_bool(lp_ctx, NULL, "kdc", "require spn for service", true)) {
+ && lpcfg_parm_bool(lp_ctx, NULL, "kdc", "require spn for service", true)) {
if (!is_computer && !ldb_msg_find_attr_as_string(msg, "servicePrincipalName", NULL)) {
entry_ex->entry.flags.server = 0;
}
&& principal->name.name_string.len == 2
&& (strcmp(principal->name.name_string.val[0], "kadmin") == 0)
&& (strcmp(principal->name.name_string.val[1], "changepw") == 0)
- && lp_is_my_domain_or_realm(lp_ctx, principal->realm)) {
+ && lpcfg_is_my_domain_or_realm(lp_ctx, principal->realm)) {
entry_ex->entry.flags.change_pw = 1;
}
entry_ex->entry.flags.client = 0;
{
struct loadparm_context *lp_ctx = kdc_db_ctx->lp_ctx;
const char *dnsdomain;
- char *realm = strupper_talloc(mem_ctx, lp_realm(lp_ctx));
+ char *realm = strupper_talloc(mem_ctx, lpcfg_realm(lp_ctx));
DATA_BLOB password_utf16;
struct samr_Password password_hash;
const struct ldb_val *password_val;
/* krbtgt case. Either us or a trusted realm */
- if (lp_is_my_domain_or_realm(lp_ctx, principal->realm)
- && lp_is_my_domain_or_realm(lp_ctx, principal->name.name_string.val[1])) {
+ if (lpcfg_is_my_domain_or_realm(lp_ctx, principal->realm)
+ && lpcfg_is_my_domain_or_realm(lp_ctx, principal->name.name_string.val[1])) {
/* us */
/* Cludge, cludge cludge. If the realm part of krbtgt/realm,
* is in our db, then direct the caller at our primary
return HDB_ERR_NOENTRY;
}
- realm_fixed = strupper_talloc(mem_ctx, lp_realm(lp_ctx));
+ realm_fixed = strupper_talloc(mem_ctx, lpcfg_realm(lp_ctx));
if (!realm_fixed) {
ret = ENOMEM;
krb5_set_error_message(context, ret, "strupper_talloc: out of memory");
/* Either an inbound or outbound trust */
- if (strcasecmp(lp_realm(lp_ctx), principal->realm) == 0) {
+ if (strcasecmp(lpcfg_realm(lp_ctx), principal->realm) == 0) {
/* look for inbound trust */
direction = INBOUND;
realm = principal->name.name_string.val[1];
}
- if (strcasecmp(lp_realm(lp_ctx), principal->name.name_string.val[1]) == 0) {
+ if (strcasecmp(lpcfg_realm(lp_ctx), principal->name.name_string.val[1]) == 0) {
/* look for outbound trust */
direction = OUTBOUND;
realm = principal->realm;
model_ops,
&kdc_tcp_stream_ops,
"ip", address, &port,
- lp_socket_options(kdc->task->lp_ctx),
+ lpcfg_socket_options(kdc->task->lp_ctx),
kdc_socket);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to bind to %s:%u TCP - %s\n",
for (i=0; i<num_interfaces; i++) {
const char *address = talloc_strdup(tmp_ctx, iface_n_ip(ifaces, i));
- uint16_t kdc_port = lp_krb5_port(lp_ctx);
- uint16_t kpasswd_port = lp_kpasswd_port(lp_ctx);
+ uint16_t kdc_port = lpcfg_krb5_port(lp_ctx);
+ uint16_t kpasswd_port = lpcfg_kpasswd_port(lp_ctx);
if (kdc_port) {
status = kdc_add_socket(kdc, model_ops,
}
ret = krb5_make_principal(kdc->smb_krb5_context->krb5_context, &principal,
- lp_realm(kdc->task->lp_ctx),
- "krbtgt", lp_realm(kdc->task->lp_ctx),
+ lpcfg_realm(kdc->task->lp_ctx),
+ "krbtgt", lpcfg_realm(kdc->task->lp_ctx),
NULL);
if (ret != 0) {
krb5_error_code ret;
struct interface *ifaces;
- switch (lp_server_role(task->lp_ctx)) {
+ switch (lpcfg_server_role(task->lp_ctx)) {
case ROLE_STANDALONE:
task_server_terminate(task, "kdc: no KDC required in standalone configuration", false);
return;
break;
}
- load_interfaces(task, lp_interfaces(task->lp_ctx), &ifaces);
+ load_interfaces(task, lpcfg_interfaces(task->lp_ctx), &ifaces);
if (iface_count(ifaces) == 0) {
task_server_terminate(task, "kdc: no network interfaces configured", false);
case KRB5_KPASSWD_VERS_CHANGEPW:
{
DATA_BLOB password;
- if (!convert_string_talloc_convenience(mem_ctx, lp_iconv_convenience(kdc->task->lp_ctx),
+ if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(kdc->task->lp_ctx),
CH_UTF8, CH_UTF16,
(const char *)input->data,
input->length,
reply);
}
- if (!convert_string_talloc_convenience(mem_ctx, lp_iconv_convenience(kdc->task->lp_ctx),
+ if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(kdc->task->lp_ctx),
CH_UTF8, CH_UTF16,
(const char *)chpw.newpasswd.data,
chpw.newpasswd.length,
}
/* init s4 configuration */
- s4_conf_file = lp_configfile(ctx->db_ctx->lp_ctx);
+ s4_conf_file = lpcfg_configfile(ctx->db_ctx->lp_ctx);
if (s4_conf_file) {
- lp_load(ctx->db_ctx->lp_ctx, s4_conf_file);
+ lpcfg_load(ctx->db_ctx->lp_ctx, s4_conf_file);
} else {
- lp_load_default(ctx->db_ctx->lp_ctx);
+ lpcfg_load_default(ctx->db_ctx->lp_ctx);
}
ctx->session_info = system_session(ctx->db_ctx->lp_ctx);
}
nt_status = authsam_make_server_info(mem_ctx, p->kdc_db_ctx->samdb,
- lp_netbios_name(p->kdc_db_ctx->lp_ctx),
- lp_sam_name(p->kdc_db_ctx->lp_ctx),
+ lpcfg_netbios_name(p->kdc_db_ctx->lp_ctx),
+ lpcfg_sam_name(p->kdc_db_ctx->lp_ctx),
p->realm_dn,
p->msg,
data_blob(NULL, 0),
conn->ldb = ldb_wrap_connect(conn,
conn->connection->event.ctx,
conn->lp_ctx,
- lp_sam_url(conn->lp_ctx),
+ lpcfg_sam_url(conn->lp_ctx),
conn->session_info,
- samdb_credentials(conn->connection->event.ctx, conn->lp_ctx),
+ samdb_credentials(conn->connection->event.ctx, conn->lp_ctx),
conn->global_catalog ? LDB_FLG_RDONLY : 0);
if (conn->ldb == NULL) {
return NT_STATUS_INTERNAL_DB_CORRUPTION;
= gensec_use_kerberos_mechs(conn, backends, conn->server_credentials);
unsigned int i, j = 0;
for (i = 0; ops && ops[i]; i++) {
- if (!lp_parm_bool(conn->lp_ctx, NULL, "gensec", ops[i]->name, ops[i]->enabled))
+ if (!lpcfg_parm_bool(conn->lp_ctx, NULL, "gensec", ops[i]->name, ops[i]->enabled))
continue;
if (ops[i]->sasl_name && ops[i]->server_start) {
add a socket address to the list of events, one event per port
*/
static NTSTATUS add_socket(struct tevent_context *event_context,
- struct loadparm_context *lp_ctx,
+ struct loadparm_context *lp_ctx,
const struct model_ops *model_ops,
const char *address, struct ldapsrv_service *ldap_service)
{
status = stream_setup_socket(event_context, lp_ctx,
model_ops, &ldap_stream_nonpriv_ops,
"ipv4", address, &port,
- lp_socket_options(lp_ctx),
+ lpcfg_socket_options(lp_ctx),
ldap_service);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("ldapsrv failed to bind to %s:%u - %s\n",
if (tls_support(ldap_service->tls_params)) {
/* add ldaps server */
port = 636;
- status = stream_setup_socket(event_context, lp_ctx,
+ status = stream_setup_socket(event_context, lp_ctx,
model_ops,
&ldap_stream_nonpriv_ops,
"ipv4", address, &port,
- lp_socket_options(lp_ctx),
+ lpcfg_socket_options(lp_ctx),
ldap_service);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("ldapsrv failed to bind to %s:%u - %s\n",
model_ops,
&ldap_stream_nonpriv_ops,
"ipv4", address, &port,
- lp_socket_options(lp_ctx),
+ lpcfg_socket_options(lp_ctx),
ldap_service);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("ldapsrv failed to bind to %s:%u - %s\n",
NTSTATUS status;
const struct model_ops *model_ops;
- switch (lp_server_role(task->lp_ctx)) {
+ switch (lpcfg_server_role(task->lp_ctx)) {
case ROLE_STANDALONE:
task_server_terminate(task, "ldap_server: no LDAP server required in standalone configuration",
false);
ldap_service->tls_params = tls_initialise(ldap_service, task->lp_ctx);
if (ldap_service->tls_params == NULL) goto failed;
- if (lp_interfaces(task->lp_ctx) && lp_bind_interfaces_only(task->lp_ctx)) {
+ if (lpcfg_interfaces(task->lp_ctx) && lpcfg_bind_interfaces_only(task->lp_ctx)) {
struct interface *ifaces;
int num_interfaces;
int i;
- load_interfaces(task, lp_interfaces(task->lp_ctx), &ifaces);
+ load_interfaces(task, lpcfg_interfaces(task->lp_ctx), &ifaces);
num_interfaces = iface_count(ifaces);
/* We have been given an interfaces line, and been
if (!NT_STATUS_IS_OK(status)) goto failed;
}
} else {
- status = add_socket(task->event_ctx, task->lp_ctx, model_ops,
- lp_socket_address(task->lp_ctx), ldap_service);
+ status = add_socket(task->event_ctx, task->lp_ctx, model_ops,
+ lpcfg_socket_address(task->lp_ctx), ldap_service);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
status = stream_setup_socket(task->event_ctx, task->lp_ctx,
model_ops, &ldap_stream_nonpriv_ops,
"unix", ldapi_path, NULL,
- lp_socket_options(task->lp_ctx),
+ lpcfg_socket_options(task->lp_ctx),
ldap_service);
talloc_free(ldapi_path);
if (!NT_STATUS_IS_OK(status)) {
status = stream_setup_socket(task->event_ctx, task->lp_ctx,
model_ops, &ldap_stream_priv_ops,
"unix", ldapi_path, NULL,
- lp_socket_options(task->lp_ctx),
+ lpcfg_socket_options(task->lp_ctx),
ldap_service);
talloc_free(ldapi_path);
if (!NT_STATUS_IS_OK(status)) {
const char *pname;
if (reason == POPT_CALLBACK_REASON_POST) {
- if (lp_configfile(cmdline_lp_ctx) == NULL) {
- lp_load_default(cmdline_lp_ctx);
+ if (lpcfg_configfile(cmdline_lp_ctx) == NULL) {
+ lpcfg_load_default(cmdline_lp_ctx);
}
/* Hook any 'every Samba program must do this, after
* the smb.conf is setup' functions here */
break;
case OPT_OPTION:
- if (!lp_set_option(cmdline_lp_ctx, arg)) {
+ if (!lpcfg_set_option(cmdline_lp_ctx, arg)) {
fprintf(stderr, "Error setting option '%s'\n", arg);
exit(1);
}
break;
case 'd':
- lp_set_cmdline(cmdline_lp_ctx, "log level", arg);
+ lpcfg_set_cmdline(cmdline_lp_ctx, "log level", arg);
break;
case OPT_DEBUG_STDERR:
case 's':
if (arg) {
- lp_load(cmdline_lp_ctx, arg);
+ lpcfg_load(cmdline_lp_ctx, arg);
}
break;
case 'l':
if (arg) {
char *new_logfile = talloc_asprintf(NULL, "%s/log.%s", arg, pname);
- lp_set_cmdline(cmdline_lp_ctx, "log file", new_logfile);
+ lpcfg_set_cmdline(cmdline_lp_ctx, "log file", new_logfile);
talloc_free(new_logfile);
}
break;
switch(opt->val) {
case 'O':
if (arg) {
- lp_set_cmdline(lp_ctx, "socket options", arg);
+ lpcfg_set_cmdline(lp_ctx, "socket options", arg);
}
break;
case 'W':
- lp_set_cmdline(lp_ctx, "workgroup", arg);
+ lpcfg_set_cmdline(lp_ctx, "workgroup", arg);
break;
case 'r':
- lp_set_cmdline(lp_ctx, "realm", arg);
+ lpcfg_set_cmdline(lp_ctx, "realm", arg);
break;
case 'n':
- lp_set_cmdline(lp_ctx, "netbios name", arg);
+ lpcfg_set_cmdline(lp_ctx, "netbios name", arg);
break;
case 'i':
- lp_set_cmdline(lp_ctx, "netbios scope", arg);
+ lpcfg_set_cmdline(lp_ctx, "netbios scope", arg);
break;
case 'm':
- lp_set_cmdline(lp_ctx, "client max protocol", arg);
+ lpcfg_set_cmdline(lp_ctx, "client max protocol", arg);
break;
case 'R':
- lp_set_cmdline(lp_ctx, "name resolve order", arg);
+ lpcfg_set_cmdline(lp_ctx, "name resolve order", arg);
break;
case 'S':
- lp_set_cmdline(lp_ctx, "client signing", arg);
+ lpcfg_set_cmdline(lp_ctx, "client signing", arg);
break;
}
if (server == NULL) {
return dcerpc_pipe_connect(ctx->event_ctx, p, "ncalrpc",
&ndr_table_IRemoteActivation,
- dcom_get_server_credentials(ctx, NULL), ctx->event_ctx, ctx->lp_ctx);
+ dcom_get_server_credentials(ctx, NULL), ctx->event_ctx, ctx->lp_ctx);
}
loc_ctx = talloc_new(ctx);
bd->flags |= DCERPC_DEBUG_PRINT_BOTH;
status = dcerpc_pipe_connect_b(ctx->event_ctx, p, bd,
&ndr_table_IRemoteActivation,
- dcom_get_server_credentials(ctx, bd->host), ctx->event_ctx, ctx->lp_ctx);
+ dcom_get_server_credentials(ctx, bd->host), ctx->event_ctx, ctx->lp_ctx);
goto end;
}
ldb_set_modules_dir(ldb,
talloc_asprintf(ldb,
"%s/ldb",
- lp_modulesdir(lp_ctx)));
+ lpcfg_modulesdir(lp_ctx)));
if (session_info) {
if (ldb_set_opaque(ldb, "sessionInfo", session_info)) {
return NULL;
}
- if (lp_ctx != NULL && strcmp(lp_sam_url(lp_ctx), url) == 0) {
+ if (lp_ctx != NULL && strcmp(lpcfg_sam_url(lp_ctx), url) == 0) {
dsdb_set_global_schema(ldb);
}
}
/* allow admins to force non-sync ldb for all databases */
- if (lp_parm_bool(lp_ctx, NULL, "ldb", "nosync", false)) {
+ if (lpcfg_parm_bool(lp_ctx, NULL, "ldb", "nosync", false)) {
flags |= LDB_FLG_NOSYNC;
}
DLIST_ADD(ldb_wrap_list, w);
/* make the resulting schema global */
- if (lp_ctx != NULL && strcmp(lp_sam_url(lp_ctx), url) == 0) {
+ if (lp_ctx != NULL && strcmp(lpcfg_sam_url(lp_ctx), url) == 0) {
struct dsdb_schema *schema = dsdb_get_schema(ldb, NULL);
if (schema) {
dsdb_make_schema_global(ldb, schema);
ldb = PyLdb_AsLdbContext(self);
- lp_ctx = lp_from_py_object(ldb, py_lp_ctx);
+ lp_ctx = lpcfg_from_py_object(ldb, py_lp_ctx);
if (lp_ctx == NULL) {
PyErr_SetString(PyExc_TypeError, "Expected loadparm object");
return NULL;
ev = s4_event_context_init(ret->mem_ctx);
if (messaging_path == NULL) {
- messaging_path = lp_messaging_path(ret->mem_ctx,
+ messaging_path = lpcfg_messaging_path(ret->mem_ctx,
py_default_loadparm_context(ret->mem_ctx));
} else {
messaging_path = talloc_strdup(ret->mem_ctx, messaging_path);
ev = s4_event_context_init(ret->mem_ctx);
if (messaging_path == NULL) {
- messaging_path = lp_messaging_path(ret->mem_ctx,
+ messaging_path = lpcfg_messaging_path(ret->mem_ctx,
py_default_loadparm_context(ret->mem_ctx));
} else {
messaging_path = talloc_strdup(ret->mem_ctx, messaging_path);
*_data = data = talloc(tctx, struct irpc_test_data);
- lp_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
+ lpcfg_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
data->ev = tctx->ev;
torture_assert(tctx, data->msg_ctx1 =
messaging_init(tctx,
- lp_messaging_path(tctx, tctx->lp_ctx),
+ lpcfg_messaging_path(tctx, tctx->lp_ctx),
cluster_id(0, MSG_ID1),
data->ev),
"Failed to init first messaging context");
torture_assert(tctx, data->msg_ctx2 =
messaging_init(tctx,
- lp_messaging_path(tctx, tctx->lp_ctx),
+ lpcfg_messaging_path(tctx, tctx->lp_ctx),
cluster_id(0, MSG_ID2),
data->ev),
"Failed to init second messaging context");
int timelimit = torture_setting_int(tctx, "timelimit", 10);
uint32_t msg_ping, msg_exit;
- lp_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
+ lpcfg_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
ev = tctx->ev;
msg_server_ctx = messaging_init(tctx,
- lp_messaging_path(tctx, tctx->lp_ctx), cluster_id(0, 1),
+ lpcfg_messaging_path(tctx, tctx->lp_ctx), cluster_id(0, 1),
ev);
torture_assert(tctx, msg_server_ctx != NULL, "Failed to init ping messaging context");
messaging_register_tmp(msg_server_ctx, tctx, exit_message, &msg_exit);
msg_client_ctx = messaging_init(tctx,
- lp_messaging_path(tctx, tctx->lp_ctx),
+ lpcfg_messaging_path(tctx, tctx->lp_ctx),
cluster_id(0, 2),
ev);
gp_ctx->cli = smbcli_state_init(gp_ctx);
- lp_smbcli_options(gp_ctx->lp_ctx, &options);
- lp_smbcli_session_options(gp_ctx->lp_ctx, &session_options);
+ lpcfg_smbcli_options(gp_ctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(gp_ctx->lp_ctx, &session_options);
return smbcli_full_connection(gp_ctx,
&gp_ctx->cli,
gp_ctx->active_dc.name,
- lp_smb_ports(gp_ctx->lp_ctx),
+ lpcfg_smb_ports(gp_ctx->lp_ctx),
"sysvol",
NULL,
- lp_socket_options(gp_ctx->lp_ctx),
+ lpcfg_socket_options(gp_ctx->lp_ctx),
gp_ctx->credentials,
- lp_resolve_context(gp_ctx->lp_ctx),
+ lpcfg_resolve_context(gp_ctx->lp_ctx),
gp_ctx->ev_ctx,
&options,
&session_options,
- lp_gensec_settings(gp_ctx, gp_ctx->lp_ctx));
+ lpcfg_gensec_settings(gp_ctx, gp_ctx->lp_ctx));
return NT_STATUS_OK;
}
io = talloc_zero(mem_ctx, struct libnet_LookupDCs);
NT_STATUS_HAVE_NO_MEMORY(io);
io->in.name_type = NBT_NAME_PDC;
- io->in.domain_name = lp_workgroup(lp_ctx);
+ io->in.domain_name = lpcfg_workgroup(lp_ctx);
/* Find Active DC's */
rv = libnet_LookupDCs(net_ctx, mem_ctx, io);
gpo->display_name = talloc_strdup(gpo, display_name);
NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpo->display_name, mem_ctx);
- gpo->file_sys_path = talloc_asprintf(gpo, "\\\\%s\\sysvol\\%s\\Policies\\%s", lp_dnsdomain(gp_ctx->lp_ctx), lp_dnsdomain(gp_ctx->lp_ctx), name);
+ gpo->file_sys_path = talloc_asprintf(gpo, "\\\\%s\\sysvol\\%s\\Policies\\%s", lpcfg_dnsdomain(gp_ctx->lp_ctx), lpcfg_dnsdomain(gp_ctx->lp_ctx), name);
NT_STATUS_HAVE_NO_MEMORY_AND_FREE(gpo->file_sys_path, mem_ctx);
/* Create the GPT */
&py_credentials))
return NULL;
- lp_ctx = lp_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
+ lp_ctx = lpcfg_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
if (lp_ctx == NULL) {
PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
return NULL;
&py_credentials, &py_lp_ctx))
return NULL;
- lp_ctx = lp_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
+ lp_ctx = lpcfg_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
if (lp_ctx == NULL) {
PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
return NULL;
const char *location;
location = talloc_asprintf(ctx, "%s/%s.ldb",
- lp_private_dir(lp_ctx),
+ lpcfg_private_dir(lp_ctx),
name);
W_ERROR_HAVE_NO_MEMORY(location);
TALLOC_CTX *mem_ctx = tctx;
struct interface *ifaces;
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
status = socket_create("ip", SOCKET_TYPE_DGRAM, &sock1, 0);
torture_assert_ntstatus_ok(tctx, status, "creating DGRAM IP socket 1");
torture_assert_ntstatus_ok(tctx, status, "creating IP stream socket 1");
talloc_steal(mem_ctx, sock2);
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
localhost = socket_address_from_strings(sock1, sock1->backend_name,
iface_best_ip(ifaces, "127.0.0.1"), 0);
torture_assert(tctx, localhost, "Localhost not found");
struct tls_params *params;
int ret;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
- const char *keyfile = lp_tls_keyfile(tmp_ctx, lp_ctx);
- const char *certfile = lp_tls_certfile(tmp_ctx, lp_ctx);
- const char *cafile = lp_tls_cafile(tmp_ctx, lp_ctx);
- const char *crlfile = lp_tls_crlfile(tmp_ctx, lp_ctx);
- const char *dhpfile = lp_tls_dhpfile(tmp_ctx, lp_ctx);
+ const char *keyfile = lpcfg_tls_keyfile(tmp_ctx, lp_ctx);
+ const char *certfile = lpcfg_tls_certfile(tmp_ctx, lp_ctx);
+ const char *cafile = lpcfg_tls_cafile(tmp_ctx, lp_ctx);
+ const char *crlfile = lpcfg_tls_crlfile(tmp_ctx, lp_ctx);
+ const char *dhpfile = lpcfg_tls_dhpfile(tmp_ctx, lp_ctx);
void tls_cert_generate(TALLOC_CTX *, const char *, const char *, const char *, const char *);
params = talloc(mem_ctx, struct tls_params);
if (params == NULL) {
return NULL;
}
- if (!lp_tls_enabled(lp_ctx) || keyfile == NULL || *keyfile == 0) {
+ if (!lpcfg_tls_enabled(lp_ctx) || keyfile == NULL || *keyfile == 0) {
params->tls_enabled = false;
talloc_free(tmp_ctx);
return params;
if (!file_exist(cafile)) {
char *hostname = talloc_asprintf(mem_ctx, "%s.%s",
- lp_netbios_name(lp_ctx),
- lp_dnsdomain(lp_ctx));
+ lpcfg_netbios_name(lp_ctx),
+ lpcfg_dnsdomain(lp_ctx));
if (hostname == NULL) {
goto init_failed;
}
status = gensec_client_start(conn, &conn->gensec,
conn->event.event_ctx,
- lp_gensec_settings(conn, lp_ctx));
+ lpcfg_gensec_settings(conn, lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Failed to start GENSEC engine (%s)\n", nt_errstr(status)));
goto failed;
* local host name as the target for gensec's
* DIGEST-MD5 mechanism */
conn->host = talloc_asprintf(conn, "%s.%s",
- lp_netbios_name(conn->lp_ctx),
- lp_dnsdomain(conn->lp_ctx));
+ lpcfg_netbios_name(conn->lp_ctx),
+ lpcfg_dnsdomain(conn->lp_ctx));
if (composite_nomem(conn->host, state->ctx)) {
return result;
}
}
ctx = socket_connect_multi_send(state, conn->host, 1, &conn->port,
- lp_resolve_context(conn->lp_ctx), conn->event.event_ctx);
+ lpcfg_resolve_context(conn->lp_ctx), conn->event.event_ctx);
if (ctx == NULL) goto failed;
ctx->async.fn = ldap_connect_recv_tcp_conn;
talloc_steal(conn, conn->sock);
if (conn->ldaps) {
struct socket_context *tls_socket;
- char *cafile = lp_tls_cafile(conn->sock, conn->lp_ctx);
+ char *cafile = lpcfg_tls_cafile(conn->sock, conn->lp_ctx);
if (!cafile || !*cafile) {
talloc_free(conn->sock);
bool resolve_context_add_bcast_method_lp(struct resolve_context *ctx, struct loadparm_context *lp_ctx)
{
struct interface *ifaces;
- load_interfaces(ctx, lp_interfaces(lp_ctx), &ifaces);
- return resolve_context_add_bcast_method(ctx, ifaces, lp_nbt_port(lp_ctx), lp_parm_int(lp_ctx, NULL, "nbt", "timeout", 1));
+ load_interfaces(ctx, lpcfg_interfaces(lp_ctx), &ifaces);
+ return resolve_context_add_bcast_method(ctx, ifaces, lpcfg_nbt_port(lp_ctx), lpcfg_parm_int(lp_ctx, NULL, "nbt", "timeout", 1));
}
bool resolve_context_add_file_method_lp(struct resolve_context *ctx, struct loadparm_context *lp_ctx)
{
- return resolve_context_add_file_method(ctx, lp_parm_string(lp_ctx, NULL, "resolv", "host file"));
+ return resolve_context_add_file_method(ctx, lpcfg_parm_string(lp_ctx, NULL, "resolv", "host file"));
}
#include "libcli/resolve/resolve.h"
#include "param/param.h"
-struct resolve_context *lp_resolve_context(struct loadparm_context *lp_ctx)
+struct resolve_context *lpcfg_resolve_context(struct loadparm_context *lp_ctx)
{
- const char **methods = lp_name_resolve_order(lp_ctx);
+ const char **methods = lpcfg_name_resolve_order(lp_ctx);
int i;
struct resolve_context *ret = resolve_context_init(lp_ctx);
bool resolve_context_add_wins_method_lp(struct resolve_context *ctx, struct loadparm_context *lp_ctx)
{
struct interface *ifaces;
- load_interfaces(ctx, lp_interfaces(lp_ctx), &ifaces);
- return resolve_context_add_wins_method(ctx, lp_wins_server_list(lp_ctx), ifaces, lp_nbt_port(lp_ctx), lp_parm_int(lp_ctx, NULL, "nbt", "timeout", 1));
+ load_interfaces(ctx, lpcfg_interfaces(lp_ctx), &ifaces);
+ return resolve_context_add_wins_method(ctx, lpcfg_wins_server_list(lp_ctx), ifaces, lpcfg_nbt_port(lp_ctx), lpcfg_parm_int(lp_ctx, NULL, "nbt", "timeout", 1));
}
int num_dests;
const char **hostnames;
const char **addresses;
- int *ports; /* Either NULL for lp_smb_ports() per
+ int *ports; /* Either NULL for lpcfg_smb_ports() per
* destination or a list of explicit ports */
} in;
struct {
const char *wrepl_best_ip(struct loadparm_context *lp_ctx, const char *peer_ip)
{
struct interface *ifaces;
- load_interfaces(lp_ctx, lp_interfaces(lp_ctx), &ifaces);
+ load_interfaces(lp_ctx, lpcfg_interfaces(lp_ctx), &ifaces);
return iface_best_ip(ifaces, peer_ip);
}
dcerpc_init(lp_ctx);
/* name resolution methods */
- ctx->resolve_ctx = lp_resolve_context(lp_ctx);
+ ctx->resolve_ctx = lpcfg_resolve_context(lp_ctx);
/* connected services' params */
ZERO_STRUCT(ctx->samr);
static int32_t get_dc_function_level(struct loadparm_context *lp_ctx)
{
/* per default we are (Windows) 2008 R2 compatible */
- return lp_parm_int(lp_ctx, NULL, "ads", "dc function level",
+ return lpcfg_parm_int(lp_ctx, NULL, "ads", "dc function level",
DS_DOMAIN_FUNCTION_2008_R2);
}
ret = tsocket_address_inet_from_strings(s, "ip",
s->source_dsa.address,
- lp_cldap_port(s->libnet->lp_ctx),
+ lpcfg_cldap_port(s->libnet->lp_ctx),
&dest_address);
if (ret != 0) {
c->status = map_nt_error_from_unix(errno);
* configuration partition works fine, but it fails for
* the domain partition.
*/
- if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
+ if (lpcfg_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
"force krb5", true))
{
krb5_str = "krb5,";
}
- if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
+ if (lpcfg_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
"print", false))
{
print_str = "print,";
r->in.req.req1.options = DRSUAPI_DRS_ADD_REF | DRSUAPI_DRS_DEL_REF;
/* I think this is how we mark ourselves as a RODC */
- if (!lp_parm_bool(s->libnet->lp_ctx, NULL, "repl", "RODC", false)) {
+ if (!lpcfg_parm_bool(s->libnet->lp_ctx, NULL, "repl", "RODC", false)) {
r->in.req.req1.options |= DRSUAPI_DRS_WRIT_REP;
}
return NT_STATUS_NO_MEMORY;
}
- remote_ldb = ldb_wrap_connect(tmp_ctx, ctx->event_ctx, ctx->lp_ctx,
+ remote_ldb = ldb_wrap_connect(tmp_ctx, ctx->event_ctx, ctx->lp_ctx,
remote_ldb_url,
NULL, ctx->cred, 0);
if (!remote_ldb) {
connect_with_info->out.domain_name = talloc_strdup(tmp_ctx, r->in.domain_name);
} else {
/* Bugger, we just lost our way to automatically find the domain name */
- connect_with_info->out.domain_name = talloc_strdup(tmp_ctx, lp_workgroup(ctx->lp_ctx));
- connect_with_info->out.realm = talloc_strdup(tmp_ctx, lp_realm(ctx->lp_ctx));
+ connect_with_info->out.domain_name = talloc_strdup(tmp_ctx, lpcfg_workgroup(ctx->lp_ctx));
+ connect_with_info->out.realm = talloc_strdup(tmp_ctx, lpcfg_realm(ctx->lp_ctx));
}
}
if (r->in.netbios_name != NULL) {
netbios_name = r->in.netbios_name;
} else {
- netbios_name = talloc_strdup(tmp_mem, lp_netbios_name(ctx->lp_ctx));
+ netbios_name = talloc_strdup(tmp_mem, lpcfg_netbios_name(ctx->lp_ctx));
if (!netbios_name) {
r->out.error_string = NULL;
talloc_free(tmp_mem);
struct composite_context *c;
struct messaging_context *msg_ctx =
messaging_client_init(mem_ctx,
- lp_messaging_path(mem_ctx, ctx->lp_ctx),
+ lpcfg_messaging_path(mem_ctx, ctx->lp_ctx),
ctx->event_ctx);
- c = finddcs_send(mem_ctx, lp_netbios_name(ctx->lp_ctx),
- lp_nbt_port(ctx->lp_ctx), io->in.domain_name,
+ c = finddcs_send(mem_ctx, lpcfg_netbios_name(ctx->lp_ctx),
+ lpcfg_nbt_port(ctx->lp_ctx), io->in.domain_name,
io->in.name_type, NULL, ctx->resolve_ctx,
ctx->event_ctx, msg_ctx);
return c;
if (strcasecmp_m(s->name, secret_name) != 0) {
continue;
}
- if (!convert_string_talloc_convenience(mem_ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF16, CH_UNIX,
+ if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(ctx->lp_ctx), CH_UTF16, CH_UNIX,
s->secret.data, s->secret.length,
(void **)&secret_string, NULL, false)) {
r->out.error_string = talloc_asprintf(mem_ctx,
state->remote_ldb = ldb_wrap_connect(mem_ctx,
state->samsync_state->machine_net_ctx->event_ctx,
- state->samsync_state->machine_net_ctx->lp_ctx,
+ state->samsync_state->machine_net_ctx->lp_ctx,
ldap_url,
NULL, state->samsync_state->machine_net_ctx->cred,
0);
state->sam_ldb = samdb_connect(mem_ctx,
ctx->event_ctx,
- ctx->lp_ctx,
+ ctx->lp_ctx,
r->in.session_info);
if (!state->sam_ldb) {
return NT_STATUS_INTERNAL_DB_ERROR;
}
make_nbt_name_client(&name, libnet_r->out.samr_binding->host);
- status = resolve_name(lp_resolve_context(ctx->lp_ctx), &name, r, &dest_addr, ctx->event_ctx);
+ status = resolve_name(lpcfg_resolve_context(ctx->lp_ctx), &name, r, &dest_addr, ctx->event_ctx);
if (!NT_STATUS_IS_OK(status)) {
libnet_r->out.error_string = NULL;
talloc_free(tmp_ctx);
r->in.dest_address = dest_addr;
r->in.netbios_name = libnet_r->in.netbios_name;
r->in.domain_dn_str = libnet_r->out.domain_dn_str;
- r->in.cldap_port = lp_cldap_port(ctx->lp_ctx);
+ r->in.cldap_port = lpcfg_cldap_port(ctx->lp_ctx);
status = libnet_FindSite(tmp_ctx, ctx, r);
if (!NT_STATUS_IS_OK(status)) {
ret = tsocket_address_inet_from_strings(s, "ip",
s->source_dsa.address,
- lp_cldap_port(s->libnet->lp_ctx),
+ lpcfg_cldap_port(s->libnet->lp_ctx),
&dest_address);
if (ret != 0) {
c->status = map_nt_error_from_unix(errno);
return werror_to_ntstatus(status);
}
- if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
+ if (lpcfg_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
for (i=0; i < schema_objs->num_objects; i++) {
struct ldb_ldif ldif;
fprintf(stdout, "#\n");
return werror_to_ntstatus(status);
}
- if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
+ if (lpcfg_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
for (i=0; i < objs->num_objects; i++) {
struct ldb_ldif ldif;
fprintf(stdout, "#\n");
return NT_STATUS_FOOBAR;
}
- if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
+ if (lpcfg_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
DEBUG(0,("# %s\n", sa->lDAPDisplayName));
NDR_PRINT_DEBUG(drsuapi_DsReplicaLinkedAttribute, &linked_attributes[i]);
dump_data(0,
if (r->in.netbios_name != NULL) {
netbios_name = r->in.netbios_name;
} else {
- netbios_name = talloc_reference(join, lp_netbios_name(ctx->lp_ctx));
+ netbios_name = talloc_reference(join, lpcfg_netbios_name(ctx->lp_ctx));
if (!netbios_name) {
talloc_free(join);
r->out.error_string = NULL;
/* Now set these values into the smb.conf - we probably had
* empty or useless defaults here from whatever smb.conf we
* started with */
- lp_set_cmdline(s->lp_ctx, "realm", join->out.realm);
- lp_set_cmdline(s->lp_ctx, "workgroup", join->out.domain_name);
+ lpcfg_set_cmdline(s->lp_ctx, "realm", join->out.realm);
+ lpcfg_set_cmdline(s->lp_ctx, "workgroup", join->out.domain_name);
b.in.domain_dns_name = join->out.realm;
b.in.domain_netbios_name = join->out.domain_name;
b.in.callbacks.config_chunk = libnet_vampire_cb_store_chunk;
b.in.callbacks.domain_chunk = libnet_vampire_cb_store_chunk;
- b.in.rodc_join = lp_parm_bool(s->lp_ctx, NULL, "repl", "RODC", false);
+ b.in.rodc_join = lpcfg_parm_bool(s->lp_ctx, NULL, "repl", "RODC", false);
status = libnet_BecomeDC(ctx, s, &b);
if (!NT_STATUS_IS_OK(status)) {
return NULL;
}
- r.in.netbios_name = lp_netbios_name(self->libnet_ctx->lp_ctx);
+ r.in.netbios_name = lpcfg_netbios_name(self->libnet_ctx->lp_ctx);
r.out.error_string = NULL;
mem_ctx = talloc_new(NULL);
ret->ev = s4_event_context_init(NULL);
ret->mem_ctx = talloc_new(ret->ev);
- lp = lp_from_py_object(ret->mem_ctx, py_lp);
+ lp = lpcfg_from_py_object(ret->mem_ctx, py_lp);
if (lp == NULL) {
Py_DECREF(ret);
return NULL;
/* prepare smb connection parameters: we're connecting to IPC$ share on
remote rpc server */
conn->in.dest_host = s->io.binding->host;
- conn->in.dest_ports = lp_smb_ports(lp_ctx);
+ conn->in.dest_ports = lpcfg_smb_ports(lp_ctx);
if (s->io.binding->target_hostname == NULL)
conn->in.called_name = "*SMBSERVER"; /* FIXME: This is invalid */
else
conn->in.called_name = s->io.binding->target_hostname;
- conn->in.socket_options = lp_socket_options(lp_ctx);
+ conn->in.socket_options = lpcfg_socket_options(lp_ctx);
conn->in.service = "IPC$";
conn->in.service_type = NULL;
- conn->in.workgroup = lp_workgroup(lp_ctx);
- conn->in.gensec_settings = lp_gensec_settings(conn, lp_ctx);
+ conn->in.workgroup = lpcfg_workgroup(lp_ctx);
+ conn->in.gensec_settings = lpcfg_gensec_settings(conn, lp_ctx);
- lp_smbcli_options(lp_ctx, &conn->in.options);
- lp_smbcli_session_options(lp_ctx, &conn->in.session_options);
+ lpcfg_smbcli_options(lp_ctx, &conn->in.options);
+ lpcfg_smbcli_session_options(lp_ctx, &conn->in.session_options);
/*
* provide proper credentials - user supplied, but allow a
cli_credentials_guess(s->io.creds, lp_ctx);
}
- lp_smbcli_options(lp_ctx, &options);
+ lpcfg_smbcli_options(lp_ctx, &options);
/* send smb2 connect request */
conn_req = smb2_connect_send(mem_ctx, s->io.binding->host,
- lp_parm_string_list(mem_ctx, lp_ctx, NULL, "smb2", "ports", NULL),
+ lpcfg_parm_string_list(mem_ctx, lp_ctx, NULL, "smb2", "ports", NULL),
"IPC$",
s->io.resolve_ctx,
s->io.creds,
c->event_ctx,
&options,
- lp_socket_options(lp_ctx),
- lp_gensec_settings(mem_ctx, lp_ctx)
+ lpcfg_socket_options(lp_ctx),
+ lpcfg_gensec_settings(mem_ctx, lp_ctx)
);
composite_continue(c, conn_req, continue_smb2_connect, c);
return c;
s->io = *io;
/* send pipe open request */
- pipe_req = dcerpc_pipe_open_pipe_send(s->io.pipe->conn, lp_ncalrpc_dir(lp_ctx),
+ pipe_req = dcerpc_pipe_open_pipe_send(s->io.pipe->conn, lpcfg_ncalrpc_dir(lp_ctx),
s->io.binding->endpoint);
composite_continue(c, pipe_req, continue_pipe_open_ncalrpc, c);
return c;
pc.binding = s->binding;
pc.interface = s->table;
pc.creds = s->credentials;
- pc.resolve_ctx = lp_resolve_context(s->lp_ctx);
+ pc.resolve_ctx = lpcfg_resolve_context(s->lp_ctx);
/* connect dcerpc pipe depending on required transport */
switch (s->binding->transport) {
if (composite_nomem(s->pipe, c)) return c;
if (DEBUGLEVEL >= 10)
- s->pipe->conn->packet_log_dir = lp_lockdir(lp_ctx);
+ s->pipe->conn->packet_log_dir = lpcfg_lockdir(lp_ctx);
/* store parameters in state structure */
s->binding = binding;
/* send bind auth request with received creds */
auth_req = dcerpc_bind_auth_send(c, s->pipe, s->table, s->credentials,
- lp_gensec_settings(c, s->lp_ctx),
+ lpcfg_gensec_settings(c, s->lp_ctx),
DCERPC_AUTH_TYPE_SCHANNEL, s->auth_level,
NULL);
if (composite_nomem(auth_req, c)) return;
/* initiate a authenticated bind */
auth_req = dcerpc_bind_auth_send(c, s->pipe, s->table,
s->credentials,
- lp_gensec_settings(c, s->lp_ctx),
+ lpcfg_gensec_settings(c, s->lp_ctx),
DCERPC_AUTH_TYPE_NTLMSSP,
dcerpc_auth_level(s->pipe->conn),
s->table->authservices->names[0]);
/* initiate a authenticated bind */
auth_req = dcerpc_bind_auth_send(c, s->pipe, s->table,
s->credentials,
- lp_gensec_settings(c, s->lp_ctx),
+ lpcfg_gensec_settings(c, s->lp_ctx),
DCERPC_AUTH_TYPE_SPNEGO,
dcerpc_auth_level(s->pipe->conn),
s->table->authservices->names[0]);
/* try SPNEGO with fallback to NTLMSSP */
auth_req = dcerpc_bind_auth_send(c, s->pipe, s->table,
s->credentials,
- lp_gensec_settings(c, s->lp_ctx),
+ lpcfg_gensec_settings(c, s->lp_ctx),
DCERPC_AUTH_TYPE_SPNEGO,
dcerpc_auth_level(conn),
s->table->authservices->names[0]);
auth_req = dcerpc_bind_auth_send(c, s->pipe, s->table,
s->credentials,
- lp_gensec_settings(c, s->lp_ctx),
+ lpcfg_gensec_settings(c, s->lp_ctx),
auth_type,
dcerpc_auth_level(conn),
s->table->authservices->names[0]);
return NULL;
}
- lp_ctx = lp_from_py_object(mem_ctx, py_lp_ctx);
+ lp_ctx = lpcfg_from_py_object(mem_ctx, py_lp_ctx);
if (lp_ctx == NULL) {
PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
talloc_free(mem_ctx);
return NULL;
}
- lp_ctx = lp_from_py_object(mem_ctx, py_lp_ctx);
+ lp_ctx = lpcfg_from_py_object(mem_ctx, py_lp_ctx);
if (lp_ctx == NULL) {
PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
talloc_free(mem_ctx);
samctx = iface->nbtsrv->sam_ctx;
- if (lp_server_role(iface->nbtsrv->task->lp_ctx) != ROLE_DOMAIN_CONTROLLER
+ if (lpcfg_server_role(iface->nbtsrv->task->lp_ctx) != ROLE_DOMAIN_CONTROLLER
|| !samdb_is_pdc(samctx)) {
DEBUG(2, ("Not a PDC, so not processing LOGON_PRIMARY_QUERY\n"));
return;
}
- if (strcasecmp_m(name->name, lp_workgroup(iface->nbtsrv->task->lp_ctx)) != 0) {
+ if (strcasecmp_m(name->name, lpcfg_workgroup(iface->nbtsrv->task->lp_ctx)) != 0) {
DEBUG(5,("GetDC requested for a domian %s that we don't host\n", name->name));
return;
}
pdc = &netlogon_response.data.get_pdc;
pdc->command = NETLOGON_RESPONSE_FROM_PDC;
- pdc->pdc_name = lp_netbios_name(iface->nbtsrv->task->lp_ctx);
+ pdc->pdc_name = lpcfg_netbios_name(iface->nbtsrv->task->lp_ctx);
pdc->unicode_pdc_name = pdc->pdc_name;
- pdc->domain_name = lp_workgroup(iface->nbtsrv->task->lp_ctx);
+ pdc->domain_name = lpcfg_workgroup(iface->nbtsrv->task->lp_ctx);
pdc->nt_version = 1;
pdc->lmnt_token = 0xFFFF;
pdc->lm20_token = 0xFFFF;
dgram_mailslot_netlogon_reply(reply_iface->dgmsock,
packet,
- lp_netbios_name(iface->nbtsrv->task->lp_ctx),
+ lpcfg_netbios_name(iface->nbtsrv->task->lp_ctx),
netlogon->req.pdc.mailslot_name,
&netlogon_response);
}
dgram_mailslot_netlogon_reply(reply_iface->dgmsock,
packet,
- lp_netbios_name(iface->nbtsrv->task->lp_ctx),
+ lpcfg_netbios_name(iface->nbtsrv->task->lp_ctx),
netlogon->req.logon.mailslot_name,
&netlogon_response);
}
logon = &reply.req.reply;
logon->server = talloc_asprintf(packet, "\\\\%s",
- lp_netbios_name(iface->nbtsrv->task->lp_ctx));
+ lpcfg_netbios_name(iface->nbtsrv->task->lp_ctx));
logon->user_name = ntlogon->req.logon.user_name;
- logon->domain = lp_workgroup(iface->nbtsrv->task->lp_ctx);
+ logon->domain = lpcfg_workgroup(iface->nbtsrv->task->lp_ctx);
logon->nt_version = 1;
logon->lmnt_token = 0xFFFF;
logon->lm20_token = 0xFFFF;
dgram_mailslot_ntlogon_reply(reply_iface->dgmsock,
packet,
- lp_netbios_name(iface->nbtsrv->task->lp_ctx),
+ lpcfg_netbios_name(iface->nbtsrv->task->lp_ctx),
ntlogon->req.logon.mailslot_name,
&reply);
}
bcast_addr = socket_address_from_strings(tmp_ctx, bcast_dgmsock->sock->backend_name,
iface->bcast_address,
- lp_dgram_port(iface->nbtsrv->task->lp_ctx));
+ lpcfg_dgram_port(iface->nbtsrv->task->lp_ctx));
if (!bcast_addr) {
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
if (!NT_STATUS_IS_OK(status)) {
talloc_free(tmp_ctx);
DEBUG(0,("Failed to bind to %s:%d - %s\n",
- iface->bcast_address, lp_dgram_port(iface->nbtsrv->task->lp_ctx),
+ iface->bcast_address, lpcfg_dgram_port(iface->nbtsrv->task->lp_ctx),
nt_errstr(status)));
return status;
}
}
bind_addr = socket_address_from_strings(tmp_ctx, iface->dgmsock->sock->backend_name,
- bind_address, lp_dgram_port(iface->nbtsrv->task->lp_ctx));
+ bind_address, lpcfg_dgram_port(iface->nbtsrv->task->lp_ctx));
if (!bind_addr) {
talloc_free(tmp_ctx);
return NT_STATUS_NO_MEMORY;
if (!NT_STATUS_IS_OK(status)) {
talloc_free(tmp_ctx);
DEBUG(0,("Failed to bind to %s:%d - %s\n",
- bind_address, lp_dgram_port(iface->nbtsrv->task->lp_ctx), nt_errstr(status)));
+ bind_address, lpcfg_dgram_port(iface->nbtsrv->task->lp_ctx), nt_errstr(status)));
return status;
}
}
bcast_address = socket_address_from_strings(bcast_nbtsock, bcast_nbtsock->sock->backend_name,
- bcast, lp_nbt_port(lp_ctx));
+ bcast, lpcfg_nbt_port(lp_ctx));
if (!bcast_address) {
talloc_free(iface);
return NT_STATUS_NO_MEMORY;
status = socket_listen(bcast_nbtsock->sock, bcast_address, 0, 0);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to bind to %s:%d - %s\n",
- bcast, lp_nbt_port(lp_ctx), nt_errstr(status)));
+ bcast, lpcfg_nbt_port(lp_ctx), nt_errstr(status)));
talloc_free(iface);
return status;
}
unicast_address = socket_address_from_strings(iface->nbtsock,
iface->nbtsock->sock->backend_name,
- bind_address, lp_nbt_port(lp_ctx));
+ bind_address, lpcfg_nbt_port(lp_ctx));
status = socket_listen(iface->nbtsock->sock, unicast_address, 0, 0);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to bind to %s:%d - %s\n",
- bind_address, lp_nbt_port(lp_ctx), nt_errstr(status)));
+ bind_address, lpcfg_nbt_port(lp_ctx), nt_errstr(status)));
talloc_free(iface);
return status;
}
/* if we are allowing incoming packets from any address, then
we also need to bind to the wildcard address */
- if (!lp_bind_interfaces_only(lp_ctx)) {
+ if (!lpcfg_bind_interfaces_only(lp_ctx)) {
const char *primary_address;
/* the primary address is the address we will return
primary_address = iface_n_ip(ifaces, 0);
} else {
primary_address = inet_ntoa(interpret_addr2(
- lp_netbios_name(lp_ctx)));
+ lpcfg_netbios_name(lp_ctx)));
}
primary_address = talloc_strdup(tmp_ctx, primary_address);
NT_STATUS_HAVE_NO_MEMORY(primary_address);
bcast = talloc_strdup(tmp_ctx, bcast);
netmask = talloc_strdup(tmp_ctx, iface_n_netmask(ifaces, i));
- status = nbtd_add_socket(nbtsrv, lp_ctx,
+ status = nbtd_add_socket(nbtsrv, lp_ctx,
address, address, bcast, netmask);
NT_STATUS_NOT_OK_RETURN(status);
}
- if (lp_wins_server_list(lp_ctx)) {
+ if (lpcfg_wins_server_list(lp_ctx)) {
status = nbtd_add_wins_socket(nbtsrv);
NT_STATUS_NOT_OK_RETURN(status);
}
NTSTATUS status;
struct interface *ifaces;
- load_interfaces(task, lp_interfaces(task->lp_ctx), &ifaces);
+ load_interfaces(task, lpcfg_interfaces(task->lp_ctx), &ifaces);
if (iface_count(ifaces) == 0) {
task_server_terminate(task, "nbtd: no network interfaces configured", false);
struct nbtd_server *nbtsrv = iface->nbtsrv;
/* if its not from the nbt port, then it wasn't a broadcast from us */
- if (src->port != lp_nbt_port(iface->nbtsrv->task->lp_ctx)) {
+ if (src->port != lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx)) {
return false;
}
if (!(packet->operation & NBT_FLAG_BROADCAST) &&
(packet->operation & NBT_FLAG_RECURSION_DESIRED) &&
(iname->nb_flags & NBT_NM_GROUP) &&
- lp_wins_support(iface->nbtsrv->task->lp_ctx)) {
+ lpcfg_wins_support(iface->nbtsrv->task->lp_ctx)) {
nbtd_winsserver_request(nbtsock, packet, src);
return;
}
registration packets */
io.in.name = iname->name;
io.in.dest_addr = iface->bcast_address;
- io.in.dest_port = lp_nbt_port(iface->nbtsrv->task->lp_ctx);
+ io.in.dest_port = lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx);
io.in.address = iface->ip_address;
io.in.nb_flags = iname->nb_flags;
io.in.ttl = iname->ttl;
static void nbtd_start_refresh_timer(struct nbtd_iface_name *iname)
{
uint32_t refresh_time;
- uint32_t max_refresh_time = lp_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "max_refresh_time", 7200);
+ uint32_t max_refresh_time = lpcfg_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "max_refresh_time", 7200);
refresh_time = MIN(max_refresh_time, iname->ttl/2);
uint16_t nb_flags)
{
struct nbtd_iface_name *iname;
- const char *scope = lp_netbios_scope(iface->nbtsrv->task->lp_ctx);
+ const char *scope = lpcfg_netbios_scope(iface->nbtsrv->task->lp_ctx);
struct nbt_name_register_bcast io;
struct composite_context *creq;
struct nbtd_server *nbtsrv = iface->nbtsrv;
iname->name.scope = NULL;
}
iname->nb_flags = nb_flags;
- iname->ttl = lp_parm_int(iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "bcast_ttl", 300000);
+ iname->ttl = lpcfg_parm_int(iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "bcast_ttl", 300000);
iname->registration_time = timeval_zero();
iname->wins_server = NULL;
/* setup a broadcast name registration request */
io.in.name = iname->name;
io.in.dest_addr = iface->bcast_address;
- io.in.dest_port = lp_nbt_port(iface->nbtsrv->task->lp_ctx);
+ io.in.dest_port = lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx);
io.in.address = iface->ip_address;
io.in.nb_flags = nb_flags;
io.in.ttl = iname->ttl;
/* note that we don't initially mark the names "ACTIVE". They are
marked active once registration is successful */
- nbtd_register_name(nbtsrv, lp_netbios_name(nbtsrv->task->lp_ctx), NBT_NAME_CLIENT, nb_flags);
- nbtd_register_name(nbtsrv, lp_netbios_name(nbtsrv->task->lp_ctx), NBT_NAME_USER, nb_flags);
- nbtd_register_name(nbtsrv, lp_netbios_name(nbtsrv->task->lp_ctx), NBT_NAME_SERVER, nb_flags);
+ nbtd_register_name(nbtsrv, lpcfg_netbios_name(nbtsrv->task->lp_ctx), NBT_NAME_CLIENT, nb_flags);
+ nbtd_register_name(nbtsrv, lpcfg_netbios_name(nbtsrv->task->lp_ctx), NBT_NAME_USER, nb_flags);
+ nbtd_register_name(nbtsrv, lpcfg_netbios_name(nbtsrv->task->lp_ctx), NBT_NAME_SERVER, nb_flags);
- aliases = lp_netbios_aliases(nbtsrv->task->lp_ctx);
+ aliases = lpcfg_netbios_aliases(nbtsrv->task->lp_ctx);
while (aliases && aliases[0]) {
nbtd_register_name(nbtsrv, aliases[0], NBT_NAME_CLIENT, nb_flags);
nbtd_register_name(nbtsrv, aliases[0], NBT_NAME_SERVER, nb_flags);
aliases++;
}
- if (lp_server_role(nbtsrv->task->lp_ctx) == ROLE_DOMAIN_CONTROLLER) {
+ if (lpcfg_server_role(nbtsrv->task->lp_ctx) == ROLE_DOMAIN_CONTROLLER) {
bool is_pdc = samdb_is_pdc(nbtsrv->sam_ctx);
if (is_pdc) {
- nbtd_register_name(nbtsrv, lp_workgroup(nbtsrv->task->lp_ctx),
+ nbtd_register_name(nbtsrv, lpcfg_workgroup(nbtsrv->task->lp_ctx),
NBT_NAME_PDC, nb_flags);
}
- nbtd_register_name(nbtsrv, lp_workgroup(nbtsrv->task->lp_ctx),
+ nbtd_register_name(nbtsrv, lpcfg_workgroup(nbtsrv->task->lp_ctx),
NBT_NAME_LOGON, nb_flags | NBT_NM_GROUP);
}
nb_flags |= NBT_NM_GROUP;
- nbtd_register_name(nbtsrv, lp_workgroup(nbtsrv->task->lp_ctx), NBT_NAME_CLIENT, nb_flags);
+ nbtd_register_name(nbtsrv, lpcfg_workgroup(nbtsrv->task->lp_ctx), NBT_NAME_CLIENT, nb_flags);
nb_flags |= NBT_NM_PERMANENT;
nbtd_register_name(nbtsrv, "__SAMBA__", NBT_NAME_CLIENT, nb_flags);
ldb_module_set_private(module, NULL);
- owner = lp_parm_string(lp_ctx, NULL, "winsdb", "local_owner");
+ owner = lpcfg_parm_string(lp_ctx, NULL, "winsdb", "local_owner");
if (!owner) {
struct interface *ifaces;
- load_interfaces(module, lp_interfaces(lp_ctx), &ifaces);
+ load_interfaces(module, lpcfg_interfaces(lp_ctx), &ifaces);
owner = iface_n_ip(ifaces, 0);
if (!owner) {
owner = "0.0.0.0";
static void nbtd_wins_start_refresh_timer(struct nbtd_iface_name *iname)
{
uint32_t refresh_time;
- uint32_t max_refresh_time = lp_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "max_refresh_time", 7200);
+ uint32_t max_refresh_time = lpcfg_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "max_refresh_time", 7200);
refresh_time = MIN(max_refresh_time, iname->ttl/2);
/* setup a wins name refresh request */
io.in.name = iname->name;
io.in.wins_servers = (const char **)str_list_make_single(tmp_ctx, iname->wins_server);
- io.in.wins_port = lp_nbt_port(iface->nbtsrv->task->lp_ctx);
+ io.in.wins_port = lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx);
io.in.addresses = nbtd_address_list(iface, tmp_ctx);
io.in.nb_flags = iname->nb_flags;
io.in.ttl = iname->ttl;
if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
/* none of the WINS servers responded - try again
periodically */
- int wins_retry_time = lp_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "wins_retry", 300);
+ int wins_retry_time = lpcfg_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "wins_retry", 300);
event_add_timed(iname->iface->nbtsrv->task->event_ctx,
iname,
timeval_current_ofs(wins_retry_time, 0),
/* setup a wins name register request */
io.in.name = iname->name;
- io.in.wins_port = lp_nbt_port(iname->iface->nbtsrv->task->lp_ctx);
- io.in.wins_servers = lp_wins_server_list(iname->iface->nbtsrv->task->lp_ctx);
+ io.in.wins_port = lpcfg_nbt_port(iname->iface->nbtsrv->task->lp_ctx);
+ io.in.wins_servers = lpcfg_wins_server_list(iname->iface->nbtsrv->task->lp_ctx);
io.in.addresses = nbtd_address_list(iface, iname);
io.in.nb_flags = iname->nb_flags;
io.in.ttl = iname->ttl;
talloc_free(h->ldb);
h->ldb = NULL;
- if (lp_parm_bool(lp_ctx, NULL,"winsdb", "nosync", false)) {
+ if (lpcfg_parm_bool(lp_ctx, NULL,"winsdb", "nosync", false)) {
flags |= LDB_FLG_NOSYNC;
}
- h->ldb = ldb_wrap_connect(h, ev_ctx, lp_ctx, lock_path(h, lp_ctx, lp_wins_url(lp_ctx)),
+ h->ldb = ldb_wrap_connect(h, ev_ctx, lp_ctx, lock_path(h, lp_ctx, lpcfg_wins_url(lp_ctx)),
NULL, NULL, flags);
if (!h->ldb) goto failed;
h = talloc_zero(mem_ctx, struct winsdb_handle);
if (!h) return NULL;
- if (lp_parm_bool(lp_ctx, NULL,"winsdb", "nosync", false)) {
+ if (lpcfg_parm_bool(lp_ctx, NULL,"winsdb", "nosync", false)) {
flags |= LDB_FLG_NOSYNC;
}
- h->ldb = ldb_wrap_connect(h, ev_ctx, lp_ctx, lock_path(h, lp_ctx, lp_wins_url(lp_ctx)),
+ h->ldb = ldb_wrap_connect(h, ev_ctx, lp_ctx, lock_path(h, lp_ctx, lpcfg_wins_url(lp_ctx)),
NULL, NULL, flags);
if (!h->ldb) goto failed;
h->caller = caller;
- h->hook_script = lp_wins_hook(lp_ctx);
+ h->hook_script = lpcfg_wins_hook(lp_ctx);
h->local_owner = talloc_strdup(h, owner);
if (!h->local_owner) goto failed;
if (talloc_reference(s, src) == NULL) goto failed;
s->io.in.nbtd_server = iface->nbtsrv;
- s->io.in.nbt_port = lp_nbt_port(iface->nbtsrv->task->lp_ctx);
+ s->io.in.nbt_port = lpcfg_nbt_port(iface->nbtsrv->task->lp_ctx);
s->io.in.event_ctx = iface->nbtsrv->task->event_ctx;
s->io.in.name = rec->name;
s->io.in.num_addresses = winsdb_addr_list_length(rec->addresses);
/* first sort the addresses depending on the matching to the client */
LDB_TYPESAFE_QSORT(addresses, num_addrs, src, nbtd_wins_randomize1Clist_sort);
- mask = lp_parm_string(lp_ctx, NULL, "nbtd", "wins_randomize1Clist_mask");
+ mask = lpcfg_parm_string(lp_ctx, NULL, "nbtd", "wins_randomize1Clist_mask");
if (!mask) {
mask = "255.255.255.0";
}
* Value: 0 = deactivated, 1 = activated
*/
if (name->type == NBT_NAME_LOGON &&
- lp_parm_bool(lp_ctx, NULL, "nbtd", "wins_prepend1Bto1Cqueries", true)) {
+ lpcfg_parm_bool(lp_ctx, NULL, "nbtd", "wins_prepend1Bto1Cqueries", true)) {
struct nbt_name name_1b;
name_1b = *name;
status = winsdb_lookup(winssrv->wins_db, name, packet, &rec);
if (!NT_STATUS_IS_OK(status)) {
- if (!lp_wins_dns_proxy(lp_ctx)) {
+ if (!lpcfg_wins_dns_proxy(lp_ctx)) {
goto notfound;
}
* Value: 0 = deactivated, 1 = activated
*/
if (name->type == NBT_NAME_LOGON &&
- lp_parm_bool(lp_ctx, NULL, "nbtd", "wins_randomize1Clist", false)) {
+ lpcfg_parm_bool(lp_ctx, NULL, "nbtd", "wins_randomize1Clist", false)) {
nbtd_wins_randomize1Clist(lp_ctx, addresses, src);
}
if (strcmp(rec->wins_owner, winssrv->wins_db->local_owner) != 0) {
modify_flags = WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP;
}
- if (lp_parm_bool(iface->nbtsrv->task->lp_ctx, NULL, "wreplsrv", "propagate name releases", false)) {
+ if (lpcfg_parm_bool(iface->nbtsrv->task->lp_ctx, NULL, "wreplsrv", "propagate name releases", false)) {
/*
* We have an option to propagate every name release,
* this is off by default to match windows servers
uint32_t tmp;
const char *owner;
- if (!lp_wins_support(nbtsrv->task->lp_ctx)) {
+ if (!lpcfg_wins_support(nbtsrv->task->lp_ctx)) {
nbtsrv->winssrv = NULL;
return NT_STATUS_OK;
}
nbtsrv->winssrv = talloc_zero(nbtsrv, struct wins_server);
NT_STATUS_HAVE_NO_MEMORY(nbtsrv->winssrv);
- nbtsrv->winssrv->config.max_renew_interval = lp_max_wins_ttl(nbtsrv->task->lp_ctx);
- nbtsrv->winssrv->config.min_renew_interval = lp_min_wins_ttl(nbtsrv->task->lp_ctx);
- tmp = lp_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv", "tombstone_interval", 6*24*60*60);
+ nbtsrv->winssrv->config.max_renew_interval = lpcfg_max_wins_ttl(nbtsrv->task->lp_ctx);
+ nbtsrv->winssrv->config.min_renew_interval = lpcfg_min_wins_ttl(nbtsrv->task->lp_ctx);
+ tmp = lpcfg_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv", "tombstone_interval", 6*24*60*60);
nbtsrv->winssrv->config.tombstone_interval = tmp;
- tmp = lp_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv"," tombstone_timeout", 1*24*60*60);
+ tmp = lpcfg_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv"," tombstone_timeout", 1*24*60*60);
nbtsrv->winssrv->config.tombstone_timeout = tmp;
- owner = lp_parm_string(nbtsrv->task->lp_ctx, NULL, "winsdb", "local_owner");
+ owner = lpcfg_parm_string(nbtsrv->task->lp_ctx, NULL, "winsdb", "local_owner");
if (owner == NULL) {
struct interface *ifaces;
- load_interfaces(nbtsrv->task, lp_interfaces(nbtsrv->task->lp_ctx), &ifaces);
+ load_interfaces(nbtsrv->task, lpcfg_interfaces(nbtsrv->task->lp_ctx), &ifaces);
owner = iface_n_ip(ifaces, 0);
}
if (state->current_address < state->io->in.num_addresses) {
struct nbtd_interface *iface;
- state->release.in.dest_port = lp_nbt_port(state->io->in.nbtd_server->task->lp_ctx);
+ state->release.in.dest_port = lpcfg_nbt_port(state->io->in.nbtd_server->task->lp_ctx);
state->release.in.dest_addr = state->io->in.addresses[state->current_address];
state->release.in.address = state->release.in.dest_addr;
state->release.in.timeout = (state->addresses_left > 1 ? 2 : 1);
* with 2 retries
*/
state->release.in.name = *state->io->in.name;
- state->release.in.dest_port = lp_nbt_port(state->io->in.nbtd_server->task->lp_ctx);
+ state->release.in.dest_port = lpcfg_nbt_port(state->io->in.nbtd_server->task->lp_ctx);
state->release.in.dest_addr = state->io->in.addresses[state->current_address];
state->release.in.address = state->release.in.dest_addr;
state->release.in.broadcast = false;
s->req = req;
s->io.in.nbtd_server = nbtd_server;
- s->io.in.nbt_port = lp_nbt_port(nbtd_server->task->lp_ctx);
+ s->io.in.nbt_port = lpcfg_nbt_port(nbtd_server->task->lp_ctx);
s->io.in.event_ctx = msg->ev;
s->io.in.name = &req->in.name;
s->io.in.num_addresses = req->in.num_addrs;
const char *address;
- if (!directory_create_or_exist(lp_ntp_signd_socket_directory(task->lp_ctx), geteuid(), 0755)) {
+ if (!directory_create_or_exist(lpcfg_ntp_signd_socket_directory(task->lp_ctx), geteuid(), 0755)) {
char *error = talloc_asprintf(task, "Cannot create NTP signd pipe directory: %s",
- lp_ntp_signd_socket_directory(task->lp_ctx));
+ lpcfg_ntp_signd_socket_directory(task->lp_ctx));
task_server_terminate(task,
error, true);
return;
return;
}
- address = talloc_asprintf(ntp_signd, "%s/socket", lp_ntp_signd_socket_directory(task->lp_ctx));
+ address = talloc_asprintf(ntp_signd, "%s/socket", lpcfg_ntp_signd_socket_directory(task->lp_ctx));
status = stream_setup_socket(ntp_signd->task->event_ctx,
ntp_signd->task->lp_ctx,
model_ops,
&ntp_signd_stream_ops,
"unix", address, NULL,
- lp_socket_options(ntp_signd->task->lp_ctx),
+ lpcfg_socket_options(ntp_signd->task->lp_ctx),
ntp_signd);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to bind to %s - %s\n",
*/
static struct ldb_context *sptr_db_connect(TALLOC_CTX *mem_ctx, struct tevent_context *ev_ctx, struct loadparm_context *lp_ctx)
{
- return ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx, lp_spoolss_url(lp_ctx), system_session(lp_ctx),
+ return ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx, lpcfg_spoolss_url(lp_ctx), system_session(lp_ctx),
NULL, 0);
}
union spoolss_PrinterData *r,
enum winreg_Type *type)
{
- struct dcerpc_server_info *server_info = lp_dcerpc_server_info(mem_ctx, server->ntptr->lp_ctx);
+ struct dcerpc_server_info *server_info = lpcfg_dcerpc_server_info(mem_ctx, server->ntptr->lp_ctx);
if (strcmp("W3SvcInstalled", value_name) == 0) {
*type = REG_DWORD;
r->value = 0;
r->binary = blob;
return WERR_OK;
} else if (strcmp("DNSMachineName", value_name) == 0) {
- const char *dnsdomain = lp_dnsdomain(server->ntptr->lp_ctx);
+ const char *dnsdomain = lpcfg_dnsdomain(server->ntptr->lp_ctx);
if (dnsdomain == NULL) return WERR_INVALID_PARAM;
*type = REG_SZ;
r->string = talloc_asprintf(mem_ctx, "%s.%s",
- lp_netbios_name(server->ntptr->lp_ctx),
+ lpcfg_netbios_name(server->ntptr->lp_ctx),
dnsdomain);
W_ERROR_HAVE_NO_MEMORY(r->string);
return WERR_OK;
/* connect to the server, using the smbd event context */
io.in.dest_host = host;
- io.in.dest_ports = lp_smb_ports(ntvfs->ctx->lp_ctx);
- io.in.socket_options = lp_socket_options(ntvfs->ctx->lp_ctx);
+ io.in.dest_ports = lpcfg_smb_ports(ntvfs->ctx->lp_ctx);
+ io.in.socket_options = lpcfg_socket_options(ntvfs->ctx->lp_ctx);
io.in.called_name = host;
io.in.credentials = credentials;
io.in.fallback_to_anonymous = false;
- io.in.workgroup = lp_workgroup(ntvfs->ctx->lp_ctx);
+ io.in.workgroup = lpcfg_workgroup(ntvfs->ctx->lp_ctx);
io.in.service = remote_share;
io.in.service_type = "?????";
- io.in.gensec_settings = lp_gensec_settings(p, ntvfs->ctx->lp_ctx);
- lp_smbcli_options(ntvfs->ctx->lp_ctx, &io.in.options);
- lp_smbcli_session_options(ntvfs->ctx->lp_ctx, &io.in.session_options);
+ io.in.gensec_settings = lpcfg_gensec_settings(p, ntvfs->ctx->lp_ctx);
+ lpcfg_smbcli_options(ntvfs->ctx->lp_ctx, &io.in.options);
+ lpcfg_smbcli_session_options(ntvfs->ctx->lp_ctx, &io.in.session_options);
if (!(ntvfs->ctx->client_caps & NTVFS_CLIENT_CAP_LEVEL_II_OPLOCKS)) {
io.in.options.use_level2_oplocks = false;
}
creq = smb_composite_connect_send(&io, p,
- lp_resolve_context(ntvfs->ctx->lp_ctx),
+ lpcfg_resolve_context(ntvfs->ctx->lp_ctx),
ntvfs->ctx->event_ctx);
status = smb_composite_connect_recv(creq, p);
NT_STATUS_NOT_OK_RETURN(status);
fs->generic.out.serial_number = 1;
fs->generic.out.fs_type = talloc_strdup(req, "NTFS");
fs->generic.out.volume_name = talloc_strdup(req,
- lp_servicename(req->tcon->service));
+ lpcfg_servicename(req->tcon->service));
return NT_STATUS_OK;
}
r->out.available = 0;
r->out.info = NULL;
- nterr = share_get_context_by_name(mem_ctx, lp_share_backend(lp_ctx), event_ctx, lp_ctx, &sctx);
+ nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(lp_ctx), event_ctx, lp_ctx, &sctx);
if (!NT_STATUS_IS_OK(nterr)) {
return nterr;
}
}
directory = talloc_asprintf(req, "%s/np",
- lp_ncalrpc_dir(ipriv->ntvfs->ctx->lp_ctx));
+ lpcfg_ncalrpc_dir(ipriv->ntvfs->ctx->lp_ctx));
NT_STATUS_HAVE_NO_MEMORY(directory);
state = talloc(req, struct ipc_open_state);
}
/* by default have a max of 512 entries in the cache. */
- ctx->cache_size = lp_parm_int(pvfs->ntvfs->ctx->lp_ctx, NULL, "mangle", "cachesize", 512);
+ ctx->cache_size = lpcfg_parm_int(pvfs->ntvfs->ctx->lp_ctx, NULL, "mangle", "cachesize", 512);
ctx->prefix_cache = talloc_array(ctx, char *, ctx->cache_size);
if (ctx->prefix_cache == NULL) {
memset(ctx->prefix_cache, 0, sizeof(char *) * ctx->cache_size);
memset(ctx->prefix_cache_hashes, 0, sizeof(uint32_t) * ctx->cache_size);
- ctx->mangle_prefix = lp_parm_int(pvfs->ntvfs->ctx->lp_ctx, NULL, "mangle", "prefix", -1);
+ ctx->mangle_prefix = lpcfg_parm_int(pvfs->ntvfs->ctx->lp_ctx, NULL, "mangle", "prefix", -1);
if (ctx->mangle_prefix < 0 || ctx->mangle_prefix > 6) {
ctx->mangle_prefix = DEFAULT_MANGLE_PREFIX;
}
pvfs->notify_context = notify_init(pvfs,
pvfs->ntvfs->ctx->server_id,
pvfs->ntvfs->ctx->msg_ctx,
- pvfs->ntvfs->ctx->lp_ctx,
+ pvfs->ntvfs->ctx->lp_ctx,
pvfs->ntvfs->ctx->event_ctx,
pvfs->ntvfs->ctx->config);
p = (char *)io->ioctl.out.blob.data;
SSVAL(p,0, 1 /* REWRITE: fsp->rap_print_jobid */);
- push_string(p+2, lp_netbios_name(ntvfs->ctx->lp_ctx), 15, STR_TERMINATE|STR_ASCII);
+ push_string(p+2, lpcfg_netbios_name(ntvfs->ctx->lp_ctx), 15, STR_TERMINATE|STR_ASCII);
push_string(p+18, ntvfs->ctx->config->name, 13, STR_TERMINATE|STR_ASCII);
return NT_STATUS_OK;
}
fs->generic.out.serial_number = 1;
fs->generic.out.fs_type = talloc_strdup(req, "NTFS");
fs->generic.out.volume_name = talloc_strdup(req,
- lp_servicename(req->tcon->service));
+ lpcfg_servicename(req->tcon->service));
return NT_STATUS_OK;
}
return NT_STATUS_INVALID_PARAMETER;
}
- lp_smbcli_options(ntvfs->ctx->lp_ctx, &options);
+ lpcfg_smbcli_options(ntvfs->ctx->lp_ctx, &options);
creq = smb2_connect_send(p, host,
- lp_parm_string_list(p, ntvfs->ctx->lp_ctx, NULL, "smb2", "ports", NULL),
+ lpcfg_parm_string_list(p, ntvfs->ctx->lp_ctx, NULL, "smb2", "ports", NULL),
remote_share,
- lp_resolve_context(ntvfs->ctx->lp_ctx),
+ lpcfg_resolve_context(ntvfs->ctx->lp_ctx),
credentials,
ntvfs->ctx->event_ctx, &options,
- lp_socket_options(ntvfs->ctx->lp_ctx),
- lp_gensec_settings(p, ntvfs->ctx->lp_ctx)
+ lpcfg_socket_options(ntvfs->ctx->lp_ctx),
+ lpcfg_gensec_settings(p, ntvfs->ctx->lp_ctx)
);
status = smb2_connect_recv(creq, p, &tree);
bool isglobal = strcmp(section->name, "global") == 0;
for (param = section->parameters->entries; param; param = param->next) {
if (isglobal)
- lp_do_global_parameter(lp_ctx, param->key,
+ lpcfg_do_global_parameter(lp_ctx, param->key,
param->value);
else {
struct loadparm_service *service =
- lp_service(lp_ctx, section->name);
+ lpcfg_service(lp_ctx, section->name);
if (service == NULL)
- service = lp_add_service(lp_ctx, lp_default_service(lp_ctx), section->name);
- lp_do_service_parameter(lp_ctx, service, param->key, param->value);
+ service = lpcfg_add_service(lp_ctx, lpcfg_default_service(lp_ctx), section->name);
+ lpcfg_do_service_parameter(lp_ctx, service, param->key, param->value);
}
}
}
};
-struct loadparm_service *lp_default_service(struct loadparm_context *lp_ctx)
+struct loadparm_service *lpcfg_default_service(struct loadparm_context *lp_ctx)
{
return lp_ctx->sDefault;
}
/*
return the parameter table
*/
-struct parm_struct *lp_parm_table(void)
+struct parm_struct *lpcfg_parm_table(void)
{
return parm_table;
}
parameters from the rest of the program are defined
*/
+/*
+ * the creation of separate lpcfg_*() and lp_*() functions is to allow
+ * for code compatibility between existing Samba4 and Samba3 code.
+ */
+
+/* this global context supports the lp_*() function varients */
+static struct loadparm_context *global_loadparm_context;
+
+#define lpcfg_default_service global_loadparm_context->sDefault
+#define lpcfg_global_service(i) global_loadparm_context->services[i]
+
#define FN_GLOBAL_STRING(fn_name,var_name) \
- 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) : "";}
+ _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) : "";} \
+ _PUBLIC_ const char *lp_ ## fn_name(void) { return lpcfg_ ## fn_name(global_loadparm_context); }
+
#define FN_GLOBAL_CONST_STRING(fn_name,var_name) \
- 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 : "";}
+ _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 : "";} \
+ _PUBLIC_ const char *lp_ ## fn_name(void) { return lpcfg_ ## fn_name(global_loadparm_context); }
+
#define FN_GLOBAL_LIST(fn_name,var_name) \
- const char **fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name;}
+ _PUBLIC_ const char **lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name;} \
+ _PUBLIC_ const char **lp_ ## fn_name(void) { return lpcfg_ ## fn_name(global_loadparm_context); }
+
#define FN_GLOBAL_BOOL(fn_name,var_name) \
- bool fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return false; return lp_ctx->globals->var_name;}
-#if 0 /* unused */
-#define FN_GLOBAL_CHAR(fn_name,ptr) \
- char fn_name(void) {return(*(char *)(ptr));}
-#endif
+ _PUBLIC_ bool lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return false; return lp_ctx->globals->var_name;} \
+ _PUBLIC_ bool lp_ ## fn_name(void) { return lpcfg_ ## fn_name(global_loadparm_context); }
+
#define FN_GLOBAL_INTEGER(fn_name,var_name) \
- int fn_name(struct loadparm_context *lp_ctx) {return lp_ctx->globals->var_name;}
+ _PUBLIC_ int lpcfg_ ## fn_name(struct loadparm_context *lp_ctx) {return lp_ctx->globals->var_name;} \
+ _PUBLIC_ int lp_ ## fn_name(void) { return lpcfg_ ## fn_name(global_loadparm_context); }
#define FN_LOCAL_STRING(fn_name,val) \
- 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)));}
+ _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)));} \
+ _PUBLIC_ const char *lp_ ## fn_name(int i) { return lpcfg_ ## fn_name(lpcfg_global_service(i), lpcfg_default_service); }
+
#define FN_LOCAL_LIST(fn_name,val) \
- const char **fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return(const char **)(service != NULL && service->val != NULL? service->val : sDefault->val);}
+ _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);} \
+ _PUBLIC_ const char **lp_ ## fn_name(int i) { return lpcfg_ ## fn_name(lpcfg_global_service(i), lpcfg_default_service); }
+
#define FN_LOCAL_BOOL(fn_name,val) \
- bool fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
-#define FN_LOCAL_INTEGER(fn_name,val) \
- int fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
-
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_server_role, server_role)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_sid_generator, sid_generator)
-_PUBLIC_ FN_GLOBAL_LIST(lp_smb_ports, smb_ports)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_nbt_port, nbt_port)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_dgram_port, dgram_port)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_cldap_port, cldap_port)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_krb5_port, krb5_port)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_kpasswd_port, kpasswd_port)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_web_port, web_port)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_tls_enabled, tls_enabled)
-_PUBLIC_ FN_GLOBAL_STRING(lp_share_backend, szShareBackend)
-_PUBLIC_ FN_GLOBAL_STRING(lp_sam_url, szSAM_URL)
-_PUBLIC_ FN_GLOBAL_STRING(lp_idmap_url, szIDMAP_URL)
-_PUBLIC_ FN_GLOBAL_STRING(lp_secrets_url, szSECRETS_URL)
-_PUBLIC_ FN_GLOBAL_STRING(lp_spoolss_url, szSPOOLSS_URL)
-_PUBLIC_ FN_GLOBAL_STRING(lp_wins_config_url, szWINS_CONFIG_URL)
-_PUBLIC_ FN_GLOBAL_STRING(lp_wins_url, szWINS_URL)
-_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbind_separator, szWinbindSeparator)
-_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbindd_socket_directory, szWinbinddSocketDirectory)
-_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbindd_privileged_socket_directory, szWinbinddPrivilegedSocketDirectory)
-_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_shell, szTemplateShell)
-_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_homedir, szTemplateHomedir)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_winbind_sealed_pipes, bWinbindSealedPipes)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_idmap_trusted_only, bIdmapTrustedOnly)
-_PUBLIC_ FN_GLOBAL_STRING(lp_private_dir, szPrivateDir)
-_PUBLIC_ FN_GLOBAL_STRING(lp_serverstring, szServerString)
-_PUBLIC_ FN_GLOBAL_STRING(lp_lockdir, szLockDir)
-_PUBLIC_ FN_GLOBAL_STRING(lp_modulesdir, szModulesDir)
-_PUBLIC_ FN_GLOBAL_STRING(lp_setupdir, szSetupDir)
-_PUBLIC_ FN_GLOBAL_STRING(lp_ncalrpc_dir, ncalrpc_dir)
-_PUBLIC_ FN_GLOBAL_STRING(lp_dos_charset, dos_charset)
-_PUBLIC_ FN_GLOBAL_STRING(lp_unix_charset, unix_charset)
-_PUBLIC_ FN_GLOBAL_STRING(lp_display_charset, display_charset)
-_PUBLIC_ FN_GLOBAL_STRING(lp_piddir, szPidDir)
-_PUBLIC_ FN_GLOBAL_LIST(lp_rndc_command, szRNDCCommand)
-_PUBLIC_ FN_GLOBAL_LIST(lp_dns_update_command, szDNSUpdateCommand)
-_PUBLIC_ FN_GLOBAL_LIST(lp_spn_update_command, szSPNUpdateCommand)
-_PUBLIC_ FN_GLOBAL_STRING(lp_nsupdate_command, szNSUpdateCommand)
-_PUBLIC_ FN_GLOBAL_LIST(lp_dcerpc_endpoint_servers, dcerpc_ep_servers)
-_PUBLIC_ FN_GLOBAL_LIST(lp_server_services, server_services)
-_PUBLIC_ FN_GLOBAL_STRING(lp_ntptr_providor, ntptr_providor)
-_PUBLIC_ FN_GLOBAL_STRING(lp_auto_services, szAutoServices)
-_PUBLIC_ FN_GLOBAL_STRING(lp_passwd_chat, szPasswdChat)
-_PUBLIC_ FN_GLOBAL_LIST(lp_passwordserver, szPasswordServers)
-_PUBLIC_ FN_GLOBAL_LIST(lp_name_resolve_order, szNameResolveOrder)
-_PUBLIC_ FN_GLOBAL_STRING(lp_realm, szRealm_upper)
-_PUBLIC_ FN_GLOBAL_STRING(lp_dnsdomain, szRealm_lower)
-_PUBLIC_ FN_GLOBAL_STRING(lp_socket_options, socket_options)
-_PUBLIC_ FN_GLOBAL_STRING(lp_workgroup, szWorkgroup)
-_PUBLIC_ FN_GLOBAL_STRING(lp_netbios_name, szNetbiosName)
-_PUBLIC_ FN_GLOBAL_STRING(lp_netbios_scope, szNetbiosScope)
-_PUBLIC_ FN_GLOBAL_LIST(lp_wins_server_list, szWINSservers)
-_PUBLIC_ FN_GLOBAL_LIST(lp_interfaces, szInterfaces)
-_PUBLIC_ FN_GLOBAL_STRING(lp_socket_address, szSocketAddress)
-_PUBLIC_ FN_GLOBAL_LIST(lp_netbios_aliases, szNetbiosAliases)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_disable_netbios, bDisableNetbios)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_wins_support, bWINSsupport)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_wins_dns_proxy, bWINSdnsProxy)
-_PUBLIC_ FN_GLOBAL_STRING(lp_wins_hook, szWINSHook)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_local_master, bLocalMaster)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_readraw, bReadRaw)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_large_readwrite, bLargeReadwrite)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_writeraw, bWriteRaw)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_null_passwords, bNullPasswords)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_obey_pam_restrictions, bObeyPamRestrictions)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_encrypted_passwords, bEncryptPasswords)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_time_server, bTimeServer)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_bind_interfaces_only, bBindInterfacesOnly)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_unicode, bUnicode)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_nt_status_support, bNTStatusSupport)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_lanman_auth, bLanmanAuth)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_ntlm_auth, bNTLMAuth)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_client_plaintext_auth, bClientPlaintextAuth)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_client_lanman_auth, bClientLanManAuth)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, bClientNTLMv2Auth)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_client_use_spnego_principal, client_use_spnego_principal)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_host_msdfs, bHostMSDfs)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_unix_extensions, bUnixExtensions)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_use_spnego, bUseSpnego)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_rpc_big_endian, bRpcBigEndian)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_max_wins_ttl, max_wins_ttl)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_min_wins_ttl, min_wins_ttl)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_maxmux, max_mux)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_max_xmit, max_xmit)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_passwordlevel, pwordlevel)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_maxprotocol, srv_maxprotocol)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_minprotocol, srv_minprotocol)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_maxprotocol, cli_maxprotocol)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_minprotocol, cli_minprotocol)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_security, security)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_paranoid_server_security, paranoid_server_security)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_announce_as, announce_as)
-
-const char *lp_servicename(const struct loadparm_service *service)
-{
- return lp_string((const char *)service->szService);
-}
+ _PUBLIC_ bool lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);} \
+ _PUBLIC_ bool lp_ ## fn_name(int i) { return lpcfg_ ## fn_name(lpcfg_global_service(i), lpcfg_default_service); }
-_PUBLIC_ FN_LOCAL_STRING(lp_pathname, szPath)
-static FN_LOCAL_STRING(_lp_printername, szPrintername)
-_PUBLIC_ FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
-_PUBLIC_ FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
-_PUBLIC_ FN_LOCAL_STRING(lp_comment, comment)
-_PUBLIC_ FN_LOCAL_STRING(lp_fstype, fstype)
-static FN_LOCAL_STRING(lp_volume, volume)
-_PUBLIC_ FN_LOCAL_LIST(lp_ntvfs_handler, ntvfs_handler)
-_PUBLIC_ FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
-_PUBLIC_ FN_LOCAL_BOOL(lp_browseable, bBrowseable)
-_PUBLIC_ FN_LOCAL_BOOL(lp_readonly, bRead_only)
-_PUBLIC_ FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
-_PUBLIC_ FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
-_PUBLIC_ FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
-_PUBLIC_ FN_LOCAL_BOOL(lp_strict_locking, bStrictLocking)
-_PUBLIC_ FN_LOCAL_BOOL(lp_oplocks, bOplocks)
-_PUBLIC_ FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
-_PUBLIC_ FN_LOCAL_BOOL(lp_ci_filesystem, bCIFileSystem)
-_PUBLIC_ FN_LOCAL_BOOL(lp_map_system, bMap_system)
-_PUBLIC_ FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
-_PUBLIC_ FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
-_PUBLIC_ FN_LOCAL_INTEGER(lp_create_mask, iCreate_mask)
-_PUBLIC_ FN_LOCAL_INTEGER(lp_force_create_mode, iCreate_force_mode)
-_PUBLIC_ FN_LOCAL_INTEGER(lp_dir_mask, iDir_mask)
-_PUBLIC_ FN_LOCAL_INTEGER(lp_force_dir_mode, iDir_force_mode)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_server_signing, server_signing)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_client_signing, client_signing)
-
-_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_ntp_signd_socket_directory, szNTPSignDSocketDirectory)
+#define FN_LOCAL_INTEGER(fn_name,val) \
+ _PUBLIC_ int lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);} \
+ _PUBLIC_ int lp_ ## fn_name(int i) { return lpcfg_ ## fn_name(lpcfg_global_service(i), lpcfg_default_service); }
+
+FN_GLOBAL_INTEGER(server_role, server_role)
+FN_GLOBAL_INTEGER(sid_generator, sid_generator)
+FN_GLOBAL_LIST(smb_ports, smb_ports)
+FN_GLOBAL_INTEGER(nbt_port, nbt_port)
+FN_GLOBAL_INTEGER(dgram_port, dgram_port)
+FN_GLOBAL_INTEGER(cldap_port, cldap_port)
+FN_GLOBAL_INTEGER(krb5_port, krb5_port)
+FN_GLOBAL_INTEGER(kpasswd_port, kpasswd_port)
+FN_GLOBAL_INTEGER(web_port, web_port)
+FN_GLOBAL_BOOL(tls_enabled, tls_enabled)
+FN_GLOBAL_STRING(share_backend, szShareBackend)
+FN_GLOBAL_STRING(sam_url, szSAM_URL)
+FN_GLOBAL_STRING(idmap_url, szIDMAP_URL)
+FN_GLOBAL_STRING(secrets_url, szSECRETS_URL)
+FN_GLOBAL_STRING(spoolss_url, szSPOOLSS_URL)
+FN_GLOBAL_STRING(wins_config_url, szWINS_CONFIG_URL)
+FN_GLOBAL_STRING(wins_url, szWINS_URL)
+FN_GLOBAL_CONST_STRING(winbind_separator, szWinbindSeparator)
+FN_GLOBAL_CONST_STRING(winbindd_socket_directory, szWinbinddSocketDirectory)
+FN_GLOBAL_CONST_STRING(winbindd_privileged_socket_directory, szWinbinddPrivilegedSocketDirectory)
+FN_GLOBAL_CONST_STRING(template_shell, szTemplateShell)
+FN_GLOBAL_CONST_STRING(template_homedir, szTemplateHomedir)
+FN_GLOBAL_BOOL(winbind_sealed_pipes, bWinbindSealedPipes)
+FN_GLOBAL_BOOL(idmap_trusted_only, bIdmapTrustedOnly)
+FN_GLOBAL_STRING(private_dir, szPrivateDir)
+FN_GLOBAL_STRING(serverstring, szServerString)
+FN_GLOBAL_STRING(lockdir, szLockDir)
+FN_GLOBAL_STRING(modulesdir, szModulesDir)
+FN_GLOBAL_STRING(setupdir, szSetupDir)
+FN_GLOBAL_STRING(ncalrpc_dir, ncalrpc_dir)
+FN_GLOBAL_STRING(dos_charset, dos_charset)
+FN_GLOBAL_STRING(unix_charset, unix_charset)
+FN_GLOBAL_STRING(display_charset, display_charset)
+FN_GLOBAL_STRING(piddir, szPidDir)
+FN_GLOBAL_LIST(rndc_command, szRNDCCommand)
+FN_GLOBAL_LIST(dns_update_command, szDNSUpdateCommand)
+FN_GLOBAL_LIST(spn_update_command, szSPNUpdateCommand)
+FN_GLOBAL_STRING(nsupdate_command, szNSUpdateCommand)
+FN_GLOBAL_LIST(dcerpc_endpoint_servers, dcerpc_ep_servers)
+FN_GLOBAL_LIST(server_services, server_services)
+FN_GLOBAL_STRING(ntptr_providor, ntptr_providor)
+FN_GLOBAL_STRING(auto_services, szAutoServices)
+FN_GLOBAL_STRING(passwd_chat, szPasswdChat)
+FN_GLOBAL_LIST(passwordserver, szPasswordServers)
+FN_GLOBAL_LIST(name_resolve_order, szNameResolveOrder)
+FN_GLOBAL_STRING(realm, szRealm_upper)
+FN_GLOBAL_STRING(dnsdomain, szRealm_lower)
+FN_GLOBAL_STRING(socket_options, socket_options)
+FN_GLOBAL_STRING(workgroup, szWorkgroup)
+FN_GLOBAL_STRING(netbios_name, szNetbiosName)
+FN_GLOBAL_STRING(netbios_scope, szNetbiosScope)
+FN_GLOBAL_LIST(wins_server_list, szWINSservers)
+FN_GLOBAL_LIST(interfaces, szInterfaces)
+FN_GLOBAL_STRING(socket_address, szSocketAddress)
+FN_GLOBAL_LIST(netbios_aliases, szNetbiosAliases)
+FN_GLOBAL_BOOL(disable_netbios, bDisableNetbios)
+FN_GLOBAL_BOOL(wins_support, bWINSsupport)
+FN_GLOBAL_BOOL(wins_dns_proxy, bWINSdnsProxy)
+FN_GLOBAL_STRING(wins_hook, szWINSHook)
+FN_GLOBAL_BOOL(local_master, bLocalMaster)
+FN_GLOBAL_BOOL(readraw, bReadRaw)
+FN_GLOBAL_BOOL(large_readwrite, bLargeReadwrite)
+FN_GLOBAL_BOOL(writeraw, bWriteRaw)
+FN_GLOBAL_BOOL(null_passwords, bNullPasswords)
+FN_GLOBAL_BOOL(obey_pam_restrictions, bObeyPamRestrictions)
+FN_GLOBAL_BOOL(encrypted_passwords, bEncryptPasswords)
+FN_GLOBAL_BOOL(time_server, bTimeServer)
+FN_GLOBAL_BOOL(bind_interfaces_only, bBindInterfacesOnly)
+FN_GLOBAL_BOOL(unicode, bUnicode)
+FN_GLOBAL_BOOL(nt_status_support, bNTStatusSupport)
+FN_GLOBAL_BOOL(lanman_auth, bLanmanAuth)
+FN_GLOBAL_BOOL(ntlm_auth, bNTLMAuth)
+FN_GLOBAL_BOOL(client_plaintext_auth, bClientPlaintextAuth)
+FN_GLOBAL_BOOL(client_lanman_auth, bClientLanManAuth)
+FN_GLOBAL_BOOL(client_ntlmv2_auth, bClientNTLMv2Auth)
+FN_GLOBAL_BOOL(client_use_spnego_principal, client_use_spnego_principal)
+FN_GLOBAL_BOOL(host_msdfs, bHostMSDfs)
+FN_GLOBAL_BOOL(unix_extensions, bUnixExtensions)
+FN_GLOBAL_BOOL(use_spnego, bUseSpnego)
+FN_GLOBAL_BOOL(rpc_big_endian, bRpcBigEndian)
+FN_GLOBAL_INTEGER(max_wins_ttl, max_wins_ttl)
+FN_GLOBAL_INTEGER(min_wins_ttl, min_wins_ttl)
+FN_GLOBAL_INTEGER(maxmux, max_mux)
+FN_GLOBAL_INTEGER(max_xmit, max_xmit)
+FN_GLOBAL_INTEGER(passwordlevel, pwordlevel)
+FN_GLOBAL_INTEGER(srv_maxprotocol, srv_maxprotocol)
+FN_GLOBAL_INTEGER(srv_minprotocol, srv_minprotocol)
+FN_GLOBAL_INTEGER(cli_maxprotocol, cli_maxprotocol)
+FN_GLOBAL_INTEGER(cli_minprotocol, cli_minprotocol)
+FN_GLOBAL_INTEGER(security, security)
+FN_GLOBAL_BOOL(paranoid_server_security, paranoid_server_security)
+FN_GLOBAL_INTEGER(announce_as, announce_as)
+
+FN_LOCAL_STRING(pathname, szPath)
+FN_LOCAL_LIST(hostsallow, szHostsallow)
+FN_LOCAL_LIST(hostsdeny, szHostsdeny)
+FN_LOCAL_STRING(comment, comment)
+FN_LOCAL_STRING(fstype, fstype)
+FN_LOCAL_LIST(ntvfs_handler, ntvfs_handler)
+FN_LOCAL_BOOL(msdfs_root, bMSDfsRoot)
+FN_LOCAL_BOOL(browseable, bBrowseable)
+FN_LOCAL_BOOL(readonly, bRead_only)
+FN_LOCAL_BOOL(print_ok, bPrint_ok)
+FN_LOCAL_BOOL(map_hidden, bMap_hidden)
+FN_LOCAL_BOOL(map_archive, bMap_archive)
+FN_LOCAL_BOOL(strict_locking, bStrictLocking)
+FN_LOCAL_BOOL(oplocks, bOplocks)
+FN_LOCAL_BOOL(strict_sync, bStrictSync)
+FN_LOCAL_BOOL(ci_filesystem, bCIFileSystem)
+FN_LOCAL_BOOL(map_system, bMap_system)
+FN_LOCAL_INTEGER(max_connections, iMaxConnections)
+FN_LOCAL_INTEGER(csc_policy, iCSCPolicy)
+FN_LOCAL_INTEGER(create_mask, iCreate_mask)
+FN_LOCAL_INTEGER(force_create_mode, iCreate_force_mode)
+FN_LOCAL_INTEGER(dir_mask, iDir_mask)
+FN_LOCAL_INTEGER(force_dir_mode, iDir_force_mode)
+FN_GLOBAL_INTEGER(server_signing, server_signing)
+FN_GLOBAL_INTEGER(client_signing, client_signing)
+
+FN_GLOBAL_CONST_STRING(ntp_signd_socket_directory, szNTPSignDSocketDirectory)
/* local prototypes */
static int map_parameter(const char *pszParmName);
-static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx,
+static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx,
const char *pszServiceName);
static void copy_service(struct loadparm_service *pserviceDest,
struct loadparm_service *pserviceSource,
/* This is a helper function for parametrical options support. */
/* It returns a pointer to parametrical option value if it exists or NULL otherwise */
/* Actual parametrical functions are quite simple */
-const char *lp_get_parametric(struct loadparm_context *lp_ctx,
+const char *lpcfg_get_parametric(struct loadparm_context *lp_ctx,
struct loadparm_service *service,
const char *type, const char *option)
{
* Returned value is allocated in 'lp_talloc' context
*/
-const char *lp_parm_string(struct loadparm_context *lp_ctx,
- struct loadparm_service *service, const char *type,
- const char *option)
+const char *lpcfg_parm_string(struct loadparm_context *lp_ctx,
+ struct loadparm_service *service, const char *type,
+ const char *option)
{
- const char *value = lp_get_parametric(lp_ctx, service, type, option);
+ const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
if (value)
return lp_string(value);
* Returned value is allocated in 'lp_talloc' context
*/
-const char **lp_parm_string_list(TALLOC_CTX *mem_ctx,
- struct loadparm_context *lp_ctx,
- struct loadparm_service *service,
- const char *type,
- const char *option, const char *separator)
+const char **lpcfg_parm_string_list(TALLOC_CTX *mem_ctx,
+ struct loadparm_context *lp_ctx,
+ struct loadparm_service *service,
+ const char *type,
+ const char *option, const char *separator)
{
- const char *value = lp_get_parametric(lp_ctx, service, type, option);
+ const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
if (value != NULL)
return (const char **)str_list_make(mem_ctx, value, separator);
* Parametric option has following syntax: 'Type: option = value'
*/
-int lp_parm_int(struct loadparm_context *lp_ctx,
- struct loadparm_service *service, const char *type,
- const char *option, int default_v)
+int lpcfg_parm_int(struct loadparm_context *lp_ctx,
+ struct loadparm_service *service, const char *type,
+ const char *option, int default_v)
{
- const char *value = lp_get_parametric(lp_ctx, service, type, option);
+ const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
if (value)
return lp_int(value);
* Parametric option has following syntax: 'Type: option = value'.
*/
-int lp_parm_bytes(struct loadparm_context *lp_ctx,
+int lpcfg_parm_bytes(struct loadparm_context *lp_ctx,
struct loadparm_service *service, const char *type,
const char *option, int default_v)
{
uint64_t bval;
- const char *value = lp_get_parametric(lp_ctx, service, type, option);
+ const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
if (value && conv_str_size(value, &bval)) {
if (bval <= INT_MAX) {
* Type is a part of option before ':'
* Parametric option has following syntax: 'Type: option = value'
*/
-unsigned long lp_parm_ulong(struct loadparm_context *lp_ctx,
+unsigned long lpcfg_parm_ulong(struct loadparm_context *lp_ctx,
struct loadparm_service *service, const char *type,
const char *option, unsigned long default_v)
{
- const char *value = lp_get_parametric(lp_ctx, service, type, option);
+ const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
if (value)
return lp_ulong(value);
}
-double lp_parm_double(struct loadparm_context *lp_ctx,
+double lpcfg_parm_double(struct loadparm_context *lp_ctx,
struct loadparm_service *service, const char *type,
const char *option, double default_v)
{
- const char *value = lp_get_parametric(lp_ctx, service, type, option);
+ const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
if (value != NULL)
return lp_double(value);
* Parametric option has following syntax: 'Type: option = value'
*/
-bool lp_parm_bool(struct loadparm_context *lp_ctx,
- struct loadparm_service *service, const char *type,
- const char *option, bool default_v)
+bool lpcfg_parm_bool(struct loadparm_context *lp_ctx,
+ struct loadparm_service *service, const char *type,
+ const char *option, bool default_v)
{
- const char *value = lp_get_parametric(lp_ctx, service, type, option);
+ const char *value = lpcfg_get_parametric(lp_ctx, service, type, option);
if (value != NULL)
return lp_bool(value);
* service.
*/
-struct loadparm_service *lp_add_service(struct loadparm_context *lp_ctx,
- const struct loadparm_service *pservice,
- const char *name)
+struct loadparm_service *lpcfg_add_service(struct loadparm_context *lp_ctx,
+ const struct loadparm_service *pservice,
+ const char *name)
{
int i;
struct loadparm_service tservice;
tsp = talloc_realloc(lp_ctx, lp_ctx->services, struct loadparm_service *, num_to_alloc);
if (!tsp) {
- DEBUG(0,("lp_add_service: failed to enlarge services!\n"));
+ DEBUG(0,("lpcfg_add_service: failed to enlarge services!\n"));
return NULL;
} else {
lp_ctx->services = tsp;
lp_ctx->services[i] = init_service(lp_ctx->services, lp_ctx->sDefault);
if (lp_ctx->services[i] == NULL) {
- DEBUG(0,("lp_add_service: out of memory!\n"));
+ DEBUG(0,("lpcfg_add_service: out of memory!\n"));
return NULL;
}
copy_service(lp_ctx->services[i], &tservice, NULL);
* from service ifrom.
*/
-bool lp_add_home(struct loadparm_context *lp_ctx,
+bool lpcfg_add_home(struct loadparm_context *lp_ctx,
const char *pszHomename,
struct loadparm_service *default_service,
const char *user, const char *pszHomedir)
{
struct loadparm_service *service;
- service = lp_add_service(lp_ctx, default_service, pszHomename);
+ service = lpcfg_add_service(lp_ctx, default_service, pszHomename);
if (service == NULL)
return false;
|| strequal(default_service->szPath, lp_ctx->sDefault->szPath)) {
service->szPath = talloc_strdup(service, pszHomedir);
} else {
- service->szPath = string_sub_talloc(service, lp_pathname(default_service, lp_ctx->sDefault), "%H", pszHomedir);
+ service->szPath = string_sub_talloc(service, lpcfg_pathname(default_service, lp_ctx->sDefault), "%H", pszHomedir);
}
if (!(*(service->comment))) {
* Add the IPC service.
*/
-static bool lp_add_hidden(struct loadparm_context *lp_ctx, const char *name,
- const char *fstype)
+static bool lpcfg_add_hidden(struct loadparm_context *lp_ctx, const char *name,
+ const char *fstype)
{
- struct loadparm_service *service = lp_add_service(lp_ctx, lp_ctx->sDefault, name);
+ struct loadparm_service *service = lpcfg_add_service(lp_ctx, lp_ctx->sDefault, name);
if (service == NULL)
return false;
service->bBrowseable = false;
if (strcasecmp(fstype, "IPC") == 0) {
- lp_do_service_parameter(lp_ctx, service, "ntvfs handler",
+ lpcfg_do_service_parameter(lp_ctx, service, "ntvfs handler",
"default");
}
{
const char *comment = "From Printcap";
struct loadparm_service *service;
- service = lp_add_service(lp_ctx, default_service, pszPrintername);
+ service = lpcfg_add_service(lp_ctx, default_service, pszPrintername);
if (service == NULL)
return false;
/**
return the parameter structure for a parameter
*/
-struct parm_struct *lp_parm_struct(const char *name)
+struct parm_struct *lpcfg_parm_struct(const char *name)
{
int parmnum = map_parameter(name);
if (parmnum == -1) return NULL;
/**
return the parameter pointer for a parameter
*/
-void *lp_parm_ptr(struct loadparm_context *lp_ctx,
+void *lpcfg_parm_ptr(struct loadparm_context *lp_ctx,
struct loadparm_service *service, struct parm_struct *parm)
{
if (service == NULL) {
* Find a service by name. Otherwise works like get_service.
*/
-static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx,
+static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx,
const char *pszServiceName)
{
int iService;
}
-bool lp_do_global_parameter(struct loadparm_context *lp_ctx,
- const char *pszParmName, const char *pszParmValue)
+bool lpcfg_do_global_parameter(struct loadparm_context *lp_ctx,
+ const char *pszParmName, const char *pszParmValue)
{
int parmnum = map_parameter(pszParmName);
void *parm_ptr;
return true;
}
- parm_ptr = lp_parm_ptr(lp_ctx, NULL, &parm_table[parmnum]);
+ parm_ptr = lpcfg_parm_ptr(lp_ctx, NULL, &parm_table[parmnum]);
return set_variable(lp_ctx, parmnum, parm_ptr,
pszParmName, pszParmValue, lp_ctx);
}
-bool lp_do_service_parameter(struct loadparm_context *lp_ctx,
- struct loadparm_service *service,
- const char *pszParmName, const char *pszParmValue)
+bool lpcfg_do_service_parameter(struct loadparm_context *lp_ctx,
+ struct loadparm_service *service,
+ const char *pszParmName, const char *pszParmValue)
{
void *parm_ptr;
int i;
struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
if (lp_ctx->bInGlobalSection)
- return lp_do_global_parameter(lp_ctx, pszParmName,
+ return lpcfg_do_global_parameter(lp_ctx, pszParmName,
pszParmValue);
else
- return lp_do_service_parameter(lp_ctx, lp_ctx->currentService,
- pszParmName, pszParmValue);
+ return lpcfg_do_service_parameter(lp_ctx, lp_ctx->currentService,
+ pszParmName, pszParmValue);
}
/*
variable argument do parameter
*/
-bool lp_do_global_parameter_var(struct loadparm_context *lp_ctx, const char *pszParmName, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
-bool lp_do_global_parameter_var(struct loadparm_context *lp_ctx,
+bool lpcfg_do_global_parameter_var(struct loadparm_context *lp_ctx, const char *pszParmName, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
+bool lpcfg_do_global_parameter_var(struct loadparm_context *lp_ctx,
const char *pszParmName, const char *fmt, ...)
{
char *s;
va_start(ap, fmt);
s = talloc_vasprintf(NULL, fmt, ap);
va_end(ap);
- ret = lp_do_global_parameter(lp_ctx, pszParmName, s);
+ ret = lpcfg_do_global_parameter(lp_ctx, pszParmName, s);
talloc_free(s);
return ret;
}
parsing code. It sets the parameter then marks the parameter as unable to be modified
by smb.conf processing
*/
-bool lp_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
- const char *pszParmValue)
+bool lpcfg_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
+ const char *pszParmValue)
{
int parmnum = map_parameter(pszParmName);
int i;
/* reset the CMDLINE flag in case this has been called before */
lp_ctx->flags[parmnum] &= ~FLAG_CMDLINE;
- if (!lp_do_global_parameter(lp_ctx, pszParmName, pszParmValue)) {
+ if (!lpcfg_do_global_parameter(lp_ctx, pszParmName, pszParmValue)) {
return false;
}
/*
set a option from the commandline in 'a=b' format. Use to support --option
*/
-bool lp_set_option(struct loadparm_context *lp_ctx, const char *option)
+bool lpcfg_set_option(struct loadparm_context *lp_ctx, const char *option)
{
char *p, *s;
bool ret;
*p = 0;
- ret = lp_set_cmdline(lp_ctx, s, p+1);
+ ret = lpcfg_set_cmdline(lp_ctx, s, p+1);
free(s);
return ret;
}
/* issued by the post-processing of a previous section. */
DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
- if ((lp_ctx->currentService = lp_add_service(lp_ctx, lp_ctx->sDefault,
- pszSectionName))
+ if ((lp_ctx->currentService = lpcfg_add_service(lp_ctx, lp_ctx->sDefault,
+ pszSectionName))
== NULL) {
DEBUG(0, ("Failed to add a new service\n"));
return false;
if (parm_table[i].pclass == P_GLOBAL &&
parm_table[i].offset != -1 &&
(i == 0 || (parm_table[i].offset != parm_table[i - 1].offset))) {
- if (!show_defaults && (lp_ctx->flags[i] & FLAG_DEFAULT))
+ if (!show_defaults && (lp_ctx->flags[i] & FLAG_DEFAULT))
continue;
fprintf(f, "\t%s = ", parm_table[i].label);
- print_parameter(&parm_table[i], lp_parm_ptr(lp_ctx, NULL, &parm_table[i]), f);
+ print_parameter(&parm_table[i], lpcfg_parm_ptr(lp_ctx, NULL, &parm_table[i]), f);
fprintf(f, "\n");
}
if (lp_ctx->globals->param_opt != NULL) {
}
}
-bool lp_dump_a_parameter(struct loadparm_context *lp_ctx,
- struct loadparm_service *service,
- const char *parm_name, FILE * f)
+bool lpcfg_dump_a_parameter(struct loadparm_context *lp_ctx,
+ struct loadparm_service *service,
+ const char *parm_name, FILE * f)
{
struct parm_struct *parm;
void *ptr;
- parm = lp_parm_struct(parm_name);
+ parm = lpcfg_parm_struct(parm_name);
if (!parm) {
return false;
}
- ptr = lp_parm_ptr(lp_ctx, service,parm);
+ ptr = lpcfg_parm_ptr(lp_ctx, service,parm);
print_parameter(parm, ptr, f);
fprintf(f, "\n");
* Return NULL when out of parameters.
*/
-struct parm_struct *lp_next_parameter(struct loadparm_context *lp_ctx, int snum, int *i,
- int allparameters)
+
+struct parm_struct *lpcfg_next_parameter(struct loadparm_context *lp_ctx, int snum, int *i,
+ int allparameters)
{
if (snum == -1) {
/* do the globals */
/**
* Auto-load some home services.
*/
-static void lp_add_auto_services(struct loadparm_context *lp_ctx,
- const char *str)
+static void lpcfg_add_auto_services(struct loadparm_context *lp_ctx,
+ const char *str)
{
return;
}
}
}
- lp_do_global_parameter(lp_ctx, "share backend", "classic");
+ lpcfg_do_global_parameter(lp_ctx, "share backend", "classic");
- lp_do_global_parameter(lp_ctx, "server role", "standalone");
+ lpcfg_do_global_parameter(lp_ctx, "server role", "standalone");
/* options that can be set on the command line must be initialised via
- the slower lp_do_global_parameter() to ensure that FLAG_CMDLINE is obeyed */
+ the slower lpcfg_do_global_parameter() to ensure that FLAG_CMDLINE is obeyed */
#ifdef TCP_NODELAY
- lp_do_global_parameter(lp_ctx, "socket options", "TCP_NODELAY");
+ lpcfg_do_global_parameter(lp_ctx, "socket options", "TCP_NODELAY");
#endif
- lp_do_global_parameter(lp_ctx, "workgroup", DEFAULT_WORKGROUP);
+ lpcfg_do_global_parameter(lp_ctx, "workgroup", DEFAULT_WORKGROUP);
myname = get_myname(lp_ctx);
- lp_do_global_parameter(lp_ctx, "netbios name", myname);
+ lpcfg_do_global_parameter(lp_ctx, "netbios name", myname);
talloc_free(myname);
- lp_do_global_parameter(lp_ctx, "name resolve order", "wins host bcast");
-
- lp_do_global_parameter(lp_ctx, "fstype", "NTFS");
-
- lp_do_global_parameter(lp_ctx, "ntvfs handler", "unixuid default");
- lp_do_global_parameter(lp_ctx, "max connections", "-1");
-
- lp_do_global_parameter(lp_ctx, "dcerpc endpoint servers", "epmapper srvsvc wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi winreg dssetup unixinfo browser");
- lp_do_global_parameter(lp_ctx, "server services", "smb rpc nbt wrepl ldap cldap kdc drepl winbind ntp_signd kcc dnsupdate");
- lp_do_global_parameter(lp_ctx, "ntptr providor", "simple_ldb");
- lp_do_global_parameter(lp_ctx, "auth methods:domain controller", "anonymous sam_ignoredomain");
- lp_do_global_parameter(lp_ctx, "auth methods:member server", "anonymous sam winbind");
- lp_do_global_parameter(lp_ctx, "auth methods:standalone", "anonymous sam_ignoredomain");
- lp_do_global_parameter(lp_ctx, "private dir", dyn_PRIVATE_DIR);
- lp_do_global_parameter(lp_ctx, "sam database", "sam.ldb");
- lp_do_global_parameter(lp_ctx, "idmap database", "idmap.ldb");
- lp_do_global_parameter(lp_ctx, "secrets database", "secrets.ldb");
- lp_do_global_parameter(lp_ctx, "spoolss database", "spoolss.ldb");
- lp_do_global_parameter(lp_ctx, "wins config database", "wins_config.ldb");
- lp_do_global_parameter(lp_ctx, "wins database", "wins.ldb");
- lp_do_global_parameter(lp_ctx, "registry:HKEY_LOCAL_MACHINE", "hklm.ldb");
+ lpcfg_do_global_parameter(lp_ctx, "name resolve order", "wins host bcast");
+
+ lpcfg_do_global_parameter(lp_ctx, "fstype", "NTFS");
+
+ lpcfg_do_global_parameter(lp_ctx, "ntvfs handler", "unixuid default");
+ lpcfg_do_global_parameter(lp_ctx, "max connections", "-1");
+
+ lpcfg_do_global_parameter(lp_ctx, "dcerpc endpoint servers", "epmapper srvsvc wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi winreg dssetup unixinfo browser");
+ lpcfg_do_global_parameter(lp_ctx, "server services", "smb rpc nbt wrepl ldap cldap kdc drepl winbind ntp_signd kcc dnsupdate");
+ lpcfg_do_global_parameter(lp_ctx, "ntptr providor", "simple_ldb");
+ lpcfg_do_global_parameter(lp_ctx, "auth methods:domain controller", "anonymous sam_ignoredomain");
+ lpcfg_do_global_parameter(lp_ctx, "auth methods:member server", "anonymous sam winbind");
+ lpcfg_do_global_parameter(lp_ctx, "auth methods:standalone", "anonymous sam_ignoredomain");
+ lpcfg_do_global_parameter(lp_ctx, "private dir", dyn_PRIVATE_DIR);
+ lpcfg_do_global_parameter(lp_ctx, "sam database", "sam.ldb");
+ lpcfg_do_global_parameter(lp_ctx, "idmap database", "idmap.ldb");
+ lpcfg_do_global_parameter(lp_ctx, "secrets database", "secrets.ldb");
+ lpcfg_do_global_parameter(lp_ctx, "spoolss database", "spoolss.ldb");
+ lpcfg_do_global_parameter(lp_ctx, "wins config database", "wins_config.ldb");
+ lpcfg_do_global_parameter(lp_ctx, "wins database", "wins.ldb");
+ lpcfg_do_global_parameter(lp_ctx, "registry:HKEY_LOCAL_MACHINE", "hklm.ldb");
/* This hive should be dynamically generated by Samba using
data from the sam, but for the moment leave it in a tdb to
keep regedt32 from popping up an annoying dialog. */
- lp_do_global_parameter(lp_ctx, "registry:HKEY_USERS", "hku.ldb");
+ lpcfg_do_global_parameter(lp_ctx, "registry:HKEY_USERS", "hku.ldb");
/* using UTF8 by default allows us to support all chars */
- lp_do_global_parameter(lp_ctx, "unix charset", "UTF8");
+ lpcfg_do_global_parameter(lp_ctx, "unix charset", "UTF8");
/* Use codepage 850 as a default for the dos character set */
- lp_do_global_parameter(lp_ctx, "dos charset", "CP850");
+ lpcfg_do_global_parameter(lp_ctx, "dos charset", "CP850");
/*
* Allow the default PASSWD_CHAT to be overridden in local.h.
*/
- lp_do_global_parameter(lp_ctx, "passwd chat", DEFAULT_PASSWD_CHAT);
+ lpcfg_do_global_parameter(lp_ctx, "passwd chat", DEFAULT_PASSWD_CHAT);
- lp_do_global_parameter(lp_ctx, "pid directory", dyn_PIDDIR);
- lp_do_global_parameter(lp_ctx, "lock dir", dyn_LOCKDIR);
- lp_do_global_parameter(lp_ctx, "modules dir", dyn_MODULESDIR);
- lp_do_global_parameter(lp_ctx, "ncalrpc dir", dyn_NCALRPCDIR);
+ lpcfg_do_global_parameter(lp_ctx, "pid directory", dyn_PIDDIR);
+ lpcfg_do_global_parameter(lp_ctx, "lock dir", dyn_LOCKDIR);
+ lpcfg_do_global_parameter(lp_ctx, "modules dir", dyn_MODULESDIR);
+ lpcfg_do_global_parameter(lp_ctx, "ncalrpc dir", dyn_NCALRPCDIR);
- lp_do_global_parameter(lp_ctx, "socket address", "0.0.0.0");
- lp_do_global_parameter_var(lp_ctx, "server string",
+ lpcfg_do_global_parameter(lp_ctx, "socket address", "0.0.0.0");
+ lpcfg_do_global_parameter_var(lp_ctx, "server string",
"Samba %s", SAMBA_VERSION_STRING);
- lp_do_global_parameter_var(lp_ctx, "announce version", "%d.%d",
+ lpcfg_do_global_parameter_var(lp_ctx, "announce version", "%d.%d",
DEFAULT_MAJOR_VERSION,
DEFAULT_MINOR_VERSION);
- lp_do_global_parameter(lp_ctx, "password server", "*");
-
- lp_do_global_parameter(lp_ctx, "max mux", "50");
- lp_do_global_parameter(lp_ctx, "max xmit", "12288");
- lp_do_global_parameter(lp_ctx, "password level", "0");
- lp_do_global_parameter(lp_ctx, "LargeReadwrite", "True");
- lp_do_global_parameter(lp_ctx, "server min protocol", "CORE");
- lp_do_global_parameter(lp_ctx, "server max protocol", "NT1");
- lp_do_global_parameter(lp_ctx, "client min protocol", "CORE");
- lp_do_global_parameter(lp_ctx, "client max protocol", "NT1");
- lp_do_global_parameter(lp_ctx, "security", "USER");
- lp_do_global_parameter(lp_ctx, "paranoid server security", "True");
- lp_do_global_parameter(lp_ctx, "EncryptPasswords", "True");
- lp_do_global_parameter(lp_ctx, "ReadRaw", "True");
- lp_do_global_parameter(lp_ctx, "WriteRaw", "True");
- lp_do_global_parameter(lp_ctx, "NullPasswords", "False");
- lp_do_global_parameter(lp_ctx, "ObeyPamRestrictions", "False");
- lp_do_global_parameter(lp_ctx, "announce as", "NT SERVER");
-
- lp_do_global_parameter(lp_ctx, "TimeServer", "False");
- lp_do_global_parameter(lp_ctx, "BindInterfacesOnly", "False");
- lp_do_global_parameter(lp_ctx, "Unicode", "True");
- lp_do_global_parameter(lp_ctx, "ClientLanManAuth", "False");
- lp_do_global_parameter(lp_ctx, "LanmanAuth", "False");
- lp_do_global_parameter(lp_ctx, "NTLMAuth", "True");
- lp_do_global_parameter(lp_ctx, "client use spnego principal", "False");
-
- lp_do_global_parameter(lp_ctx, "UnixExtensions", "False");
-
- lp_do_global_parameter(lp_ctx, "PreferredMaster", "Auto");
- lp_do_global_parameter(lp_ctx, "LocalMaster", "True");
-
- lp_do_global_parameter(lp_ctx, "wins support", "False");
- lp_do_global_parameter(lp_ctx, "dns proxy", "True");
-
- lp_do_global_parameter(lp_ctx, "winbind separator", "\\");
- lp_do_global_parameter(lp_ctx, "winbind sealed pipes", "True");
- lp_do_global_parameter(lp_ctx, "winbindd socket directory", dyn_WINBINDD_SOCKET_DIR);
- lp_do_global_parameter(lp_ctx, "winbindd privileged socket directory", dyn_WINBINDD_PRIVILEGED_SOCKET_DIR);
- lp_do_global_parameter(lp_ctx, "template shell", "/bin/false");
- lp_do_global_parameter(lp_ctx, "template homedir", "/home/%WORKGROUP%/%ACCOUNTNAME%");
- lp_do_global_parameter(lp_ctx, "idmap trusted only", "False");
-
- lp_do_global_parameter(lp_ctx, "client signing", "Yes");
- lp_do_global_parameter(lp_ctx, "server signing", "auto");
-
- lp_do_global_parameter(lp_ctx, "use spnego", "True");
-
- lp_do_global_parameter(lp_ctx, "smb ports", "445 139");
- lp_do_global_parameter(lp_ctx, "nbt port", "137");
- lp_do_global_parameter(lp_ctx, "dgram port", "138");
- lp_do_global_parameter(lp_ctx, "cldap port", "389");
- lp_do_global_parameter(lp_ctx, "krb5 port", "88");
- lp_do_global_parameter(lp_ctx, "kpasswd port", "464");
- lp_do_global_parameter(lp_ctx, "web port", "901");
-
- lp_do_global_parameter(lp_ctx, "nt status support", "True");
-
- lp_do_global_parameter(lp_ctx, "max wins ttl", "518400"); /* 6 days */
- lp_do_global_parameter(lp_ctx, "min wins ttl", "10");
-
- lp_do_global_parameter(lp_ctx, "tls enabled", "True");
- lp_do_global_parameter(lp_ctx, "tls keyfile", "tls/key.pem");
- lp_do_global_parameter(lp_ctx, "tls certfile", "tls/cert.pem");
- lp_do_global_parameter(lp_ctx, "tls cafile", "tls/ca.pem");
- lp_do_global_parameter_var(lp_ctx, "setup directory", "%s",
+ lpcfg_do_global_parameter(lp_ctx, "password server", "*");
+
+ lpcfg_do_global_parameter(lp_ctx, "max mux", "50");
+ lpcfg_do_global_parameter(lp_ctx, "max xmit", "12288");
+ lpcfg_do_global_parameter(lp_ctx, "password level", "0");
+ lpcfg_do_global_parameter(lp_ctx, "LargeReadwrite", "True");
+ lpcfg_do_global_parameter(lp_ctx, "server min protocol", "CORE");
+ lpcfg_do_global_parameter(lp_ctx, "server max protocol", "NT1");
+ lpcfg_do_global_parameter(lp_ctx, "client min protocol", "CORE");
+ lpcfg_do_global_parameter(lp_ctx, "client max protocol", "NT1");
+ lpcfg_do_global_parameter(lp_ctx, "security", "USER");
+ lpcfg_do_global_parameter(lp_ctx, "paranoid server security", "True");
+ lpcfg_do_global_parameter(lp_ctx, "EncryptPasswords", "True");
+ lpcfg_do_global_parameter(lp_ctx, "ReadRaw", "True");
+ lpcfg_do_global_parameter(lp_ctx, "WriteRaw", "True");
+ lpcfg_do_global_parameter(lp_ctx, "NullPasswords", "False");
+ lpcfg_do_global_parameter(lp_ctx, "ObeyPamRestrictions", "False");
+ lpcfg_do_global_parameter(lp_ctx, "announce as", "NT SERVER");
+
+ lpcfg_do_global_parameter(lp_ctx, "TimeServer", "False");
+ lpcfg_do_global_parameter(lp_ctx, "BindInterfacesOnly", "False");
+ lpcfg_do_global_parameter(lp_ctx, "Unicode", "True");
+ lpcfg_do_global_parameter(lp_ctx, "ClientLanManAuth", "False");
+ lpcfg_do_global_parameter(lp_ctx, "LanmanAuth", "False");
+ lpcfg_do_global_parameter(lp_ctx, "NTLMAuth", "True");
+ lpcfg_do_global_parameter(lp_ctx, "client use spnego principal", "False");
+
+ lpcfg_do_global_parameter(lp_ctx, "UnixExtensions", "False");
+
+ lpcfg_do_global_parameter(lp_ctx, "PreferredMaster", "Auto");
+ lpcfg_do_global_parameter(lp_ctx, "LocalMaster", "True");
+
+ lpcfg_do_global_parameter(lp_ctx, "wins support", "False");
+ lpcfg_do_global_parameter(lp_ctx, "dns proxy", "True");
+
+ lpcfg_do_global_parameter(lp_ctx, "winbind separator", "\\");
+ lpcfg_do_global_parameter(lp_ctx, "winbind sealed pipes", "True");
+ lpcfg_do_global_parameter(lp_ctx, "winbindd socket directory", dyn_WINBINDD_SOCKET_DIR);
+ lpcfg_do_global_parameter(lp_ctx, "winbindd privileged socket directory", dyn_WINBINDD_PRIVILEGED_SOCKET_DIR);
+ lpcfg_do_global_parameter(lp_ctx, "template shell", "/bin/false");
+ lpcfg_do_global_parameter(lp_ctx, "template homedir", "/home/%WORKGROUP%/%ACCOUNTNAME%");
+ lpcfg_do_global_parameter(lp_ctx, "idmap trusted only", "False");
+
+ lpcfg_do_global_parameter(lp_ctx, "client signing", "Yes");
+ lpcfg_do_global_parameter(lp_ctx, "server signing", "auto");
+
+ lpcfg_do_global_parameter(lp_ctx, "use spnego", "True");
+
+ lpcfg_do_global_parameter(lp_ctx, "smb ports", "445 139");
+ lpcfg_do_global_parameter(lp_ctx, "nbt port", "137");
+ lpcfg_do_global_parameter(lp_ctx, "dgram port", "138");
+ lpcfg_do_global_parameter(lp_ctx, "cldap port", "389");
+ lpcfg_do_global_parameter(lp_ctx, "krb5 port", "88");
+ lpcfg_do_global_parameter(lp_ctx, "kpasswd port", "464");
+ lpcfg_do_global_parameter(lp_ctx, "web port", "901");
+
+ lpcfg_do_global_parameter(lp_ctx, "nt status support", "True");
+
+ lpcfg_do_global_parameter(lp_ctx, "max wins ttl", "518400"); /* 6 days */
+ lpcfg_do_global_parameter(lp_ctx, "min wins ttl", "10");
+
+ lpcfg_do_global_parameter(lp_ctx, "tls enabled", "True");
+ lpcfg_do_global_parameter(lp_ctx, "tls keyfile", "tls/key.pem");
+ lpcfg_do_global_parameter(lp_ctx, "tls certfile", "tls/cert.pem");
+ lpcfg_do_global_parameter(lp_ctx, "tls cafile", "tls/ca.pem");
+ lpcfg_do_global_parameter_var(lp_ctx, "setup directory", "%s",
dyn_SETUPDIR);
- lp_do_global_parameter(lp_ctx, "prefork children:smb", "4");
+ lpcfg_do_global_parameter(lp_ctx, "prefork children:smb", "4");
- lp_do_global_parameter(lp_ctx, "ntp signd socket directory", dyn_NTP_SIGND_SOCKET_DIR);
- lp_do_global_parameter(lp_ctx, "rndc command", "/usr/sbin/rndc");
- lp_do_global_parameter_var(lp_ctx, "dns update command", "%s/samba_dnsupdate", dyn_SBINDIR);
- lp_do_global_parameter_var(lp_ctx, "spn update command", "%s/samba_spnupdate", dyn_SBINDIR);
- lp_do_global_parameter(lp_ctx, "nsupdate command", "/usr/bin/nsupdate -g");
+ lpcfg_do_global_parameter(lp_ctx, "ntp signd socket directory", dyn_NTP_SIGND_SOCKET_DIR);
+ lpcfg_do_global_parameter(lp_ctx, "rndc command", "/usr/sbin/rndc");
+ lpcfg_do_global_parameter_var(lp_ctx, "dns update command", "%s/samba_dnsupdate", dyn_SBINDIR);
+ lpcfg_do_global_parameter_var(lp_ctx, "spn update command", "%s/samba_spnupdate", dyn_SBINDIR);
+ lpcfg_do_global_parameter(lp_ctx, "nsupdate command", "/usr/bin/nsupdate -g");
for (i = 0; parm_table[i].label; i++) {
if (!(lp_ctx->flags[i] & FLAG_CMDLINE)) {
return lp_ctx;
}
-const char *lp_configfile(struct loadparm_context *lp_ctx)
+const char *lpcfg_configfile(struct loadparm_context *lp_ctx)
{
return lp_ctx->szConfigFile;
}
* Update the internal state of a loadparm context after settings
* have changed.
*/
-static bool lp_update(struct loadparm_context *lp_ctx)
+static bool lpcfg_update(struct loadparm_context *lp_ctx)
{
- lp_add_auto_services(lp_ctx, lp_auto_services(lp_ctx));
+ lpcfg_add_auto_services(lp_ctx, lpcfg_auto_services(lp_ctx));
- lp_add_hidden(lp_ctx, "IPC$", "IPC");
- lp_add_hidden(lp_ctx, "ADMIN$", "DISK");
+ lpcfg_add_hidden(lp_ctx, "IPC$", "IPC");
+ lpcfg_add_hidden(lp_ctx, "ADMIN$", "DISK");
if (!lp_ctx->globals->szWINSservers && lp_ctx->globals->bWINSsupport) {
- lp_do_global_parameter(lp_ctx, "wins server", "127.0.0.1");
+ lpcfg_do_global_parameter(lp_ctx, "wins server", "127.0.0.1");
}
panic_action = lp_ctx->globals->panic_action;
reload_charcnv(lp_ctx);
- /* FIXME: ntstatus_check_dos_mapping = lp_nt_status_support(lp_ctx); */
+ /* FIXME: ntstatus_check_dos_mapping = lpcfg_nt_status_support(lp_ctx); */
/* FIXME: This is a bit of a hack, but we can't use a global, since
* not everything that uses lp also uses the socket library */
- if (lp_parm_bool(lp_ctx, NULL, "socket", "testnonblock", false)) {
+ if (lpcfg_parm_bool(lp_ctx, NULL, "socket", "testnonblock", false)) {
setenv("SOCKET_TESTNONBLOCK", "1", 1);
} else {
unsetenv("SOCKET_TESTNONBLOCK");
}
/* FIXME: Check locale in environment for this: */
- if (strcmp(lp_display_charset(lp_ctx), lp_unix_charset(lp_ctx)) != 0)
- d_set_iconv(smb_iconv_open(lp_display_charset(lp_ctx), lp_unix_charset(lp_ctx)));
+ if (strcmp(lpcfg_display_charset(lp_ctx), lpcfg_unix_charset(lp_ctx)) != 0)
+ d_set_iconv(smb_iconv_open(lpcfg_display_charset(lp_ctx), lpcfg_unix_charset(lp_ctx)));
else
d_set_iconv((smb_iconv_t)-1);
return true;
}
-bool lp_load_default(struct loadparm_context *lp_ctx)
+bool lpcfg_load_default(struct loadparm_context *lp_ctx)
{
const char *path;
if (!file_exist(path)) {
/* We allow the default smb.conf file to not exist,
* basically the equivalent of an empty file. */
- return lp_update(lp_ctx);
+ return lpcfg_update(lp_ctx);
}
- return lp_load(lp_ctx, path);
+ return lpcfg_load(lp_ctx, path);
}
/**
*
* Return True on success, False on failure.
*/
-bool lp_load(struct loadparm_context *lp_ctx, const char *filename)
+bool lpcfg_load(struct loadparm_context *lp_ctx, const char *filename)
{
char *n2;
bool bRetval;
lp_ctx->bInGlobalSection = true;
n2 = standard_sub_basic(lp_ctx, lp_ctx->szConfigFile);
- DEBUG(2, ("lp_load: refreshing parameters from %s\n", n2));
+ DEBUG(2, ("lpcfg_load: refreshing parameters from %s\n", n2));
add_to_file_list(lp_ctx, lp_ctx->szConfigFile, n2);
if (lp_ctx->currentService != NULL)
bRetval = service_ok(lp_ctx->currentService);
- bRetval = bRetval && lp_update(lp_ctx);
+ bRetval = bRetval && lpcfg_update(lp_ctx);
/* we do this unconditionally, so that it happens even
for a missing smb.conf */
/* set this up so that any child python tasks will
find the right smb.conf */
setenv("SMB_CONF_PATH", filename, 1);
+
+ /* set the context used by the lp_*() function
+ varients */
+ global_loadparm_context = lp_ctx;
}
return bRetval;
* Return the max number of services.
*/
-int lp_numservices(struct loadparm_context *lp_ctx)
+int lpcfg_numservices(struct loadparm_context *lp_ctx)
{
return lp_ctx->iNumServices;
}
* Display the contents of the services array in human-readable form.
*/
-void lp_dump(struct loadparm_context *lp_ctx, FILE *f, bool show_defaults,
+void lpcfg_dump(struct loadparm_context *lp_ctx, FILE *f, bool show_defaults,
int maxtoprint)
{
int iService;
dump_a_service(lp_ctx->sDefault, lp_ctx->sDefault, f);
for (iService = 0; iService < maxtoprint; iService++)
- lp_dump_one(f, show_defaults, lp_ctx->services[iService], lp_ctx->sDefault);
+ lpcfg_dump_one(f, show_defaults, lp_ctx->services[iService], lp_ctx->sDefault);
}
/**
* Display the contents of one service in human-readable form.
*/
-void lp_dump_one(FILE *f, bool show_defaults, struct loadparm_service *service, struct loadparm_service *sDefault)
+void lpcfg_dump_one(FILE *f, bool show_defaults, struct loadparm_service *service, struct loadparm_service *sDefault)
{
if (service != NULL) {
if (service->szService[0] == '\0')
}
}
-struct loadparm_service *lp_servicebynum(struct loadparm_context *lp_ctx,
+struct loadparm_service *lpcfg_servicebynum(struct loadparm_context *lp_ctx,
int snum)
{
return lp_ctx->services[snum];
}
-struct loadparm_service *lp_service(struct loadparm_context *lp_ctx,
+struct loadparm_service *lpcfg_service(struct loadparm_context *lp_ctx,
const char *service_name)
{
int iService;
}
}
- DEBUG(7,("lp_servicenumber: couldn't find %s\n", service_name));
+ DEBUG(7,("lpcfg_servicenumber: couldn't find %s\n", service_name));
return NULL;
}
+const char *lpcfg_servicename(const struct loadparm_service *service)
+{
+ return lp_string((const char *)service->szService);
+}
/**
* A useful volume label function.
*/
const char *volume_label(struct loadparm_service *service, struct loadparm_service *sDefault)
{
- const char *ret = lp_volume(service, sDefault);
+ const char *ret;
+ ret = lp_string((const char *)((service != NULL && service->volume != NULL) ?
+ service->volume : sDefault->volume));
if (!*ret)
- return lp_servicename(service);
+ return lpcfg_servicename(service);
return ret;
}
-
/**
* If we are PDC then prefer us as DMB
*/
-const char *lp_printername(struct loadparm_service *service, struct loadparm_service *sDefault)
+const char *lpcfg_printername(struct loadparm_service *service, struct loadparm_service *sDefault)
{
- const char *ret = _lp_printername(service, sDefault);
+ const char *ret;
+ ret = lp_string((const char *)((service != NULL && service->szPrintername != NULL) ?
+ service->szPrintername : sDefault->szPrintername));
if (ret == NULL || (ret != NULL && *ret == '\0'))
- ret = lp_servicename(service);
+ ret = lpcfg_servicename(service);
return ret;
}
/**
* Return the max print jobs per queue.
*/
-int lp_maxprintjobs(struct loadparm_service *service, struct loadparm_service *sDefault)
+int lpcfg_maxprintjobs(struct loadparm_service *service, struct loadparm_service *sDefault)
{
int maxjobs = (service != NULL) ? service->iMaxPrintJobs : sDefault->iMaxPrintJobs;
if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
return maxjobs;
}
-struct smb_iconv_convenience *lp_iconv_convenience(struct loadparm_context *lp_ctx)
+struct smb_iconv_convenience *lpcfg_iconv_convenience(struct loadparm_context *lp_ctx)
{
if (lp_ctx == NULL) {
static struct smb_iconv_convenience *fallback_ic = NULL;
global_iconv_convenience = lp_ctx->iconv_convenience;
}
-void lp_smbcli_options(struct loadparm_context *lp_ctx,
+void lpcfg_smbcli_options(struct loadparm_context *lp_ctx,
struct smbcli_options *options)
{
- options->max_xmit = lp_max_xmit(lp_ctx);
- options->max_mux = lp_maxmux(lp_ctx);
- options->use_spnego = lp_nt_status_support(lp_ctx) && lp_use_spnego(lp_ctx);
- options->signing = lp_client_signing(lp_ctx);
+ options->max_xmit = lpcfg_max_xmit(lp_ctx);
+ options->max_mux = lpcfg_maxmux(lp_ctx);
+ options->use_spnego = lpcfg_nt_status_support(lp_ctx) && lpcfg_use_spnego(lp_ctx);
+ options->signing = lpcfg_client_signing(lp_ctx);
options->request_timeout = SMB_REQUEST_TIMEOUT;
- options->ntstatus_support = lp_nt_status_support(lp_ctx);
- options->max_protocol = lp_cli_maxprotocol(lp_ctx);
- options->unicode = lp_unicode(lp_ctx);
+ options->ntstatus_support = lpcfg_nt_status_support(lp_ctx);
+ options->max_protocol = lpcfg_cli_maxprotocol(lp_ctx);
+ options->unicode = lpcfg_unicode(lp_ctx);
options->use_oplocks = true;
options->use_level2_oplocks = true;
}
-void lp_smbcli_session_options(struct loadparm_context *lp_ctx,
+void lpcfg_smbcli_session_options(struct loadparm_context *lp_ctx,
struct smbcli_session_options *options)
{
- options->lanman_auth = lp_client_lanman_auth(lp_ctx);
- options->ntlmv2_auth = lp_client_ntlmv2_auth(lp_ctx);
- options->plaintext_auth = lp_client_plaintext_auth(lp_ctx);
+ options->lanman_auth = lpcfg_client_lanman_auth(lp_ctx);
+ options->ntlmv2_auth = lpcfg_client_ntlmv2_auth(lp_ctx);
+ options->plaintext_auth = lpcfg_client_plaintext_auth(lp_ctx);
}
-_PUBLIC_ char *lp_tls_keyfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+_PUBLIC_ char *lpcfg_tls_keyfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
{
return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_keyfile);
}
-_PUBLIC_ char *lp_tls_certfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+_PUBLIC_ char *lpcfg_tls_certfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
{
return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_certfile);
}
-_PUBLIC_ char *lp_tls_cafile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+_PUBLIC_ char *lpcfg_tls_cafile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
{
return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_cafile);
}
-_PUBLIC_ char *lp_tls_crlfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+_PUBLIC_ char *lpcfg_tls_crlfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
{
return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_crlfile);
}
-_PUBLIC_ char *lp_tls_dhpfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+_PUBLIC_ char *lpcfg_tls_dhpfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
{
return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_dhpfile);
}
-_PUBLIC_ struct dcerpc_server_info *lp_dcerpc_server_info(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+_PUBLIC_ struct dcerpc_server_info *lpcfg_dcerpc_server_info(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
{
struct dcerpc_server_info *ret = talloc_zero(mem_ctx, struct dcerpc_server_info);
- ret->domain_name = talloc_reference(mem_ctx, lp_workgroup(lp_ctx));
- ret->version_major = lp_parm_int(lp_ctx, NULL, "server_info", "version_major", 5);
- ret->version_minor = lp_parm_int(lp_ctx, NULL, "server_info", "version_minor", 2);
- ret->version_build = lp_parm_int(lp_ctx, NULL, "server_info", "version_build", 3790);
+ ret->domain_name = talloc_reference(mem_ctx, lpcfg_workgroup(lp_ctx));
+ ret->version_major = lpcfg_parm_int(lp_ctx, NULL, "server_info", "version_major", 5);
+ ret->version_minor = lpcfg_parm_int(lp_ctx, NULL, "server_info", "version_minor", 2);
+ ret->version_build = lpcfg_parm_int(lp_ctx, NULL, "server_info", "version_build", 3790);
return ret;
}
-struct gensec_settings *lp_gensec_settings(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+struct gensec_settings *lpcfg_gensec_settings(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
{
struct gensec_settings *settings = talloc(mem_ctx, struct gensec_settings);
if (settings == NULL)
return NULL;
SMB_ASSERT(lp_ctx != NULL);
settings->lp_ctx = talloc_reference(settings, lp_ctx);
- settings->target_hostname = lp_parm_string(lp_ctx, NULL, "gensec", "target_hostname");
+ settings->target_hostname = lpcfg_parm_string(lp_ctx, NULL, "gensec", "target_hostname");
return settings;
}
void reload_charcnv(struct loadparm_context *lp_ctx);
-struct loadparm_service *lp_default_service(struct loadparm_context *lp_ctx);
-struct parm_struct *lp_parm_table(void);
-int lp_server_role(struct loadparm_context *);
-int lp_sid_generator(struct loadparm_context *);
-const char **lp_smb_ports(struct loadparm_context *);
-int lp_nbt_port(struct loadparm_context *);
-int lp_dgram_port(struct loadparm_context *);
-int lp_cldap_port(struct loadparm_context *);
-int lp_krb5_port(struct loadparm_context *);
-int lp_kpasswd_port(struct loadparm_context *);
-int lp_web_port(struct loadparm_context *);
-bool lp_tls_enabled(struct loadparm_context *);
-char *lp_tls_keyfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
-char *lp_tls_certfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
-char *lp_tls_cafile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
-char *lp_tls_crlfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
-char *lp_tls_dhpfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
-const char *lp_share_backend(struct loadparm_context *);
-const char *lp_sam_url(struct loadparm_context *);
-const char *lp_idmap_url(struct loadparm_context *);
-const char *lp_secrets_url(struct loadparm_context *);
-const char *lp_spoolss_url(struct loadparm_context *);
-const char *lp_wins_config_url(struct loadparm_context *);
-const char *lp_wins_url(struct loadparm_context *);
-const char *lp_winbind_separator(struct loadparm_context *);
-const char *lp_winbindd_socket_directory(struct loadparm_context *);
-const char *lp_winbindd_privileged_socket_directory(struct loadparm_context *);
-const char *lp_template_shell(struct loadparm_context *);
-const char *lp_template_homedir(struct loadparm_context *);
-bool lp_winbind_sealed_pipes(struct loadparm_context *);
-bool lp_idmap_trusted_only(struct loadparm_context *);
-const char *lp_private_dir(struct loadparm_context *);
-const char *lp_serverstring(struct loadparm_context *);
-const char *lp_lockdir(struct loadparm_context *);
-const char *lp_modulesdir(struct loadparm_context *);
-const char *lp_setupdir(struct loadparm_context *);
-const char *lp_ncalrpc_dir(struct loadparm_context *);
-const char *lp_dos_charset(struct loadparm_context *);
-const char *lp_unix_charset(struct loadparm_context *);
-const char *lp_display_charset(struct loadparm_context *);
-const char *lp_piddir(struct loadparm_context *);
-const char **lp_dcerpc_endpoint_servers(struct loadparm_context *);
-const char **lp_server_services(struct loadparm_context *);
-const char *lp_ntptr_providor(struct loadparm_context *);
-const char *lp_auto_services(struct loadparm_context *);
-const char *lp_passwd_chat(struct loadparm_context *);
-const char **lp_passwordserver(struct loadparm_context *);
-const char **lp_name_resolve_order(struct loadparm_context *);
-const char *lp_realm(struct loadparm_context *);
-const char *lp_dnsdomain(struct loadparm_context *);
-const char *lp_socket_options(struct loadparm_context *);
-const char *lp_workgroup(struct loadparm_context *);
-const char *lp_netbios_name(struct loadparm_context *);
-const char *lp_netbios_scope(struct loadparm_context *);
-const char **lp_wins_server_list(struct loadparm_context *);
-const char **lp_interfaces(struct loadparm_context *);
-const char *lp_socket_address(struct loadparm_context *);
-const char **lp_netbios_aliases(struct loadparm_context *);
-const char **lp_rndc_command(struct loadparm_context *);
-const char **lp_dns_update_command(struct loadparm_context *);
-const char **lp_spn_update_command(struct loadparm_context *);
-bool lp_disable_netbios(struct loadparm_context *);
-bool lp_wins_support(struct loadparm_context *);
-bool lp_wins_dns_proxy(struct loadparm_context *);
-const char *lp_wins_hook(struct loadparm_context *);
-bool lp_local_master(struct loadparm_context *);
-bool lp_readraw(struct loadparm_context *);
-bool lp_large_readwrite(struct loadparm_context *);
-bool lp_writeraw(struct loadparm_context *);
-bool lp_null_passwords(struct loadparm_context *);
-bool lp_obey_pam_restrictions(struct loadparm_context *);
-bool lp_encrypted_passwords(struct loadparm_context *);
-bool lp_time_server(struct loadparm_context *);
-bool lp_bind_interfaces_only(struct loadparm_context *);
-bool lp_unicode(struct loadparm_context *);
-bool lp_nt_status_support(struct loadparm_context *);
-bool lp_lanman_auth(struct loadparm_context *);
-bool lp_ntlm_auth(struct loadparm_context *);
-bool lp_client_plaintext_auth(struct loadparm_context *);
-bool lp_client_lanman_auth(struct loadparm_context *);
-bool lp_client_ntlmv2_auth(struct loadparm_context *);
-bool lp_client_use_spnego_principal(struct loadparm_context *);
-bool lp_host_msdfs(struct loadparm_context *);
-bool lp_unix_extensions(struct loadparm_context *);
-bool lp_use_spnego(struct loadparm_context *);
-bool lp_rpc_big_endian(struct loadparm_context *);
-int lp_max_wins_ttl(struct loadparm_context *);
-int lp_min_wins_ttl(struct loadparm_context *);
-int lp_maxmux(struct loadparm_context *);
-int lp_max_xmit(struct loadparm_context *);
-int lp_passwordlevel(struct loadparm_context *);
-int lp_srv_maxprotocol(struct loadparm_context *);
-int lp_srv_minprotocol(struct loadparm_context *);
-int lp_cli_maxprotocol(struct loadparm_context *);
-int lp_cli_minprotocol(struct loadparm_context *);
-int lp_security(struct loadparm_context *);
-bool lp_paranoid_server_security(struct loadparm_context *);
-int lp_announce_as(struct loadparm_context *);
-
-const char *lp_servicename(const struct loadparm_service *service);
-const char *lp_pathname(struct loadparm_service *, struct loadparm_service *);
-const char **lp_hostsallow(struct loadparm_service *, struct loadparm_service *);
-const char **lp_hostsdeny(struct loadparm_service *, struct loadparm_service *);
-const char *lp_comment(struct loadparm_service *, struct loadparm_service *);
-const char *lp_fstype(struct loadparm_service *, struct loadparm_service *);
-const char **lp_ntvfs_handler(struct loadparm_service *, struct loadparm_service *);
-bool lp_msdfs_root(struct loadparm_service *, struct loadparm_service *);
-bool lp_browseable(struct loadparm_service *, struct loadparm_service *);
-bool lp_readonly(struct loadparm_service *, struct loadparm_service *);
-bool lp_print_ok(struct loadparm_service *, struct loadparm_service *);
-bool lp_map_hidden(struct loadparm_service *, struct loadparm_service *);
-bool lp_map_archive(struct loadparm_service *, struct loadparm_service *);
-bool lp_strict_locking(struct loadparm_service *, struct loadparm_service *);
-bool lp_oplocks(struct loadparm_service *, struct loadparm_service *);
-bool lp_strict_sync(struct loadparm_service *, struct loadparm_service *);
-bool lp_ci_filesystem(struct loadparm_service *, struct loadparm_service *);
-bool lp_map_system(struct loadparm_service *, struct loadparm_service *);
-int lp_max_connections(struct loadparm_service *, struct loadparm_service *);
-int lp_csc_policy(struct loadparm_service *, struct loadparm_service *);
-int lp_create_mask(struct loadparm_service *, struct loadparm_service *);
-int lp_force_create_mode(struct loadparm_service *, struct loadparm_service *);
-int lp_dir_mask(struct loadparm_service *, struct loadparm_service *);
-int lp_force_dir_mode(struct loadparm_service *, struct loadparm_service *);
-int lp_server_signing(struct loadparm_context *);
-int lp_client_signing(struct loadparm_context *);
-const char *lp_ntp_signd_socket_directory(struct loadparm_context *);
-
-
-const char *lp_get_parametric(struct loadparm_context *lp_ctx,
+struct loadparm_service *lpcfg_default_service(struct loadparm_context *lp_ctx);
+struct parm_struct *lpcfg_parm_table(void);
+
+
+#define DECL_GLOBAL_STRING(fn_name) \
+ const char *lpcfg_ ## fn_name(struct loadparm_context *lp_ctx); \
+ const char *lp_ ## fn_name(void)
+
+#define DECL_GLOBAL_CONST_STRING(fn_name) \
+ const char *lpcfg_ ## fn_name(struct loadparm_context *lp_ctx); \
+ const char *lp_ ## fn_name(void)
+
+#define DECL_GLOBAL_LIST(fn_name) \
+ const char **lpcfg_ ## fn_name(struct loadparm_context *lp_ctx); \
+ const char **lp_ ## fn_name(void)
+
+#define DECL_GLOBAL_BOOL(fn_name) \
+ bool lpcfg_ ## fn_name(struct loadparm_context *lp_ctx); \
+ bool lp_ ## fn_name(void)
+
+#define DECL_GLOBAL_INTEGER(fn_name) \
+ int lpcfg_ ## fn_name(struct loadparm_context *lp_ctx); \
+ int lp_ ## fn_name(void)
+
+#define DECL_LOCAL_STRING(fn_name) \
+ const char *lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault); \
+ const char *lp_ ## fn_name(int i)
+
+#define DECL_LOCAL_LIST(fn_name) \
+ const char **lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault); \
+ const char **lp_ ## fn_name(int i)
+
+#define DECL_LOCAL_BOOL(fn_name) \
+ bool lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault); \
+ bool lp_ ## fn_name(int i)
+
+#define DECL_LOCAL_INTEGER(fn_name) \
+ int lpcfg_ ## fn_name(struct loadparm_service *service, struct loadparm_service *sDefault); \
+ int lp_ ## fn_name(int i)
+
+
+DECL_GLOBAL_INTEGER(server_role);
+DECL_GLOBAL_INTEGER(sid_generator);
+DECL_GLOBAL_LIST(smb_ports);
+DECL_GLOBAL_INTEGER(nbt_port);
+DECL_GLOBAL_INTEGER(dgram_port);
+DECL_GLOBAL_INTEGER(cldap_port);
+DECL_GLOBAL_INTEGER(krb5_port);
+DECL_GLOBAL_INTEGER(kpasswd_port);
+DECL_GLOBAL_INTEGER(web_port);
+DECL_GLOBAL_BOOL(tls_enabled);
+DECL_GLOBAL_STRING(share_backend);
+DECL_GLOBAL_STRING(sam_url);
+DECL_GLOBAL_STRING(idmap_url);
+DECL_GLOBAL_STRING(secrets_url);
+DECL_GLOBAL_STRING(spoolss_url);
+DECL_GLOBAL_STRING(wins_config_url);
+DECL_GLOBAL_STRING(wins_url);
+DECL_GLOBAL_CONST_STRING(winbind_separator);
+DECL_GLOBAL_CONST_STRING(winbindd_socket_directory);
+DECL_GLOBAL_CONST_STRING(winbindd_privileged_socket_directory);
+DECL_GLOBAL_CONST_STRING(template_shell);
+DECL_GLOBAL_CONST_STRING(template_homedir);
+DECL_GLOBAL_BOOL(winbind_sealed_pipes);
+DECL_GLOBAL_BOOL(idmap_trusted_only);
+DECL_GLOBAL_STRING(private_dir);
+DECL_GLOBAL_STRING(serverstring);
+DECL_GLOBAL_STRING(lockdir);
+DECL_GLOBAL_STRING(modulesdir);
+DECL_GLOBAL_STRING(setupdir);
+DECL_GLOBAL_STRING(ncalrpc_dir);
+DECL_GLOBAL_STRING(dos_charset);
+DECL_GLOBAL_STRING(unix_charset);
+DECL_GLOBAL_STRING(display_charset);
+DECL_GLOBAL_STRING(piddir);
+DECL_GLOBAL_LIST(rndc_command);
+DECL_GLOBAL_LIST(dns_update_command);
+DECL_GLOBAL_LIST(spn_update_command);
+DECL_GLOBAL_STRING(nsupdate_command);
+DECL_GLOBAL_LIST(dcerpc_endpoint_servers);
+DECL_GLOBAL_LIST(server_services);
+DECL_GLOBAL_STRING(ntptr_providor);
+DECL_GLOBAL_STRING(auto_services);
+DECL_GLOBAL_STRING(passwd_chat);
+DECL_GLOBAL_LIST(passwordserver);
+DECL_GLOBAL_LIST(name_resolve_order);
+DECL_GLOBAL_STRING(realm);
+DECL_GLOBAL_STRING(dnsdomain);
+DECL_GLOBAL_STRING(socket_options);
+DECL_GLOBAL_STRING(workgroup);
+DECL_GLOBAL_STRING(netbios_name);
+DECL_GLOBAL_STRING(netbios_scope);
+DECL_GLOBAL_LIST(wins_server_list);
+DECL_GLOBAL_LIST(interfaces);
+DECL_GLOBAL_STRING(socket_address);
+DECL_GLOBAL_LIST(netbios_aliases);
+DECL_GLOBAL_BOOL(disable_netbios);
+DECL_GLOBAL_BOOL(wins_support);
+DECL_GLOBAL_BOOL(wins_dns_proxy);
+DECL_GLOBAL_STRING(wins_hook);
+DECL_GLOBAL_BOOL(local_master);
+DECL_GLOBAL_BOOL(readraw);
+DECL_GLOBAL_BOOL(large_readwrite);
+DECL_GLOBAL_BOOL(writeraw);
+DECL_GLOBAL_BOOL(null_passwords);
+DECL_GLOBAL_BOOL(obey_pam_restrictions);
+DECL_GLOBAL_BOOL(encrypted_passwords);
+DECL_GLOBAL_BOOL(time_server);
+DECL_GLOBAL_BOOL(bind_interfaces_only);
+DECL_GLOBAL_BOOL(unicode);
+DECL_GLOBAL_BOOL(nt_status_support);
+DECL_GLOBAL_BOOL(lanman_auth);
+DECL_GLOBAL_BOOL(ntlm_auth);
+DECL_GLOBAL_BOOL(client_plaintext_auth);
+DECL_GLOBAL_BOOL(client_lanman_auth);
+DECL_GLOBAL_BOOL(client_ntlmv2_auth);
+DECL_GLOBAL_BOOL(client_use_spnego_principal);
+DECL_GLOBAL_BOOL(host_msdfs);
+DECL_GLOBAL_BOOL(unix_extensions);
+DECL_GLOBAL_BOOL(use_spnego);
+DECL_GLOBAL_BOOL(rpc_big_endian);
+DECL_GLOBAL_INTEGER(max_wins_ttl);
+DECL_GLOBAL_INTEGER(min_wins_ttl);
+DECL_GLOBAL_INTEGER(maxmux);
+DECL_GLOBAL_INTEGER(max_xmit);
+DECL_GLOBAL_INTEGER(passwordlevel);
+DECL_GLOBAL_INTEGER(srv_maxprotocol);
+DECL_GLOBAL_INTEGER(srv_minprotocol);
+DECL_GLOBAL_INTEGER(cli_maxprotocol);
+DECL_GLOBAL_INTEGER(cli_minprotocol);
+DECL_GLOBAL_INTEGER(security);
+DECL_GLOBAL_BOOL(paranoid_server_security);
+DECL_GLOBAL_INTEGER(announce_as);
+DECL_LOCAL_STRING(pathname);
+DECL_LOCAL_LIST(hostsallow);
+DECL_LOCAL_LIST(hostsdeny);
+DECL_LOCAL_STRING(comment);
+DECL_LOCAL_STRING(fstype);
+DECL_LOCAL_LIST(ntvfs_handler);
+DECL_LOCAL_BOOL(msdfs_root);
+DECL_LOCAL_BOOL(browseable);
+DECL_LOCAL_BOOL(readonly);
+DECL_LOCAL_BOOL(print_ok);
+DECL_LOCAL_BOOL(map_hidden);
+DECL_LOCAL_BOOL(map_archive);
+DECL_LOCAL_BOOL(strict_locking);
+DECL_LOCAL_BOOL(oplocks);
+DECL_LOCAL_BOOL(strict_sync);
+DECL_LOCAL_BOOL(ci_filesystem);
+DECL_LOCAL_BOOL(map_system);
+DECL_LOCAL_INTEGER(max_connections);
+DECL_LOCAL_INTEGER(csc_policy);
+DECL_LOCAL_INTEGER(create_mask);
+DECL_LOCAL_INTEGER(force_create_mode);
+DECL_LOCAL_INTEGER(dir_mask);
+DECL_LOCAL_INTEGER(force_dir_mode);
+DECL_GLOBAL_INTEGER(server_signing);
+DECL_GLOBAL_INTEGER(client_signing);
+DECL_GLOBAL_CONST_STRING(ntp_signd_socket_directory);
+
+
+char *lpcfg_tls_keyfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
+char *lpcfg_tls_certfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
+char *lpcfg_tls_cafile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
+char *lpcfg_tls_dhpfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
+char *lpcfg_tls_crlfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
+
+const char *lpcfg_servicename(const struct loadparm_service *service);
+
+
+const char *lpcfg_get_parametric(struct loadparm_context *lp_ctx,
struct loadparm_service *service,
const char *type, const char *option);
-const char *lp_parm_string(struct loadparm_context *lp_ctx,
+const char *lpcfg_parm_string(struct loadparm_context *lp_ctx,
struct loadparm_service *service, const char *type,
const char *option);
-const char **lp_parm_string_list(TALLOC_CTX *mem_ctx,
+const char **lpcfg_parm_string_list(TALLOC_CTX *mem_ctx,
struct loadparm_context *lp_ctx,
struct loadparm_service *service,
const char *type,
const char *option, const char *separator);
-int lp_parm_int(struct loadparm_context *lp_ctx,
+int lpcfg_parm_int(struct loadparm_context *lp_ctx,
struct loadparm_service *service, const char *type,
const char *option, int default_v);
-int lp_parm_bytes(struct loadparm_context *lp_ctx,
+int lpcfg_parm_bytes(struct loadparm_context *lp_ctx,
struct loadparm_service *service, const char *type,
const char *option, int default_v);
-unsigned long lp_parm_ulong(struct loadparm_context *lp_ctx,
+unsigned long lpcfg_parm_ulong(struct loadparm_context *lp_ctx,
struct loadparm_service *service, const char *type,
const char *option, unsigned long default_v);
-double lp_parm_double(struct loadparm_context *lp_ctx,
+double lpcfg_parm_double(struct loadparm_context *lp_ctx,
struct loadparm_service *service, const char *type,
const char *option, double default_v);
-bool lp_parm_bool(struct loadparm_context *lp_ctx,
- struct loadparm_service *service, const char *type,
- const char *option, bool default_v);
-struct loadparm_service *lp_add_service(struct loadparm_context *lp_ctx,
+bool lpcfg_parm_bool(struct loadparm_context *lp_ctx,
+ struct loadparm_service *service, const char *type,
+ const char *option, bool default_v);
+struct loadparm_service *lpcfg_add_service(struct loadparm_context *lp_ctx,
const struct loadparm_service *pservice,
const char *name);
-bool lp_add_home(struct loadparm_context *lp_ctx,
+bool lpcfg_add_home(struct loadparm_context *lp_ctx,
const char *pszHomename,
struct loadparm_service *default_service,
const char *user, const char *pszHomedir);
-bool lp_add_printer(struct loadparm_context *lp_ctx,
+bool lpcfg_add_printer(struct loadparm_context *lp_ctx,
const char *pszPrintername,
struct loadparm_service *default_service);
-struct parm_struct *lp_parm_struct(const char *name);
-void *lp_parm_ptr(struct loadparm_context *lp_ctx,
+struct parm_struct *lpcfg_parm_struct(const char *name);
+void *lpcfg_parm_ptr(struct loadparm_context *lp_ctx,
struct loadparm_service *service, struct parm_struct *parm);
-bool lp_file_list_changed(struct loadparm_context *lp_ctx);
+bool lpcfg_file_list_changed(struct loadparm_context *lp_ctx);
-bool lp_do_global_parameter(struct loadparm_context *lp_ctx,
+bool lpcfg_do_global_parameter(struct loadparm_context *lp_ctx,
const char *pszParmName, const char *pszParmValue);
-bool lp_do_service_parameter(struct loadparm_context *lp_ctx,
+bool lpcfg_do_service_parameter(struct loadparm_context *lp_ctx,
struct loadparm_service *service,
const char *pszParmName, const char *pszParmValue);
/**
* Process a parameter.
*/
-bool lp_do_global_parameter_var(struct loadparm_context *lp_ctx,
+bool lpcfg_do_global_parameter_var(struct loadparm_context *lp_ctx,
const char *pszParmName, const char *fmt, ...);
-bool lp_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
+bool lpcfg_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
const char *pszParmValue);
-bool lp_set_option(struct loadparm_context *lp_ctx, const char *option);
+bool lpcfg_set_option(struct loadparm_context *lp_ctx, const char *option);
/**
* Display the contents of a single services record.
*/
-bool lp_dump_a_parameter(struct loadparm_context *lp_ctx,
+bool lpcfg_dump_a_parameter(struct loadparm_context *lp_ctx,
struct loadparm_service *service,
const char *parm_name, FILE * f);
* Return info about the next service in a service. snum==-1 gives the globals.
* Return NULL when out of parameters.
*/
-struct parm_struct *lp_next_parameter(struct loadparm_context *lp_ctx, int snum, int *i,
+struct parm_struct *lpcfg_next_parameter(struct loadparm_context *lp_ctx, int snum, int *i,
int allparameters);
/**
* Unload unused services.
*/
-void lp_killunused(struct loadparm_context *lp_ctx,
+void lpcfg_killunused(struct loadparm_context *lp_ctx,
struct smbsrv_connection *smb,
bool (*snumused) (struct smbsrv_connection *, int));
* Initialise the global parameter structure.
*/
struct loadparm_context *loadparm_init(TALLOC_CTX *mem_ctx);
-const char *lp_configfile(struct loadparm_context *lp_ctx);
-bool lp_load_default(struct loadparm_context *lp_ctx);
+const char *lpcfg_configfile(struct loadparm_context *lp_ctx);
+bool lpcfg_load_default(struct loadparm_context *lp_ctx);
const char *lp_default_path(void);
/**
*
* Return True on success, False on failure.
*/
-bool lp_load(struct loadparm_context *lp_ctx, const char *filename);
+bool lpcfg_load(struct loadparm_context *lp_ctx, const char *filename);
/**
* Return the max number of services.
*/
-int lp_numservices(struct loadparm_context *lp_ctx);
+int lpcfg_numservices(struct loadparm_context *lp_ctx);
/**
* Display the contents of the services array in human-readable form.
*/
-void lp_dump(struct loadparm_context *lp_ctx, FILE *f, bool show_defaults,
+void lpcfg_dump(struct loadparm_context *lp_ctx, FILE *f, bool show_defaults,
int maxtoprint);
/**
* Display the contents of one service in human-readable form.
*/
-void lp_dump_one(FILE *f, bool show_defaults, struct loadparm_service *service, struct loadparm_service *sDefault);
-struct loadparm_service *lp_servicebynum(struct loadparm_context *lp_ctx,
+void lpcfg_dump_one(FILE *f, bool show_defaults, struct loadparm_service *service, struct loadparm_service *sDefault);
+struct loadparm_service *lpcfg_servicebynum(struct loadparm_context *lp_ctx,
int snum);
-struct loadparm_service *lp_service(struct loadparm_context *lp_ctx,
+struct loadparm_service *lpcfg_service(struct loadparm_context *lp_ctx,
const char *service_name);
/**
/**
* If we are PDC then prefer us as DMB
*/
-const char *lp_printername(struct loadparm_service *service, struct loadparm_service *sDefault);
+const char *lpcfg_printername(struct loadparm_service *service, struct loadparm_service *sDefault);
/**
* Return the max print jobs per queue.
*/
-int lp_maxprintjobs(struct loadparm_service *service, struct loadparm_service *sDefault);
-struct smb_iconv_convenience *lp_iconv_convenience(struct loadparm_context *lp_ctx);
-void lp_smbcli_options(struct loadparm_context *lp_ctx,
+int lpcfg_maxprintjobs(struct loadparm_service *service, struct loadparm_service *sDefault);
+struct smb_iconv_convenience *lpcfg_iconv_convenience(struct loadparm_context *lp_ctx);
+void lpcfg_smbcli_options(struct loadparm_context *lp_ctx,
struct smbcli_options *options);
-void lp_smbcli_session_options(struct loadparm_context *lp_ctx,
+void lpcfg_smbcli_session_options(struct loadparm_context *lp_ctx,
struct smbcli_session_options *options);
-struct dcerpc_server_info *lp_dcerpc_server_info(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx);
-struct gensec_settings *lp_gensec_settings(TALLOC_CTX *, struct loadparm_context *);
+struct dcerpc_server_info *lpcfg_dcerpc_server_info(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx);
+struct gensec_settings *lpcfg_gensec_settings(TALLOC_CTX *, struct loadparm_context *);
/* The following definitions come from param/generic.c */
* @file
* @brief Misc utility functions
*/
-bool lp_is_mydomain(struct loadparm_context *lp_ctx,
+bool lpcfg_is_mydomain(struct loadparm_context *lp_ctx,
const char *domain);
-bool lp_is_my_domain_or_realm(struct loadparm_context *lp_ctx,
+bool lpcfg_is_my_domain_or_realm(struct loadparm_context *lp_ctx,
const char *domain);
/**
see if a string matches either our primary or one of our secondary
netbios aliases. do a case insensitive match
*/
-bool lp_is_myname(struct loadparm_context *lp_ctx, const char *name);
+bool lpcfg_is_myname(struct loadparm_context *lp_ctx, const char *name);
/**
A useful function for returning a path in the Samba lock directory.
path itself
*/
char *smbd_tmp_path(TALLOC_CTX *mem_ctx,
- struct loadparm_context *lp_ctx,
+ struct loadparm_context *lp_ctx,
const char *name);
/**
* Will return an array of function pointers to initialization functions
*/
init_module_fn *load_samba_modules(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx, const char *subsystem);
-const char *lp_messaging_path(TALLOC_CTX *mem_ctx,
+const char *lpcfg_messaging_path(TALLOC_CTX *mem_ctx,
struct loadparm_context *lp_ctx);
struct smb_iconv_convenience *smb_iconv_convenience_reinit_lp(TALLOC_CTX *mem_ctx,
struct loadparm_context *lp_ctx,
struct smb_iconv_convenience *old_ic);
-const char *lp_sam_name(struct loadparm_context *lp_ctx);
+const char *lpcfg_sam_name(struct loadparm_context *lp_ctx);
/* The following definitions come from lib/version.c */
settings->targetdir));
parameters = PyDict_New();
- configfile = lp_configfile(lp_ctx);
+ configfile = lpcfg_configfile(lp_ctx);
if (configfile != NULL) {
PyDict_SetItemString(parameters, "smbconf",
PyString_FromString(configfile));
result->domaindn = talloc_strdup(mem_ctx, PyString_AsString(PyObject_GetAttrString(py_result, "domaindn")));
/* FIXME paths */
- result->lp_ctx = lp_from_py_object(result, PyObject_GetAttrString(py_result, "lp"));
+ result->lp_ctx = lpcfg_from_py_object(result, PyObject_GetAttrString(py_result, "lp"));
result->samdb = PyLdb_AsLdbContext(PyObject_GetAttrString(py_result, "samdb"));
return NT_STATUS_OK;
parameters = PyDict_New();
- setupdir = lp_setupdir(lp_ctx);
+ setupdir = lpcfg_setupdir(lp_ctx);
PyDict_SetItemString(parameters, "setup_dir",
PyString_FromString(setupdir));
if (override_prefixmap) {
strwicmp(service_name, GLOBAL_NAME2)) {
struct loadparm_service *service;
/* its a share parameter */
- service = lp_service(lp_ctx, service_name);
+ service = lpcfg_service(lp_ctx, service_name);
if (service == NULL) {
return NULL;
}
if (strchr(param_name, ':')) {
/* its a parametric option on a share */
- const char *type = talloc_strndup(lp_ctx, param_name,
+ const char *type = talloc_strndup(lp_ctx, param_name,
strcspn(param_name, ":"));
const char *option = strchr(param_name, ':') + 1;
const char *value;
if (type == NULL || option == NULL) {
return NULL;
}
- value = lp_get_parametric(lp_ctx, service, type, option);
+ value = lpcfg_get_parametric(lp_ctx, service, type, option);
if (value == NULL) {
return NULL;
}
return PyString_FromString(value);
}
- parm = lp_parm_struct(param_name);
+ parm = lpcfg_parm_struct(param_name);
if (parm == NULL || parm->pclass == P_GLOBAL) {
return NULL;
}
- parm_ptr = lp_parm_ptr(lp_ctx, service, parm);
+ parm_ptr = lpcfg_parm_ptr(lp_ctx, service, parm);
} else if (strchr(param_name, ':')) {
/* its a global parametric option */
- const char *type = talloc_strndup(lp_ctx,
+ const char *type = talloc_strndup(lp_ctx,
param_name, strcspn(param_name, ":"));
const char *option = strchr(param_name, ':') + 1;
const char *value;
if (type == NULL || option == NULL) {
return NULL;
}
- value = lp_get_parametric(lp_ctx, NULL, type, option);
+ value = lpcfg_get_parametric(lp_ctx, NULL, type, option);
if (value == NULL)
return NULL;
return PyString_FromString(value);
} else {
/* its a global parameter */
- parm = lp_parm_struct(param_name);
+ parm = lpcfg_parm_struct(param_name);
if (parm == NULL) {
return NULL;
}
- parm_ptr = lp_parm_ptr(lp_ctx, NULL, parm);
+ parm_ptr = lpcfg_parm_ptr(lp_ctx, NULL, parm);
}
if (parm == NULL || parm_ptr == NULL) {
if (!PyArg_ParseTuple(args, "s", &filename))
return NULL;
- ret = lp_load(PyLoadparmContext_AsLoadparmContext(self), filename);
+ ret = lpcfg_load(PyLoadparmContext_AsLoadparmContext(self), filename);
if (!ret) {
PyErr_Format(PyExc_RuntimeError, "Unable to load file %s", filename);
static PyObject *py_lp_ctx_load_default(py_talloc_Object *self)
{
bool ret;
- ret = lp_load_default(PyLoadparmContext_AsLoadparmContext(self));
+ ret = lpcfg_load_default(PyLoadparmContext_AsLoadparmContext(self));
if (!ret) {
PyErr_SetString(PyExc_RuntimeError, "Unable to load default file");
if (!PyArg_ParseTuple(args, "s", &name))
return NULL;
- return PyBool_FromLong(lp_is_myname(PyLoadparmContext_AsLoadparmContext(self), name));
+ return PyBool_FromLong(lpcfg_is_myname(PyLoadparmContext_AsLoadparmContext(self), name));
}
static PyObject *py_lp_ctx_is_mydomain(py_talloc_Object *self, PyObject *args)
if (!PyArg_ParseTuple(args, "s", &name))
return NULL;
- return PyBool_FromLong(lp_is_mydomain(PyLoadparmContext_AsLoadparmContext(self), name));
+ return PyBool_FromLong(lpcfg_is_mydomain(PyLoadparmContext_AsLoadparmContext(self), name));
}
static PyObject *py_lp_ctx_set(py_talloc_Object *self, PyObject *args)
if (!PyArg_ParseTuple(args, "ss", &name, &value))
return NULL;
- ret = lp_set_cmdline(PyLoadparmContext_AsLoadparmContext(self), name, value);
+ ret = lpcfg_set_cmdline(PyLoadparmContext_AsLoadparmContext(self), name, value);
if (!ret) {
PyErr_SetString(PyExc_RuntimeError, "Unable to set parameter");
return NULL;
struct loadparm_context *lp_ctx = PyLoadparmContext_AsLoadparmContext(self);
PyObject *ret;
int i;
- ret = PyList_New(lp_numservices(lp_ctx));
- for (i = 0; i < lp_numservices(lp_ctx); i++) {
- struct loadparm_service *service = lp_servicebynum(lp_ctx, i);
+ ret = PyList_New(lpcfg_numservices(lp_ctx));
+ for (i = 0; i < lpcfg_numservices(lp_ctx); i++) {
+ struct loadparm_service *service = lpcfg_servicebynum(lp_ctx, i);
if (service != NULL) {
- PyList_SetItem(ret, i, PyString_FromString(lp_servicename(service)));
+ PyList_SetItem(ret, i, PyString_FromString(lpcfg_servicename(service)));
}
}
return ret;
return NULL;
}
- lp_dump(lp_ctx, f, show_defaults, lp_numservices(lp_ctx));
+ lpcfg_dump(lp_ctx, f, show_defaults, lpcfg_numservices(lp_ctx));
Py_RETURN_NONE;
}
static PyObject *py_lp_ctx_default_service(py_talloc_Object *self, void *closure)
{
- return PyLoadparmService_FromService(lp_default_service(PyLoadparmContext_AsLoadparmContext(self)));
+ return PyLoadparmService_FromService(lpcfg_default_service(PyLoadparmContext_AsLoadparmContext(self)));
}
static PyObject *py_lp_ctx_config_file(py_talloc_Object *self, void *closure)
{
- const char *configfile = lp_configfile(PyLoadparmContext_AsLoadparmContext(self));
+ const char *configfile = lpcfg_configfile(PyLoadparmContext_AsLoadparmContext(self));
if (configfile == NULL)
Py_RETURN_NONE;
else
static Py_ssize_t py_lp_ctx_len(py_talloc_Object *self)
{
- return lp_numservices(PyLoadparmContext_AsLoadparmContext(self));
+ return lpcfg_numservices(PyLoadparmContext_AsLoadparmContext(self));
}
static PyObject *py_lp_ctx_getitem(py_talloc_Object *self, PyObject *name)
PyErr_SetString(PyExc_TypeError, "Only string subscripts are supported");
return NULL;
}
- service = lp_service(PyLoadparmContext_AsLoadparmContext(self), PyString_AsString(name));
+ service = lpcfg_service(PyLoadparmContext_AsLoadparmContext(self), PyString_AsString(name));
if (service == NULL) {
PyErr_SetString(PyExc_KeyError, "No such section");
return NULL;
default_service = PyLoadparmService_AsLoadparmService(py_default_service);
- lp_dump_one(f, show_defaults, service, default_service);
+ lpcfg_dump_one(f, show_defaults, service, default_service);
Py_RETURN_NONE;
}
#include "param/param.h"
-_PUBLIC_ struct loadparm_context *lp_from_py_object(TALLOC_CTX *mem_ctx, PyObject *py_obj);
+_PUBLIC_ struct loadparm_context *lpcfg_from_py_object(TALLOC_CTX *mem_ctx, PyObject *py_obj);
_PUBLIC_ struct loadparm_context *py_default_loadparm_context(TALLOC_CTX *mem_ctx);
#endif /* _PYPARAM_H_ */
#define PyLoadparmContext_AsLoadparmContext(obj) py_talloc_get_type(obj, struct loadparm_context)
-_PUBLIC_ struct loadparm_context *lp_from_py_object(TALLOC_CTX *mem_ctx, PyObject *py_obj)
+_PUBLIC_ struct loadparm_context *lpcfg_from_py_object(TALLOC_CTX *mem_ctx, PyObject *py_obj)
{
struct loadparm_context *lp_ctx;
if (PyString_Check(py_obj)) {
lp_ctx = loadparm_init(mem_ctx);
- if (!lp_load(lp_ctx, PyString_AsString(py_obj))) {
+ if (!lpcfg_load(lp_ctx, PyString_AsString(py_obj))) {
talloc_free(lp_ctx);
PyErr_Format(PyExc_RuntimeError, "Unable to load %s",
PyString_AsString(py_obj));
if (py_obj == Py_None) {
lp_ctx = loadparm_init(mem_ctx);
/* We're not checking that loading the file succeeded *on purpose */
- lp_load_default(lp_ctx);
+ lpcfg_load_default(lp_ctx);
return lp_ctx;
}
{
struct loadparm_context *ret;
ret = loadparm_init(mem_ctx);
- if (!lp_load_default(ret))
+ if (!lpcfg_load_default(ret))
return NULL;
return ret;
}
struct tevent_context *ev_ctx,
struct loadparm_context *lp_ctx)
{
- return ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx, lp_secrets_url(lp_ctx),
+ return ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx, lpcfg_secrets_url(lp_ctx),
NULL, NULL, 0);
}
{
struct loadparm_service *s = talloc_get_type(scfg->opaque,
struct loadparm_service);
- struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data,
+ struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data,
struct loadparm_context);
char *parm, *val;
const char *ret;
*val = '\0';
val++;
- ret = lp_parm_string(lp_ctx, s, parm, val);
+ ret = lpcfg_parm_string(lp_ctx, s, parm, val);
if (!ret) {
ret = defval;
}
}
if (strcmp(opt_name, SHARE_PATH) == 0) {
- return lp_pathname(s, lp_default_service(lp_ctx));
+ return lpcfg_pathname(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_COMMENT) == 0) {
- return lp_comment(s, lp_default_service(lp_ctx));
+ return lpcfg_comment(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_VOLUME) == 0) {
- return volume_label(s, lp_default_service(lp_ctx));
+ return volume_label(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_TYPE) == 0) {
- if (lp_print_ok(s, lp_default_service(lp_ctx))) {
+ if (lpcfg_print_ok(s, lpcfg_default_service(lp_ctx))) {
return "PRINTER";
}
- if (strcmp("NTFS", lp_fstype(s, lp_default_service(lp_ctx))) == 0) {
+ if (strcmp("NTFS", lpcfg_fstype(s, lpcfg_default_service(lp_ctx))) == 0) {
return "DISK";
}
- return lp_fstype(s, lp_default_service(lp_ctx));
+ return lpcfg_fstype(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_PASSWORD) == 0) {
{
struct loadparm_service *s = talloc_get_type(scfg->opaque,
struct loadparm_service);
- struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data,
+ struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data,
struct loadparm_context);
char *parm, *val;
int ret;
*val = '\0';
val++;
- ret = lp_parm_int(lp_ctx, s, parm, val, defval);
+ ret = lpcfg_parm_int(lp_ctx, s, parm, val, defval);
if (!ret) {
ret = defval;
}
}
if (strcmp(opt_name, SHARE_CSC_POLICY) == 0) {
- return lp_csc_policy(s, lp_default_service(lp_ctx));
+ return lpcfg_csc_policy(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_MAX_CONNECTIONS) == 0) {
- return lp_max_connections(s, lp_default_service(lp_ctx));
+ return lpcfg_max_connections(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_CREATE_MASK) == 0) {
- return lp_create_mask(s, lp_default_service(lp_ctx));
+ return lpcfg_create_mask(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_DIR_MASK) == 0) {
- return lp_dir_mask(s, lp_default_service(lp_ctx));
+ return lpcfg_dir_mask(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_FORCE_DIR_MODE) == 0) {
- return lp_force_dir_mode(s, lp_default_service(lp_ctx));
+ return lpcfg_force_dir_mode(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_FORCE_CREATE_MODE) == 0) {
- return lp_force_create_mode(s, lp_default_service(lp_ctx));
+ return lpcfg_force_create_mode(s, lpcfg_default_service(lp_ctx));
}
{
struct loadparm_service *s = talloc_get_type(scfg->opaque,
struct loadparm_service);
- struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data,
+ struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data,
struct loadparm_context);
char *parm, *val;
bool ret;
*val = '\0';
val++;
- ret = lp_parm_bool(lp_ctx, s, parm, val, defval);
+ ret = lpcfg_parm_bool(lp_ctx, s, parm, val, defval);
talloc_free(parm);
return ret;
}
}
if (strcmp(opt_name, SHARE_BROWSEABLE) == 0) {
- return lp_browseable(s, lp_default_service(lp_ctx));
+ return lpcfg_browseable(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_READONLY) == 0) {
- return lp_readonly(s, lp_default_service(lp_ctx));
+ return lpcfg_readonly(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_MAP_SYSTEM) == 0) {
- return lp_map_system(s, lp_default_service(lp_ctx));
+ return lpcfg_map_system(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_MAP_HIDDEN) == 0) {
- return lp_map_hidden(s, lp_default_service(lp_ctx));
+ return lpcfg_map_hidden(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_MAP_ARCHIVE) == 0) {
- return lp_map_archive(s, lp_default_service(lp_ctx));
+ return lpcfg_map_archive(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_STRICT_LOCKING) == 0) {
- return lp_strict_locking(s, lp_default_service(lp_ctx));
+ return lpcfg_strict_locking(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_OPLOCKS) == 0) {
- return lp_oplocks(s, lp_default_service(lp_ctx));
+ return lpcfg_oplocks(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_STRICT_SYNC) == 0) {
- return lp_strict_sync(s, lp_default_service(lp_ctx));
+ return lpcfg_strict_sync(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_MSDFS_ROOT) == 0) {
- return lp_msdfs_root(s, lp_default_service(lp_ctx));
+ return lpcfg_msdfs_root(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_CI_FILESYSTEM) == 0) {
- return lp_ci_filesystem(s, lp_default_service(lp_ctx));
+ return lpcfg_ci_filesystem(s, lpcfg_default_service(lp_ctx));
}
DEBUG(0,("request for unknown share bool option '%s'\n",
{
struct loadparm_service *s = talloc_get_type(scfg->opaque,
struct loadparm_service);
- struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data,
+ struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data,
struct loadparm_context);
char *parm, *val;
const char **ret;
*val = '\0';
val++;
- ret = lp_parm_string_list(mem_ctx, lp_ctx, s, parm, val, ",;");
+ ret = lpcfg_parm_string_list(mem_ctx, lp_ctx, s, parm, val, ",;");
talloc_free(parm);
return ret;
}
if (strcmp(opt_name, SHARE_HOSTS_ALLOW) == 0) {
- return lp_hostsallow(s, lp_default_service(lp_ctx));
+ return lpcfg_hostsallow(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_HOSTS_DENY) == 0) {
- return lp_hostsdeny(s, lp_default_service(lp_ctx));
+ return lpcfg_hostsdeny(s, lpcfg_default_service(lp_ctx));
}
if (strcmp(opt_name, SHARE_NTVFS_HANDLER) == 0) {
- return lp_ntvfs_handler(s, lp_default_service(lp_ctx));
+ return lpcfg_ntvfs_handler(s, lpcfg_default_service(lp_ctx));
}
DEBUG(0,("request for unknown share list option '%s'\n",
int num_services;
const char **n;
- num_services = lp_numservices((struct loadparm_context *)ctx->priv_data);
+ num_services = lpcfg_numservices((struct loadparm_context *)ctx->priv_data);
n = talloc_array(mem_ctx, const char *, num_services);
if (!n) {
}
for (i = 0; i < num_services; i++) {
- n[i] = talloc_strdup(n, lp_servicename(lp_servicebynum((struct loadparm_context *)ctx->priv_data, i)));
+ n[i] = talloc_strdup(n, lpcfg_servicename(lpcfg_servicebynum((struct loadparm_context *)ctx->priv_data, i)));
if (!n[i]) {
DEBUG(0,("ERROR: Out of memory!\n"));
talloc_free(n);
struct share_config *s;
struct loadparm_service *service;
- service = lp_service((struct loadparm_context *)ctx->priv_data, name);
+ service = lpcfg_service((struct loadparm_context *)ctx->priv_data, name);
if (service == NULL) {
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
return NT_STATUS_NO_MEMORY;
}
- s->name = talloc_strdup(s, lp_servicename(service));
+ s->name = talloc_strdup(s, lpcfg_servicename(service));
if (!s->name) {
DEBUG(0,("ERROR: Out of memory!\n"));
talloc_free(s);
return NT_STATUS_NO_MEMORY;
}
- sdb = ldb_wrap_connect(*ctx, ev_ctx, lp_ctx,
+ sdb = ldb_wrap_connect(*ctx, ev_ctx, lp_ctx,
private_path(*ctx, lp_ctx, "share.ldb"),
system_session(lp_ctx),
NULL, 0);
static bool test_set_option(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- torture_assert(tctx, lp_set_option(lp_ctx, "workgroup=werkgroep"), "lp_set_option failed");
- torture_assert_str_equal(tctx, "WERKGROEP", lp_workgroup(lp_ctx), "workgroup");
+ torture_assert(tctx, lpcfg_set_option(lp_ctx, "workgroup=werkgroep"), "lpcfg_set_option failed");
+ torture_assert_str_equal(tctx, "WERKGROEP", lpcfg_workgroup(lp_ctx), "workgroup");
return true;
}
static bool test_set_cmdline(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- torture_assert(tctx, lp_set_cmdline(lp_ctx, "workgroup", "werkgroep"), "lp_set_cmdline failed");
- torture_assert(tctx, lp_do_global_parameter(lp_ctx, "workgroup", "barbla"), "lp_set_option failed");
- torture_assert_str_equal(tctx, "WERKGROEP", lp_workgroup(lp_ctx), "workgroup");
+ torture_assert(tctx, lpcfg_set_cmdline(lp_ctx, "workgroup", "werkgroep"), "lpcfg_set_cmdline failed");
+ torture_assert(tctx, lpcfg_do_global_parameter(lp_ctx, "workgroup", "barbla"), "lpcfg_set_option failed");
+ torture_assert_str_equal(tctx, "WERKGROEP", lpcfg_workgroup(lp_ctx), "workgroup");
return true;
}
static bool test_do_global_parameter(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- torture_assert(tctx, lp_do_global_parameter(lp_ctx, "workgroup", "werkgroep42"),
- "lp_set_cmdline failed");
- torture_assert_str_equal(tctx, lp_workgroup(lp_ctx), "WERKGROEP42", "workgroup");
+ torture_assert(tctx, lpcfg_do_global_parameter(lp_ctx, "workgroup", "werkgroep42"),
+ "lpcfg_set_cmdline failed");
+ torture_assert_str_equal(tctx, lpcfg_workgroup(lp_ctx), "WERKGROEP42", "workgroup");
return true;
}
static bool test_do_global_parameter_var(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- torture_assert(tctx, lp_do_global_parameter_var(lp_ctx, "workgroup", "werk%s%d", "groep", 42),
- "lp_set_cmdline failed");
- torture_assert_str_equal(tctx, lp_workgroup(lp_ctx), "WERKGROEP42", "workgroup");
+ torture_assert(tctx, lpcfg_do_global_parameter_var(lp_ctx, "workgroup", "werk%s%d", "groep", 42),
+ "lpcfg_set_cmdline failed");
+ torture_assert_str_equal(tctx, lpcfg_workgroup(lp_ctx), "WERKGROEP42", "workgroup");
return true;
}
static bool test_set_option_invalid(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- torture_assert(tctx, !lp_set_option(lp_ctx, "workgroup"), "lp_set_option succeeded");
+ torture_assert(tctx, !lpcfg_set_option(lp_ctx, "workgroup"), "lpcfg_set_option succeeded");
return true;
}
static bool test_set_option_parametric(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- torture_assert(tctx, lp_set_option(lp_ctx, "some:thing=blaat"), "lp_set_option failed");
- torture_assert_str_equal(tctx, lp_parm_string(lp_ctx, NULL, "some", "thing"), "blaat",
+ torture_assert(tctx, lpcfg_set_option(lp_ctx, "some:thing=blaat"), "lpcfg_set_option failed");
+ torture_assert_str_equal(tctx, lpcfg_parm_string(lp_ctx, NULL, "some", "thing"), "blaat",
"invalid parametric option");
return true;
}
static bool test_lp_parm_double(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- torture_assert(tctx, lp_set_option(lp_ctx, "some:thing=3.4"), "lp_set_option failed");
- torture_assert(tctx, lp_parm_double(lp_ctx, NULL, "some", "thing", 2.0) == 3.4,
+ torture_assert(tctx, lpcfg_set_option(lp_ctx, "some:thing=3.4"), "lpcfg_set_option failed");
+ torture_assert(tctx, lpcfg_parm_double(lp_ctx, NULL, "some", "thing", 2.0) == 3.4,
"invalid parametric option");
- torture_assert(tctx, lp_parm_double(lp_ctx, NULL, "some", "bla", 2.0) == 2.0,
+ torture_assert(tctx, lpcfg_parm_double(lp_ctx, NULL, "some", "bla", 2.0) == 2.0,
"invalid parametric option");
return true;
}
static bool test_lp_parm_bool(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- torture_assert(tctx, lp_set_option(lp_ctx, "some:thing=true"), "lp_set_option failed");
- torture_assert(tctx, lp_parm_bool(lp_ctx, NULL, "some", "thing", false) == true,
+ torture_assert(tctx, lpcfg_set_option(lp_ctx, "some:thing=true"), "lpcfg_set_option failed");
+ torture_assert(tctx, lpcfg_parm_bool(lp_ctx, NULL, "some", "thing", false) == true,
"invalid parametric option");
- torture_assert(tctx, lp_parm_bool(lp_ctx, NULL, "some", "bla", true) == true,
+ torture_assert(tctx, lpcfg_parm_bool(lp_ctx, NULL, "some", "bla", true) == true,
"invalid parametric option");
return true;
}
static bool test_lp_parm_int(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- torture_assert(tctx, lp_set_option(lp_ctx, "some:thing=34"), "lp_set_option failed");
- torture_assert_int_equal(tctx, lp_parm_int(lp_ctx, NULL, "some", "thing", 20), 34,
+ torture_assert(tctx, lpcfg_set_option(lp_ctx, "some:thing=34"), "lpcfg_set_option failed");
+ torture_assert_int_equal(tctx, lpcfg_parm_int(lp_ctx, NULL, "some", "thing", 20), 34,
"invalid parametric option");
- torture_assert_int_equal(tctx, lp_parm_int(lp_ctx, NULL, "some", "bla", 42), 42,
+ torture_assert_int_equal(tctx, lpcfg_parm_int(lp_ctx, NULL, "some", "bla", 42), 42,
"invalid parametric option");
return true;
}
static bool test_lp_parm_bytes(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- torture_assert(tctx, lp_set_option(lp_ctx, "some:thing=16K"), "lp_set_option failed");
- torture_assert_int_equal(tctx, lp_parm_bytes(lp_ctx, NULL, "some", "thing", 20), 16 * 1024,
+ torture_assert(tctx, lpcfg_set_option(lp_ctx, "some:thing=16K"), "lpcfg_set_option failed");
+ torture_assert_int_equal(tctx, lpcfg_parm_bytes(lp_ctx, NULL, "some", "thing", 20), 16 * 1024,
"invalid parametric option");
- torture_assert_int_equal(tctx, lp_parm_bytes(lp_ctx, NULL, "some", "bla", 42), 42,
+ torture_assert_int_equal(tctx, lpcfg_parm_bytes(lp_ctx, NULL, "some", "bla", 42), 42,
"invalid parametric option");
return true;
}
static bool test_lp_do_service_parameter(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- struct loadparm_service *service = lp_add_service(lp_ctx, lp_default_service(lp_ctx), "foo");
- torture_assert(tctx, lp_do_service_parameter(lp_ctx, service,
- "some:thing", "foo"), "lp_set_option failed");
- torture_assert_str_equal(tctx, lp_parm_string(lp_ctx, service, "some", "thing"), "foo",
+ struct loadparm_service *service = lpcfg_add_service(lp_ctx, lpcfg_default_service(lp_ctx), "foo");
+ torture_assert(tctx, lpcfg_do_service_parameter(lp_ctx, service,
+ "some:thing", "foo"), "lpcfg_set_option failed");
+ torture_assert_str_equal(tctx, lpcfg_parm_string(lp_ctx, service, "some", "thing"), "foo",
"invalid parametric option");
return true;
}
static bool test_lp_service(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
- struct loadparm_service *service = lp_add_service(lp_ctx, lp_default_service(lp_ctx), "foo");
- torture_assert(tctx, service == lp_service(lp_ctx, "foo"), "invalid service");
+ struct loadparm_service *service = lpcfg_add_service(lp_ctx, lpcfg_default_service(lp_ctx), "foo");
+ torture_assert(tctx, service == lpcfg_service(lp_ctx, "foo"), "invalid service");
return true;
}
torture_suite_add_simple_test(suite, "set_lp_parm_int", test_lp_parm_int);
torture_suite_add_simple_test(suite, "set_lp_parm_bytes", test_lp_parm_bytes);
torture_suite_add_simple_test(suite, "service_parameter", test_lp_do_service_parameter);
- torture_suite_add_simple_test(suite, "lp_service", test_lp_service);
+ torture_suite_add_simple_test(suite, "lpcfg_service", test_lp_service);
torture_suite_add_simple_test(suite, "do_global_parameter_var", test_do_global_parameter_var);
torture_suite_add_simple_test(suite, "do_global_parameter", test_do_global_parameter);
*/
-bool lp_is_mydomain(struct loadparm_context *lp_ctx,
+bool lpcfg_is_mydomain(struct loadparm_context *lp_ctx,
const char *domain)
{
- return strequal(lp_workgroup(lp_ctx), domain);
+ return strequal(lpcfg_workgroup(lp_ctx), domain);
}
-bool lp_is_my_domain_or_realm(struct loadparm_context *lp_ctx,
+bool lpcfg_is_my_domain_or_realm(struct loadparm_context *lp_ctx,
const char *domain)
{
- return strequal(lp_workgroup(lp_ctx), domain) ||
- strequal(lp_realm(lp_ctx), domain);
+ return strequal(lpcfg_workgroup(lp_ctx), domain) ||
+ strequal(lpcfg_realm(lp_ctx), domain);
}
/**
see if a string matches either our primary or one of our secondary
netbios aliases. do a case insensitive match
*/
-bool lp_is_myname(struct loadparm_context *lp_ctx, const char *name)
+bool lpcfg_is_myname(struct loadparm_context *lp_ctx, const char *name)
{
const char **aliases;
int i;
- if (strcasecmp(name, lp_netbios_name(lp_ctx)) == 0) {
+ if (strcasecmp(name, lpcfg_netbios_name(lp_ctx)) == 0) {
return true;
}
- aliases = lp_netbios_aliases(lp_ctx);
+ aliases = lpcfg_netbios_aliases(lp_ctx);
for (i=0; aliases && aliases[i]; i++) {
if (strcasecmp(name, aliases[i]) == 0) {
return true;
return talloc_strdup(mem_ctx, name);
}
- dname = talloc_strdup(mem_ctx, lp_lockdir(lp_ctx));
+ dname = talloc_strdup(mem_ctx, lpcfg_lockdir(lp_ctx));
trim_string(dname,"","/");
if (!directory_exist(dname)) {
const char *name)
{
char *fname, *config_dir, *p;
- config_dir = talloc_strdup(mem_ctx, lp_configfile(lp_ctx));
+ config_dir = talloc_strdup(mem_ctx, lpcfg_configfile(lp_ctx));
if (config_dir == NULL) {
config_dir = talloc_strdup(mem_ctx, lp_default_path());
}
if (name[0] == 0 || name[0] == '/' || strstr(name, ":/")) {
return talloc_strdup(mem_ctx, name);
}
- fname = talloc_asprintf(mem_ctx, "%s/%s", lp_private_dir(lp_ctx), name);
+ fname = talloc_asprintf(mem_ctx, "%s/%s", lpcfg_private_dir(lp_ctx), name);
return fname;
}
path itself
*/
char *smbd_tmp_path(TALLOC_CTX *mem_ctx,
- struct loadparm_context *lp_ctx,
+ struct loadparm_context *lp_ctx,
const char *name)
{
char *fname, *dname;
{
const char *env_moduledir = getenv("LD_SAMBA_MODULE_PATH");
return talloc_asprintf(mem_ctx, "%s/%s",
- env_moduledir?env_moduledir:lp_modulesdir(lp_ctx),
+ env_moduledir?env_moduledir:lpcfg_modulesdir(lp_ctx),
name);
}
return ret;
}
-const char *lp_messaging_path(TALLOC_CTX *mem_ctx,
+const char *lpcfg_messaging_path(TALLOC_CTX *mem_ctx,
struct loadparm_context *lp_ctx)
{
return smbd_tmp_path(mem_ctx, lp_ctx, "messaging");
struct loadparm_context *lp_ctx,
struct smb_iconv_convenience *old_ic)
{
- return smb_iconv_convenience_reinit(mem_ctx, lp_dos_charset(lp_ctx),
- lp_unix_charset(lp_ctx),
- lp_parm_bool(lp_ctx, NULL, "iconv", "native", true),
+ return smb_iconv_convenience_reinit(mem_ctx, lpcfg_dos_charset(lp_ctx),
+ lpcfg_unix_charset(lp_ctx),
+ lpcfg_parm_bool(lp_ctx, NULL, "iconv", "native", true),
old_ic);
}
-const char *lp_sam_name(struct loadparm_context *lp_ctx)
+const char *lpcfg_sam_name(struct loadparm_context *lp_ctx)
{
- switch (lp_server_role(lp_ctx)) {
+ switch (lpcfg_server_role(lp_ctx)) {
case ROLE_DOMAIN_CONTROLLER:
- return lp_workgroup(lp_ctx);
+ return lpcfg_workgroup(lp_ctx);
default:
- return lp_netbios_name(lp_ctx);
+ return lpcfg_netbios_name(lp_ctx);
}
}
{
enum srvsvc_PlatformId id;
- id = lp_parm_int(dce_ctx->lp_ctx, NULL, "server_info", "platform_id", PLATFORM_ID_NT);
+ id = lpcfg_parm_int(dce_ctx->lp_ctx, NULL, "server_info", "platform_id", PLATFORM_ID_NT);
return id;
}
/* if there's no string return our NETBIOS name */
if (!p) {
- return talloc_strdup(mem_ctx, lp_netbios_name(dce_ctx->lp_ctx));
+ return talloc_strdup(mem_ctx, lpcfg_netbios_name(dce_ctx->lp_ctx));
}
/* if there're '\\\\' in front remove them otherwise just pass the string */
default_server_announce |= SV_TYPE_SERVER;
default_server_announce |= SV_TYPE_SERVER_UNIX;
- switch (lp_announce_as(dce_ctx->lp_ctx)) {
+ switch (lpcfg_announce_as(dce_ctx->lp_ctx)) {
case ANNOUNCE_AS_NT_SERVER:
default_server_announce |= SV_TYPE_SERVER_NT;
/* fall through... */
break;
}
- switch (lp_server_role(dce_ctx->lp_ctx)) {
+ switch (lpcfg_server_role(dce_ctx->lp_ctx)) {
case ROLE_DOMAIN_MEMBER:
default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
break;
default:
break;
}
- if (lp_time_server(dce_ctx->lp_ctx))
+ if (lpcfg_time_server(dce_ctx->lp_ctx))
default_server_announce |= SV_TYPE_TIME_SOURCE;
- if (lp_host_msdfs(dce_ctx->lp_ctx))
+ if (lpcfg_host_msdfs(dce_ctx->lp_ctx))
default_server_announce |= SV_TYPE_DFS_SERVER;
p->endpoint = ep;
p->contexts = NULL;
p->call_list = NULL;
- p->packet_log_dir = lp_lockdir(dce_ctx->lp_ctx);
+ p->packet_log_dir = lpcfg_lockdir(dce_ctx->lp_ctx);
p->incoming_fragmented_call_list = NULL;
p->pending_call_list = NULL;
p->cli_max_recv_frag = 0;
NTSTATUS status;
/* setup a bind_ack */
- dcesrv_init_hdr(&pkt, lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
+ dcesrv_init_hdr(&pkt, lpcfg_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
pkt.auth_length = 0;
pkt.call_id = call->pkt.call_id;
pkt.ptype = DCERPC_PKT_FAULT;
NTSTATUS status;
/* setup a bind_nak */
- dcesrv_init_hdr(&pkt, lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
+ dcesrv_init_hdr(&pkt, lpcfg_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
pkt.auth_length = 0;
pkt.call_id = call->pkt.call_id;
pkt.ptype = DCERPC_PKT_BIND_NAK;
if provided, check the assoc_group is valid
*/
if (call->pkt.u.bind.assoc_group_id != 0 &&
- lp_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","assoc group checking", true) &&
+ lpcfg_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","assoc group checking", true) &&
dcesrv_assoc_group_find(call->conn->dce_ctx, call->pkt.u.bind.assoc_group_id) == NULL) {
return dcesrv_bind_nak(call, 0);
}
}
if ((call->pkt.pfc_flags & DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN) &&
- lp_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","header signing", false)) {
+ lpcfg_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","header signing", false)) {
call->conn->state_flags |= DCESRV_CALL_STATE_FLAG_HEADER_SIGNING;
extra_flags |= DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN;
}
}
/* setup a bind_ack */
- dcesrv_init_hdr(&pkt, lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
+ dcesrv_init_hdr(&pkt, lpcfg_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
pkt.auth_length = 0;
pkt.call_id = call->pkt.call_id;
pkt.ptype = DCERPC_PKT_BIND_ACK;
if (result == 0 &&
call->pkt.u.alter.assoc_group_id != 0 &&
- lp_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","assoc group checking", true) &&
+ lpcfg_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","assoc group checking", true) &&
call->pkt.u.alter.assoc_group_id != call->context->assoc_group->id) {
DEBUG(0,(__location__ ": Failed attempt to use new assoc_group in alter context (0x%08x 0x%08x)\n",
call->context->assoc_group->id, call->pkt.u.alter.assoc_group_id));
}
/* setup a alter_resp */
- dcesrv_init_hdr(&pkt, lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
+ dcesrv_init_hdr(&pkt, lpcfg_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
pkt.auth_length = 0;
pkt.call_id = call->pkt.call_id;
pkt.ptype = DCERPC_PKT_ALTER_RESP;
pointers */
push->ptr_count = call->ndr_pull->ptr_count;
- if (lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx)) {
+ if (lpcfg_rpc_big_endian(call->conn->dce_ctx->lp_ctx)) {
push->flags |= LIBNDR_FLAG_BIGENDIAN;
}
length = MIN(chunk_size, stub.length);
/* form the dcerpc response packet */
- dcesrv_init_hdr(&pkt, lp_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
+ dcesrv_init_hdr(&pkt, lpcfg_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
pkt.auth_length = 0;
pkt.call_id = call->pkt.call_id;
pkt.ptype = DCERPC_PKT_RESPONSE;
status = samba_server_gensec_start(dce_conn, call->event_ctx,
call->msg_ctx,
- call->conn->dce_ctx->lp_ctx,
+ call->conn->dce_ctx->lp_ctx,
server_credentials,
NULL,
&auth->gensec_security);
ntds_guid_str = GUID_string(res, &ntds_guid);
- dom_string = lp_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
+ dom_string = lpcfg_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
/* get the dNSHostName and cn */
ret = ldb_search(b_state->sam_ctx, mem_ctx, &res2,
* connect to the samdb
*/
b_state->sam_ctx = samdb_connect(b_state, dce_call->event_ctx,
- dce_call->conn->dce_ctx->lp_ctx, auth_info);
+ dce_call->conn->dce_ctx->lp_ctx, auth_info);
if (!b_state->sam_ctx) {
return WERR_FOOBAR;
}
{
enum security_user_level level;
- if (!lp_parm_bool(dce_call->conn->dce_ctx->lp_ctx, NULL,
+ if (!lpcfg_parm_bool(dce_call->conn->dce_ctx->lp_ctx, NULL,
"drs", "disable_sec_check", false)) {
level = security_session_user_level(dce_call->conn->auth_state.session_info, NULL);
if (level < SECURITY_ADMINISTRATOR) {
{
enum security_user_level level;
- if (lp_parm_bool(dce_call->conn->dce_ctx->lp_ctx, NULL,
+ if (lpcfg_parm_bool(dce_call->conn->dce_ctx->lp_ctx, NULL,
"drs", "disable_sec_check", false)) {
return WERR_OK;
}
enum ldb_scope scope = LDB_SCOPE_SUBTREE;
const char *extra_filter;
- extra_filter = lp_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "drs", "object filter");
+ extra_filter = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "drs", "object filter");
getnc_state->min_usn = req8->highwatermark.highest_usn;
/* use this to force single objects at a time, which is useful
* for working out what object is giving problems
*/
- max_objects = lp_parm_int(dce_call->conn->dce_ctx->lp_ctx, NULL, "drs", "max object sync", 1000);
+ max_objects = lpcfg_parm_int(dce_call->conn->dce_ctx->lp_ctx, NULL, "drs", "max object sync", 1000);
if (req8->max_object_count < max_objects) {
max_objects = req8->max_object_count;
}
/*
* TODO: work out how the maximum should be calculated
*/
- max_links = lp_parm_int(dce_call->conn->dce_ctx->lp_ctx, NULL, "drs", "max link sync", 1500);
+ max_links = lpcfg_parm_int(dce_call->conn->dce_ctx->lp_ctx, NULL, "drs", "max link sync", 1500);
for(i=getnc_state->num_sent;
i<getnc_state->site_res->count &&
ureq.naming_context = ncRoot;
ureq.dest_dsa_dns_name = talloc_asprintf(mem_ctx, "%s._msdcs.%s",
GUID_string(mem_ctx, &req8->destination_dsa_guid),
- lp_realm(dce_call->conn->dce_ctx->lp_ctx));
+ lpcfg_realm(dce_call->conn->dce_ctx->lp_ctx));
if (!ureq.dest_dsa_dns_name) {
return WERR_NOMEM;
}
ZERO_STRUCT(domain_guid);
- switch (lp_server_role(dce_call->conn->dce_ctx->lp_ctx)) {
+ switch (lpcfg_server_role(dce_call->conn->dce_ctx->lp_ctx)) {
case ROLE_STANDALONE:
role = DS_ROLE_STANDALONE_SERVER;
break;
break;
}
- switch (lp_server_role(dce_call->conn->dce_ctx->lp_ctx)) {
+ switch (lpcfg_server_role(dce_call->conn->dce_ctx->lp_ctx)) {
case ROLE_STANDALONE:
- domain = talloc_strdup(mem_ctx, lp_workgroup(dce_call->conn->dce_ctx->lp_ctx));
+ domain = talloc_strdup(mem_ctx, lpcfg_workgroup(dce_call->conn->dce_ctx->lp_ctx));
W_ERROR_HAVE_NO_MEMORY(domain);
break;
case ROLE_DOMAIN_MEMBER:
- domain = talloc_strdup(mem_ctx, lp_workgroup(dce_call->conn->dce_ctx->lp_ctx));
+ domain = talloc_strdup(mem_ctx, lpcfg_workgroup(dce_call->conn->dce_ctx->lp_ctx));
W_ERROR_HAVE_NO_MEMORY(domain);
/* TODO: what is with dns_domain and forest and guid? */
break;
name = &r->in.name.string[2];
/* We need to connect to the database as system, as this is one of the rare RPC calls that must read the secrets (and this is denied otherwise) */
secret_state->sam_ldb = talloc_reference(secret_state,
- samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, system_session(dce_call->conn->dce_ctx->lp_ctx)));
+ samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, system_session(dce_call->conn->dce_ctx->lp_ctx)));
secret_state->global = true;
if (strlen(name) < 1) {
name = &r->in.name.string[2];
/* We need to connect to the database as system, as this is one of the rare RPC calls that must read the secrets (and this is denied otherwise) */
secret_state->sam_ldb = talloc_reference(secret_state,
- samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, system_session(dce_call->conn->dce_ctx->lp_ctx)));
+ samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, system_session(dce_call->conn->dce_ctx->lp_ctx)));
secret_state->global = true;
if (strlen(name) < 1) {
}
/* make sure the sam database is accessible */
- state->sam_ldb = samdb_connect(state, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info);
+ state->sam_ldb = samdb_connect(state, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info);
if (state->sam_ldb == NULL) {
return NT_STATUS_INVALID_SYSTEM_SERVICE;
}
talloc_free(dom_res);
- state->domain_name = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
+ state->domain_name = lpcfg_sam_name(dce_call->conn->dce_ctx->lp_ctx);
state->domain_dns = ldb_dn_canonical_string(state, state->domain_dn);
if (!state->domain_dns) {
r->out.sids->sids[i].sid_index = 0xFFFFFFFF;
r->out.sids->sids[i].flags = 0;
- status2 = dcesrv_lsa_lookup_name(dce_call->event_ctx, lp_ctx, policy_state, mem_ctx, name,
+ status2 = dcesrv_lsa_lookup_name(dce_call->event_ctx, lp_ctx, policy_state, mem_ctx, name,
&authority_name, &sid, &rtype, &rid);
if (!NT_STATUS_IS_OK(status2) || sid->num_auths == 0) {
continue;
r->out.sids->sids[i].sid_index = 0xFFFFFFFF;
r->out.sids->sids[i].unknown = 0;
- status2 = dcesrv_lsa_lookup_name(dce_call->event_ctx, lp_ctx, state, mem_ctx, name,
+ status2 = dcesrv_lsa_lookup_name(dce_call->event_ctx, lp_ctx, state, mem_ctx, name,
&authority_name, &sid, &rtype, &rid);
if (!NT_STATUS_IS_OK(status2)) {
continue;
creds->sid = samdb_result_dom_sid(creds, msgs[0], "objectSid");
nt_status = schannel_save_creds_state(mem_ctx,
- lp_private_dir(dce_call->conn->dce_ctx->lp_ctx),
+ lpcfg_private_dir(dce_call->conn->dce_ctx->lp_ctx),
creds);
return nt_status;
{
NTSTATUS nt_status;
struct dcerpc_auth *auth_info = dce_call->conn->auth_state.auth_info;
- bool schannel_global_required = false; /* Should be lp_schannel_server() == true */
+ bool schannel_global_required = false; /* Should be lpcfg_schannel_server() == true */
if (schannel_global_required) {
nt_status = schannel_check_required(auth_info,
}
nt_status = schannel_check_creds_state(mem_ctx,
- lp_private_dir(dce_call->conn->dce_ctx->lp_ctx),
+ lpcfg_private_dir(dce_call->conn->dce_ctx->lp_ctx),
computer_name,
received_authenticator,
return_authenticator,
sam6->sidcount = sam3->sidcount;
sam6->sids = sam3->sids;
- sam6->dns_domainname.string = lp_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
+ sam6->dns_domainname.string = lpcfg_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
sam6->principle.string = talloc_asprintf(mem_ctx, "%s@%s",
sam->account_name.string, sam6->dns_domainname.string);
NT_STATUS_HAVE_NO_MEMORY(sam6->principle.string);
struct netlogon_creds_CredentialState *creds;
nt_status = schannel_get_creds_state(mem_ctx,
- lp_private_dir(dce_call->conn->dce_ctx->lp_ctx),
+ lpcfg_private_dir(dce_call->conn->dce_ctx->lp_ctx),
r->in.computer_name, &creds);
if (!NT_STATUS_IS_OK(nt_status)) {
return nt_status;
* - check all r->in.* parameters (server_unc is ignored by w2k3!)
*/
dcname = talloc_asprintf(mem_ctx, "\\\\%s",
- lp_netbios_name(dce_call->conn->dce_ctx->lp_ctx));
+ lpcfg_netbios_name(dce_call->conn->dce_ctx->lp_ctx));
W_ERROR_HAVE_NO_MEMORY(dcname);
*r->out.dcname = dcname;
if ((r->in.domainname == NULL) || (r->in.domainname[0] == '\0')) {
/* if the domainname parameter wasn't set assume our domain */
- r->in.domainname = lp_workgroup(lp_ctx);
+ r->in.domainname = lpcfg_workgroup(lp_ctx);
}
sam_ctx = samdb_connect(mem_ctx, dce_call->event_ctx, lp_ctx,
return WERR_DS_UNAVAILABLE;
}
- if (strcasecmp(r->in.domainname, lp_workgroup(lp_ctx)) == 0) {
+ if (strcasecmp(r->in.domainname, lpcfg_workgroup(lp_ctx)) == 0) {
/* well we asked for a DC of our own domain */
if (samdb_is_pdc(sam_ctx)) {
/* we are the PDC of the specified domain */
}
*r->out.dcname = talloc_asprintf(mem_ctx, "\\%s",
- lp_netbios_name(lp_ctx));
+ lpcfg_netbios_name(lp_ctx));
W_ERROR_HAVE_NO_MEMORY(*r->out.dcname);
return WERR_OK;
}
if (is_local) {
- info->domainname.string = lp_workgroup(lp_ctx);
- info->dns_domainname.string = lp_dnsdomain(lp_ctx);
+ info->domainname.string = lpcfg_workgroup(lp_ctx);
+ info->dns_domainname.string = lpcfg_dnsdomain(lp_ctx);
info->domain_guid = samdb_result_guid(res, "objectGUID");
info->domain_sid = samdb_result_dom_sid(mem_ctx, res, "objectSid");
} else {
struct ldb_message **dom_res;
const char * const dom_attrs[] = { "objectSid", "objectGUID", NULL };
struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
- const char *dnsdomain = lp_dnsdomain(lp_ctx);
+ const char *dnsdomain = lpcfg_dnsdomain(lp_ctx);
const char *p;
WERROR werr;
trusts->count);
W_ERROR_HAVE_NO_MEMORY(trusts->array);
- trusts->array[n].netbios_name = lp_workgroup(lp_ctx);
- trusts->array[n].dns_name = lp_dnsdomain(lp_ctx);
+ trusts->array[n].netbios_name = lpcfg_workgroup(lp_ctx);
+ trusts->array[n].dns_name = lpcfg_dnsdomain(lp_ctx);
trusts->array[n].trust_flags =
NETR_TRUST_FLAG_NATIVE |
NETR_TRUST_FLAG_TREEROOT |
domain_info = &e->forest_trust_data.domain_info;
domain_info->domain_sid = samdb_result_dom_sid(info, dom_res[0],
"objectSid");
- domain_info->dns_domain_name.string = lp_dnsdomain(lp_ctx);
- domain_info->netbios_domain_name.string = lp_workgroup(lp_ctx);
+ domain_info->dns_domain_name.string = lpcfg_dnsdomain(lp_ctx);
+ domain_info->netbios_domain_name.string = lpcfg_workgroup(lp_ctx);
info->entries[1] = e;
NTSTATUS status;
const struct ndr_interface_table *table;
struct dcesrv_remote_private *priv;
- const char *binding = lp_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "binding");
+ const char *binding = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "binding");
const char *user, *pass, *domain;
struct cli_credentials *credentials;
bool must_free_credentials = true;
struct dcerpc_binding *b;
struct composite_context *pipe_conn_req;
- machine_account = lp_parm_bool(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "use_machine_account", false);
+ machine_account = lpcfg_parm_bool(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "use_machine_account", false);
priv = talloc(dce_call->conn, struct dcesrv_remote_private);
if (!priv) {
return NT_STATUS_INVALID_PARAMETER;
}
- user = lp_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "user");
- pass = lp_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "password");
- domain = lp_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dceprc_remote", "domain");
+ user = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "user");
+ pass = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "password");
+ domain = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dceprc_remote", "domain");
table = ndr_table_by_uuid(&iface->syntax_id.uuid); /* FIXME: What about if_version ? */
if (!table) {
static NTSTATUS remote_op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
{
unsigned int i;
- const char **ifaces = (const char **)str_list_make(dce_ctx, lp_parm_string(dce_ctx->lp_ctx, NULL, "dcerpc_remote", "interfaces"),NULL);
+ const char **ifaces = (const char **)str_list_make(dce_ctx, lpcfg_parm_string(dce_ctx->lp_ctx, NULL, "dcerpc_remote", "interfaces"),NULL);
if (!ifaces) {
DEBUG(3,("remote_op_init_server: no interfaces configured\n"));
}
/* make sure the sam database is accessible */
- c_state->sam_ctx = samdb_connect(c_state, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info);
+ c_state->sam_ctx = samdb_connect(c_state, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info);
if (c_state->sam_ctx == NULL) {
talloc_free(c_state);
return NT_STATUS_INVALID_SYSTEM_SERVICE;
ret = gendb_search(c_state->sam_ctx,
mem_ctx, NULL, &dom_msgs, dom_attrs,
"(objectClass=builtinDomain)");
- } else if (strcasecmp_m(r->in.domain_name->string, lp_sam_name(dce_call->conn->dce_ctx->lp_ctx)) == 0) {
+ } else if (strcasecmp_m(r->in.domain_name->string, lpcfg_sam_name(dce_call->conn->dce_ctx->lp_ctx)) == 0) {
ret = gendb_search_dn(c_state->sam_ctx,
mem_ctx, ldb_get_default_basedn(c_state->sam_ctx),
&dom_msgs, dom_attrs);
for (i=0;i<2-start_i;i++) {
array->entries[i].idx = start_i + i;
if (i == 0) {
- array->entries[i].name.string = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
+ array->entries[i].name.string = lpcfg_sam_name(dce_call->conn->dce_ctx->lp_ctx);
} else {
array->entries[i].name.string = "BUILTIN";
}
d_state->domain_name = "BUILTIN";
} else {
d_state->builtin = false;
- d_state->domain_name = lp_sam_name(dce_call->conn->dce_ctx->lp_ctx);
+ d_state->domain_name = lpcfg_sam_name(dce_call->conn->dce_ctx->lp_ctx);
}
ret = gendb_search(c_state->sam_ctx,
}
d_state->domain_dn = talloc_steal(d_state, dom_msgs[0]->dn);
- d_state->role = lp_server_role(dce_call->conn->dce_ctx->lp_ctx);
+ d_state->role = lpcfg_server_role(dce_call->conn->dce_ctx->lp_ctx);
d_state->connect_state = talloc_reference(d_state, c_state);
d_state->sam_ctx = c_state->sam_ctx;
d_state->access_mask = r->in.access_mask;
info->primary.string = samdb_result_fsmo_name(state->sam_ctx, mem_ctx, dom_msgs[0], "fSMORoleOwner");
if (!info->primary.string) {
- info->primary.string = lp_netbios_name(state->lp_ctx);
+ info->primary.string = lpcfg_netbios_name(state->lp_ctx);
}
info->force_logoff_time = ldb_msg_find_attr_as_uint64(dom_msgs[0], "forceLogoff",
dom_msgs[0], "fSMORoleOwner");
if (!info->primary.string) {
- info->primary.string = lp_netbios_name(state->lp_ctx);
+ info->primary.string = lpcfg_netbios_name(state->lp_ctx);
}
return NT_STATUS_OK;
}
/* this call can only work with lanman auth */
- if (!lp_lanman_auth(dce_call->conn->dce_ctx->lp_ctx)) {
+ if (!lpcfg_lanman_auth(dce_call->conn->dce_ctx->lp_ctx)) {
return NT_STATUS_WRONG_PASSWORD;
}
return NT_STATUS_WRONG_PASSWORD;
}
- if (!convert_string_talloc_convenience(mem_ctx, lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
+ if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
CH_DOS, CH_UNIX,
(const char *)new_password.data,
new_password.length,
return NT_STATUS_WRONG_PASSWORD;
}
- if (!convert_string_talloc_convenience(mem_ctx, lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
+ if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
CH_DOS, CH_UTF16,
(const char *)new_password.data,
new_password.length,
user_dn = res[0]->dn;
- status = samdb_result_passwords(mem_ctx, dce_call->conn->dce_ctx->lp_ctx,
+ status = samdb_result_passwords(mem_ctx, dce_call->conn->dce_ctx->lp_ctx,
res[0], &lm_pwd, &nt_pwd);
if (!NT_STATUS_IS_OK(status) ) {
goto failed;
* this) */
if (lm_pwd && r->in.lm_verifier != NULL) {
char *new_pass;
- if (!convert_string_talloc_convenience(mem_ctx, lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
+ if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
CH_UTF16, CH_UNIX,
(const char *)new_password.data,
new_password.length,
status = stream_setup_socket(event_ctx, lp_ctx,
model_ops, &dcesrv_stream_ops,
"unix", e->ep_description->endpoint, &port,
- lp_socket_options(lp_ctx),
+ lpcfg_socket_options(lp_ctx),
dcesrv_sock);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("service_setup_stream_socket(path=%s) failed - %s\n",
e->ep_description->endpoint = talloc_strdup(dce_ctx, "DEFAULT");
}
- full_path = talloc_asprintf(dce_ctx, "%s/%s", lp_ncalrpc_dir(lp_ctx),
+ full_path = talloc_asprintf(dce_ctx, "%s/%s", lpcfg_ncalrpc_dir(lp_ctx),
e->ep_description->endpoint);
dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
status = stream_setup_socket(event_ctx, lp_ctx,
model_ops, &dcesrv_stream_ops,
"unix", full_path, &port,
- lp_socket_options(lp_ctx),
+ lpcfg_socket_options(lp_ctx),
dcesrv_sock);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("service_setup_stream_socket(identifier=%s,path=%s) failed - %s\n",
status = stream_setup_socket(event_ctx, dce_ctx->lp_ctx,
model_ops, &dcesrv_stream_ops,
"ipv4", address, &port,
- lp_socket_options(dce_ctx->lp_ctx),
+ lpcfg_socket_options(dce_ctx->lp_ctx),
dcesrv_sock);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("service_setup_stream_socket(address=%s,port=%u) failed - %s\n",
NTSTATUS status;
/* Add TCP/IP sockets */
- if (lp_interfaces(lp_ctx) && lp_bind_interfaces_only(lp_ctx)) {
+ if (lpcfg_interfaces(lp_ctx) && lpcfg_bind_interfaces_only(lp_ctx)) {
int num_interfaces;
int i;
struct interface *ifaces;
- load_interfaces(dce_ctx, lp_interfaces(lp_ctx), &ifaces);
+ load_interfaces(dce_ctx, lpcfg_interfaces(lp_ctx), &ifaces);
num_interfaces = iface_count(ifaces);
for(i = 0; i < num_interfaces; i++) {
}
} else {
status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops,
- lp_socket_address(lp_ctx));
+ lpcfg_socket_address(lp_ctx));
NT_STATUS_NOT_OK_RETURN(status);
}
status = dcesrv_init_context(task->event_ctx,
task->lp_ctx,
- lp_dcerpc_endpoint_servers(task->lp_ctx),
+ lpcfg_dcerpc_endpoint_servers(task->lp_ctx),
&dce_ctx);
if (!NT_STATUS_IS_OK(status)) goto failed;
/* Make sure the directory for NCALRPC exists */
- if (!directory_exist(lp_ncalrpc_dir(task->lp_ctx))) {
- mkdir(lp_ncalrpc_dir(task->lp_ctx), 0755);
+ if (!directory_exist(lpcfg_ncalrpc_dir(task->lp_ctx))) {
+ mkdir(lpcfg_ncalrpc_dir(task->lp_ctx), 0755);
}
for (e=dce_ctx->endpoint_list;e;e=e->next) {
server_name += 2;
/* NETBIOS NAME is ok */
- ret = strequal(lp_netbios_name(dce_call->conn->dce_ctx->lp_ctx), server_name);
+ ret = strequal(lpcfg_netbios_name(dce_call->conn->dce_ctx->lp_ctx), server_name);
if (ret) return WERR_OK;
- aliases = lp_netbios_aliases(dce_call->conn->dce_ctx->lp_ctx);
+ aliases = lpcfg_netbios_aliases(dce_call->conn->dce_ctx->lp_ctx);
for (i=0; aliases && aliases[i]; i++) {
if (strequal(aliases[i], server_name)) {
/* DNS NAME is ok
* TODO: we need to check if aliases are also ok
*/
- dnsdomain = lp_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
+ dnsdomain = lpcfg_dnsdomain(dce_call->conn->dce_ctx->lp_ctx);
if (dnsdomain != NULL) {
char *str;
str = talloc_asprintf(mem_ctx, "%s.%s",
- lp_netbios_name(dce_call->conn->dce_ctx->lp_ctx),
+ lpcfg_netbios_name(dce_call->conn->dce_ctx->lp_ctx),
dnsdomain);
W_ERROR_HAVE_NO_MEMORY(str);
struct ntptr_context *ntptr;
status = ntptr_init_context(dce_call->context, dce_call->conn->event_ctx, dce_call->conn->dce_ctx->lp_ctx,
- lp_ntptr_providor(dce_call->conn->dce_ctx->lp_ctx), &ntptr);
+ lpcfg_ntptr_providor(dce_call->conn->dce_ctx->lp_ctx), &ntptr);
NT_STATUS_NOT_OK_RETURN(status);
dce_call->context->private_data = ntptr;
}
ZERO_STRUCT(rop);
- rop.in.server_name = lp_netbios_name(dce_call->conn->dce_ctx->lp_ctx);
+ rop.in.server_name = lpcfg_netbios_name(dce_call->conn->dce_ctx->lp_ctx);
W_ERROR_HAVE_NO_MEMORY(rop.in.server_name);
rop.in.printer_local = 0;
rop.in.type = REG_NONE;
unsigned int count = 8;
unsigned int i;
- nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
+ nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
if (!NT_STATUS_IS_OK(nterr)) {
return ntstatus_to_werror(nterr);
}
unsigned int count = 10;
unsigned int i;
- nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
+ nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
if (!NT_STATUS_IS_OK(nterr)) {
return ntstatus_to_werror(nterr);
}
/* TODO: - paging of results
*/
- nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
+ nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
if (!NT_STATUS_IS_OK(nterr)) {
return ntstatus_to_werror(nterr);
}
return WERR_INVALID_PARAM;
}
- nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
+ nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
if (!NT_STATUS_IS_OK(nterr)) {
return ntstatus_to_werror(nterr);
}
return WERR_INVALID_PARAM;
}
- nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
+ nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
if (!NT_STATUS_IS_OK(nterr)) {
return ntstatus_to_werror(nterr);
}
}
all_string_sub(device, "\\", "/", 0);
- nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
+ nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
if (!NT_STATUS_IS_OK(nterr)) {
return ntstatus_to_werror(nterr);
}
struct srvsvc_NetSrvGetInfo *r)
{
struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
- struct dcerpc_server_info *server_info = lp_dcerpc_server_info(mem_ctx, dce_ctx->lp_ctx);
+ struct dcerpc_server_info *server_info = lpcfg_dcerpc_server_info(mem_ctx, dce_ctx->lp_ctx);
ZERO_STRUCTP(r->out.info);
info101->version_major = server_info->version_major;
info101->version_minor = server_info->version_minor;
info101->server_type = dcesrv_common_get_server_type(mem_ctx, dce_call->event_ctx, dce_ctx);
- info101->comment = talloc_strdup(mem_ctx, lp_serverstring(dce_ctx->lp_ctx));
+ info101->comment = talloc_strdup(mem_ctx, lpcfg_serverstring(dce_ctx->lp_ctx));
W_ERROR_HAVE_NO_MEMORY(info101->comment);
r->out.info->info101 = info101;
info102->version_major = server_info->version_major;
info102->version_minor = server_info->version_minor;
info102->server_type = dcesrv_common_get_server_type(mem_ctx, dce_call->event_ctx, dce_ctx);
- info102->comment = talloc_strdup(mem_ctx, lp_serverstring(dce_ctx->lp_ctx));
+ info102->comment = talloc_strdup(mem_ctx, lpcfg_serverstring(dce_ctx->lp_ctx));
W_ERROR_HAVE_NO_MEMORY(info102->comment);
info102->users = dcesrv_common_get_users(mem_ctx, dce_ctx);
/* TODO: - paging of results
*/
- nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
+ nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
if (!NT_STATUS_IS_OK(nterr)) {
return ntstatus_to_werror(nterr);
}
NTSTATUS nterr;
struct share_context *sctx;
- nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
+ nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
if (!NT_STATUS_IS_OK(nterr)) {
return ntstatus_to_werror(nterr);
}
const struct tsocket_address *local_address;
const struct tsocket_address *remote_address;
- status = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
+ status = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
struct wkssvc_NetWkstaGetInfo *r)
{
struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
- struct dcerpc_server_info *server_info = lp_dcerpc_server_info(mem_ctx, dce_ctx->lp_ctx);
+ struct dcerpc_server_info *server_info = lpcfg_dcerpc_server_info(mem_ctx, dce_ctx->lp_ctx);
/* NOTE: win2k3 ignores r->in.server_name completly so we do --metze */
tmp_ctx = talloc_new(NULL);
- lp_ctx = lp_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
+ lp_ctx = lpcfg_from_py_object(NULL, py_lp_ctx); /* FIXME: leaky */
if (lp_ctx == NULL) {
PyErr_SetString(PyExc_TypeError, "Expected loadparm object");
talloc_free(tmp_ctx);
return NULL;
}
- load_interfaces(tmp_ctx, lp_interfaces(lp_ctx), &ifaces);
+ load_interfaces(tmp_ctx, lpcfg_interfaces(lp_ctx), &ifaces);
count = iface_count(ifaces);
****************************************************************************/
static void reply_coreplus(struct smbsrv_request *req, uint16_t choice)
{
- uint16_t raw = (lp_readraw(req->smb_conn->lp_ctx)?1:0) | (lp_writeraw(req->smb_conn->lp_ctx)?2:0);
+ uint16_t raw = (lpcfg_readraw(req->smb_conn->lp_ctx)?1:0) | (lpcfg_writeraw(req->smb_conn->lp_ctx)?2:0);
smbsrv_setup_reply(req, 13, 0);
****************************************************************************/
static void reply_lanman1(struct smbsrv_request *req, uint16_t choice)
{
- int raw = (lp_readraw(req->smb_conn->lp_ctx)?1:0) | (lp_writeraw(req->smb_conn->lp_ctx)?2:0);
+ int raw = (lpcfg_readraw(req->smb_conn->lp_ctx)?1:0) | (lpcfg_writeraw(req->smb_conn->lp_ctx)?2:0);
int secword=0;
time_t t = req->request_time.tv_sec;
- req->smb_conn->negotiate.encrypted_passwords = lp_encrypted_passwords(req->smb_conn->lp_ctx);
+ req->smb_conn->negotiate.encrypted_passwords = lpcfg_encrypted_passwords(req->smb_conn->lp_ctx);
- if (lp_security(req->smb_conn->lp_ctx) != SEC_SHARE)
+ if (lpcfg_security(req->smb_conn->lp_ctx) != SEC_SHARE)
secword |= NEGOTIATE_SECURITY_USER_LEVEL;
if (req->smb_conn->negotiate.encrypted_passwords)
SSVAL(req->out.vwv, VWV(0), choice);
SSVAL(req->out.vwv, VWV(1), secword);
SSVAL(req->out.vwv, VWV(2), req->smb_conn->negotiate.max_recv);
- SSVAL(req->out.vwv, VWV(3), lp_maxmux(req->smb_conn->lp_ctx));
+ SSVAL(req->out.vwv, VWV(3), lpcfg_maxmux(req->smb_conn->lp_ctx));
SSVAL(req->out.vwv, VWV(4), 1);
SSVAL(req->out.vwv, VWV(5), raw);
SIVAL(req->out.vwv, VWV(6), req->smb_conn->connection->server_id.id);
****************************************************************************/
static void reply_lanman2(struct smbsrv_request *req, uint16_t choice)
{
- int raw = (lp_readraw(req->smb_conn->lp_ctx)?1:0) | (lp_writeraw(req->smb_conn->lp_ctx)?2:0);
+ int raw = (lpcfg_readraw(req->smb_conn->lp_ctx)?1:0) | (lpcfg_writeraw(req->smb_conn->lp_ctx)?2:0);
int secword=0;
time_t t = req->request_time.tv_sec;
- req->smb_conn->negotiate.encrypted_passwords = lp_encrypted_passwords(req->smb_conn->lp_ctx);
+ req->smb_conn->negotiate.encrypted_passwords = lpcfg_encrypted_passwords(req->smb_conn->lp_ctx);
- if (lp_security(req->smb_conn->lp_ctx) != SEC_SHARE)
+ if (lpcfg_security(req->smb_conn->lp_ctx) != SEC_SHARE)
secword |= NEGOTIATE_SECURITY_USER_LEVEL;
if (req->smb_conn->negotiate.encrypted_passwords)
SSVAL(req->out.vwv, VWV(0), choice);
SSVAL(req->out.vwv, VWV(1), secword);
SSVAL(req->out.vwv, VWV(2), req->smb_conn->negotiate.max_recv);
- SSVAL(req->out.vwv, VWV(3), lp_maxmux(req->smb_conn->lp_ctx));
+ SSVAL(req->out.vwv, VWV(3), lpcfg_maxmux(req->smb_conn->lp_ctx));
SSVAL(req->out.vwv, VWV(4), 1);
SSVAL(req->out.vwv, VWV(5), raw);
SIVAL(req->out.vwv, VWV(6), req->smb_conn->connection->server_id.id);
get_challenge(req->smb_conn, req->out.data);
}
- req_push_str(req, NULL, lp_workgroup(req->smb_conn->lp_ctx), -1, STR_TERMINATE);
+ req_push_str(req, NULL, lpcfg_workgroup(req->smb_conn->lp_ctx), -1, STR_TERMINATE);
if (req->smb_conn->signing.mandatory_signing) {
smbsrv_terminate_connection(req->smb_conn,
req->out.ptr += 8;
SCVAL(req->out.vwv+1, VWV(16), 8);
}
- req_push_str(req, NULL, lp_workgroup(req->smb_conn->lp_ctx), -1, STR_UNICODE|STR_TERMINATE|STR_NOALIGN);
- req_push_str(req, NULL, lp_netbios_name(req->smb_conn->lp_ctx), -1, STR_UNICODE|STR_TERMINATE|STR_NOALIGN);
+ req_push_str(req, NULL, lpcfg_workgroup(req->smb_conn->lp_ctx), -1, STR_UNICODE|STR_TERMINATE|STR_NOALIGN);
+ req_push_str(req, NULL, lpcfg_netbios_name(req->smb_conn->lp_ctx), -1, STR_UNICODE|STR_TERMINATE|STR_NOALIGN);
DEBUG(3,("not using extended security (SPNEGO or NTLMSSP)\n"));
}
CAP_NT_FIND | CAP_LOCK_AND_READ |
CAP_LEVEL_II_OPLOCKS | CAP_NT_SMBS | CAP_RPC_REMOTE_APIS;
- req->smb_conn->negotiate.encrypted_passwords = lp_encrypted_passwords(req->smb_conn->lp_ctx);
+ req->smb_conn->negotiate.encrypted_passwords = lpcfg_encrypted_passwords(req->smb_conn->lp_ctx);
/* do spnego in user level security if the client
supports it and we can do encrypted passwords */
if (req->smb_conn->negotiate.encrypted_passwords &&
- (lp_security(req->smb_conn->lp_ctx) != SEC_SHARE) &&
- lp_use_spnego(req->smb_conn->lp_ctx) &&
+ (lpcfg_security(req->smb_conn->lp_ctx) != SEC_SHARE) &&
+ lpcfg_use_spnego(req->smb_conn->lp_ctx) &&
(req->flags2 & FLAGS2_EXTENDED_SECURITY)) {
negotiate_spnego = true;
capabilities |= CAP_EXTENDED_SECURITY;
}
- if (lp_unix_extensions(req->smb_conn->lp_ctx)) {
+ if (lpcfg_unix_extensions(req->smb_conn->lp_ctx)) {
capabilities |= CAP_UNIX;
}
- if (lp_large_readwrite(req->smb_conn->lp_ctx)) {
+ if (lpcfg_large_readwrite(req->smb_conn->lp_ctx)) {
capabilities |= CAP_LARGE_READX | CAP_LARGE_WRITEX | CAP_W2K_SMBS;
}
capabilities |= CAP_LARGE_FILES;
}
- if (lp_readraw(req->smb_conn->lp_ctx) &&
- lp_writeraw(req->smb_conn->lp_ctx)) {
+ if (lpcfg_readraw(req->smb_conn->lp_ctx) &&
+ lpcfg_writeraw(req->smb_conn->lp_ctx)) {
capabilities |= CAP_RAW_MODE;
}
/* allow for disabling unicode */
- if (lp_unicode(req->smb_conn->lp_ctx)) {
+ if (lpcfg_unicode(req->smb_conn->lp_ctx)) {
capabilities |= CAP_UNICODE;
}
- if (lp_nt_status_support(req->smb_conn->lp_ctx)) {
+ if (lpcfg_nt_status_support(req->smb_conn->lp_ctx)) {
capabilities |= CAP_STATUS32;
}
- if (lp_host_msdfs(req->smb_conn->lp_ctx)) {
+ if (lpcfg_host_msdfs(req->smb_conn->lp_ctx)) {
capabilities |= CAP_DFS;
}
- if (lp_security(req->smb_conn->lp_ctx) != SEC_SHARE) {
+ if (lpcfg_security(req->smb_conn->lp_ctx) != SEC_SHARE) {
secword |= NEGOTIATE_SECURITY_USER_LEVEL;
}
this is the one and only SMB packet that is malformed in
the specification - all the command words after the secword
are offset by 1 byte */
- SSVAL(req->out.vwv+1, VWV(1), lp_maxmux(req->smb_conn->lp_ctx));
+ SSVAL(req->out.vwv+1, VWV(1), lpcfg_maxmux(req->smb_conn->lp_ctx));
SSVAL(req->out.vwv+1, VWV(2), 1); /* num vcs */
SIVAL(req->out.vwv+1, VWV(3), req->smb_conn->negotiate.max_recv);
SIVAL(req->out.vwv+1, VWV(5), 0x10000); /* raw size. full 64k */
for (protocol = 0; supported_protocols[protocol].proto_name; protocol++) {
int i;
- if (supported_protocols[protocol].protocol_level > lp_srv_maxprotocol(req->smb_conn->lp_ctx))
+ if (supported_protocols[protocol].protocol_level > lpcfg_srv_maxprotocol(req->smb_conn->lp_ctx))
continue;
- if (supported_protocols[protocol].protocol_level < lp_srv_minprotocol(req->smb_conn->lp_ctx))
+ if (supported_protocols[protocol].protocol_level < lpcfg_srv_minprotocol(req->smb_conn->lp_ctx))
continue;
for (i = 0; i < protos_count; i++) {
/* this is the size that w2k uses, and it appears to be important for
good performance */
- smb_conn->negotiate.max_recv = lp_max_xmit(lp_ctx);
+ smb_conn->negotiate.max_recv = lpcfg_max_xmit(lp_ctx);
smb_conn->negotiate.zone_offset = get_time_zone(time(NULL));
- smb_conn->config.security = lp_security(lp_ctx);
- smb_conn->config.nt_status_support = lp_nt_status_support(lp_ctx);
+ smb_conn->config.security = lpcfg_security(lp_ctx);
+ smb_conn->config.nt_status_support = lpcfg_nt_status_support(lp_ctx);
status = smbsrv_init_sessions(smb_conn, UINT16_MAX);
NT_STATUS_NOT_OK_RETURN(status);
con->tconx.out.tid = req->tcon->tid;
con->tconx.out.options = SMB_SUPPORT_SEARCH_BITS | (share_int_option(req->tcon->ntvfs->config, SHARE_CSC_POLICY, SHARE_CSC_POLICY_DEFAULT) << 2);
- if (share_bool_option(req->tcon->ntvfs->config, SHARE_MSDFS_ROOT, SHARE_MSDFS_ROOT_DEFAULT) && lp_host_msdfs(req->smb_conn->lp_ctx)) {
+ if (share_bool_option(req->tcon->ntvfs->config, SHARE_MSDFS_ROOT, SHARE_MSDFS_ROOT_DEFAULT) && lpcfg_host_msdfs(req->smb_conn->lp_ctx)) {
con->tconx.out.options |= SMB_SHARE_IN_DFS;
}
(*os) = talloc_asprintf(req, "Unix");
(*lanman) = talloc_asprintf(req, "Samba %s", SAMBA_VERSION_STRING);
(*domain) = talloc_asprintf(req, "%s",
- lp_workgroup(req->smb_conn->lp_ctx));
+ lpcfg_workgroup(req->smb_conn->lp_ctx));
}
static void smbsrv_sesssetup_backend_send(struct smbsrv_request *req,
return false;
}
- switch (lp_server_signing(smb_conn->lp_ctx)) {
+ switch (lpcfg_server_signing(smb_conn->lp_ctx)) {
case SMB_SIGNING_OFF:
smb_conn->signing.allow_smb_signing = false;
break;
* attacks on communications between us and the
* clients */
- if (lp_server_role(smb_conn->lp_ctx) == ROLE_DOMAIN_CONTROLLER) {
+ if (lpcfg_server_role(smb_conn->lp_ctx) == ROLE_DOMAIN_CONTROLLER) {
smb_conn->signing.allow_smb_signing = true;
smb_conn->signing.mandatory_signing = true;
} else {
DATA_BLOB outblob;
enum ndr_err_code ndr_err;
NTSTATUS status;
- const char *dns_domain = lp_dnsdomain(lp_ctx);
- const char *netbios_domain = lp_workgroup(lp_ctx);
+ const char *dns_domain = lpcfg_dnsdomain(lp_ctx);
+ const char *netbios_domain = lpcfg_workgroup(lp_ctx);
struct dfs_referral_resp resp;
struct dfs_referral_type *tab;
struct dfs_referral_type *referral;
uint32_t current_pos = 0;
TALLOC_CTX *context;
- if (lp_server_role(lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
+ if (lpcfg_server_role(lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
DEBUG(10 ,("Received a domain referral request on a non DC\n"));
return NT_STATUS_INVALID_PARAMETER;
}
unsigned int num_domain = 1;
enum ndr_err_code ndr_err;
const char *requesteddomain;
- const char *realm = lp_realm(lp_ctx);
- const char *domain = lp_workgroup(lp_ctx);
+ const char *realm = lpcfg_realm(lp_ctx);
+ const char *domain = lpcfg_workgroup(lp_ctx);
const char *site_name = NULL; /* Name of the site where the client is */
char *share = NULL;
bool found = false;
char *client_addr = NULL;
TALLOC_CTX *context;
- if (lp_server_role(lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
+ if (lpcfg_server_role(lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
return NT_STATUS_INVALID_PARAMETER;
}
NTSTATUS status;
lp_ctx = req->tcon->ntvfs->lp_ctx;
- if (!lp_host_msdfs(lp_ctx)) {
+ if (!lpcfg_host_msdfs(lp_ctx)) {
return NT_STATUS_NOT_IMPLEMENTED;
}
return dodomain_referral(op, &dfsreq, ldb, trans, lp_ctx);
}
- realm = lp_realm(lp_ctx);
- nbname = lp_netbios_name(lp_ctx);
+ realm = lpcfg_realm(lp_ctx);
+ nbname = lpcfg_netbios_name(lp_ctx);
fqdn = talloc_asprintf(context, "%s.%s", nbname, realm);
if ((strncasecmp(requestedname+1, nbname, strlen(nbname)) == 0) ||
boot_time = timeval_current(); /* TODO: fix me */
ZERO_STRUCT(io->out);
- switch (lp_server_signing(req->smb_conn->lp_ctx)) {
+ switch (lpcfg_server_signing(req->smb_conn->lp_ctx)) {
case SMB_SIGNING_OFF:
io->out.security_mode = 0;
break;
}
io->out.dialect_revision = dialect;
io->out.capabilities = 0;
- io->out.max_transact_size = lp_parm_ulong(req->smb_conn->lp_ctx, NULL,
+ io->out.max_transact_size = lpcfg_parm_ulong(req->smb_conn->lp_ctx, NULL,
"smb2", "max transaction size", 0x10000);
- io->out.max_read_size = lp_parm_ulong(req->smb_conn->lp_ctx, NULL,
+ io->out.max_read_size = lpcfg_parm_ulong(req->smb_conn->lp_ctx, NULL,
"smb2", "max read size", 0x10000);
- io->out.max_write_size = lp_parm_ulong(req->smb_conn->lp_ctx, NULL,
+ io->out.max_write_size = lpcfg_parm_ulong(req->smb_conn->lp_ctx, NULL,
"smb2", "max write size", 0x10000);
io->out.system_time = timeval_to_nttime(¤t_time);
io->out.server_start_time = timeval_to_nttime(&boot_time);
/* this is the size that w2k uses, and it appears to be important for
good performance */
- smb_conn->negotiate.max_recv = lp_max_xmit(smb_conn->lp_ctx);
+ smb_conn->negotiate.max_recv = lpcfg_max_xmit(smb_conn->lp_ctx);
smb_conn->negotiate.zone_offset = get_time_zone(time(NULL));
close(i);
}
- prog = lp_parm_string(conn->lp_ctx, NULL, "samba3", "smbd");
+ prog = lpcfg_parm_string(conn->lp_ctx, NULL, "samba3", "smbd");
if (prog == NULL) {
argv[0] = talloc_asprintf(conn, "%s/%s", dyn_BINDIR, "smbd3");
const struct model_ops *model_ops,
const char *address)
{
- const char **ports = lp_smb_ports(lp_ctx);
+ const char **ports = lpcfg_smb_ports(lp_ctx);
int i;
NTSTATUS status;
status = stream_setup_socket(event_context, lp_ctx,
model_ops, &samba3_smb_stream_ops,
"ip", address, &port,
- lp_socket_options(lp_ctx),
+ lpcfg_socket_options(lp_ctx),
NULL);
NT_STATUS_NOT_OK_RETURN(status);
}
task_server_set_title(task, "task[samba3_smb]");
- if (lp_interfaces(task->lp_ctx)
- && lp_bind_interfaces_only(task->lp_ctx)) {
+ if (lpcfg_interfaces(task->lp_ctx)
+ && lpcfg_bind_interfaces_only(task->lp_ctx)) {
int num_interfaces;
int i;
struct interface *ifaces;
- load_interfaces(task, lp_interfaces(task->lp_ctx), &ifaces);
+ load_interfaces(task, lpcfg_interfaces(task->lp_ctx), &ifaces);
num_interfaces = iface_count(ifaces);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
} else {
- /* Just bind to lp_socket_address() (usually 0.0.0.0) */
+ /* Just bind to lpcfg_socket_address() (usually 0.0.0.0) */
status = samba3_add_socket(task->event_ctx, task->lp_ctx,
model_ops,
- lp_socket_address(task->lp_ctx));
+ lpcfg_socket_address(task->lp_ctx));
if (!NT_STATUS_IS_OK(status)) goto failed;
}
packet_set_callback(smb_conn->packet, smbsrv_recv_smb_request);
return smbsrv_recv_smb_request(smb_conn, blob);
case SMB2_MAGIC:
- if (lp_srv_maxprotocol(smb_conn->lp_ctx) < PROTOCOL_SMB2) break;
+ if (lpcfg_srv_maxprotocol(smb_conn->lp_ctx) < PROTOCOL_SMB2) break;
status = smbsrv_init_smb2_connection(smb_conn);
NT_STATUS_NOT_OK_RETURN(status);
packet_set_callback(smb_conn->packet, smbsrv_recv_smb2_request);
irpc_add_name(conn->msg_ctx, "smb_server");
- if (!NT_STATUS_IS_OK(share_get_context_by_name(smb_conn, lp_share_backend(smb_conn->lp_ctx),
+ if (!NT_STATUS_IS_OK(share_get_context_by_name(smb_conn, lpcfg_share_backend(smb_conn->lp_ctx),
smb_conn->connection->event.ctx,
smb_conn->lp_ctx, &(smb_conn->share_context)))) {
smbsrv_terminate_connection(smb_conn, "share_init failed!");
const struct model_ops *model_ops,
const char *address)
{
- const char **ports = lp_smb_ports(lp_ctx);
+ const char **ports = lpcfg_smb_ports(lp_ctx);
int i;
NTSTATUS status;
for (i=0;ports[i];i++) {
uint16_t port = atoi(ports[i]);
if (port == 0) continue;
- status = stream_setup_socket(event_context, lp_ctx,
+ status = stream_setup_socket(event_context, lp_ctx,
model_ops, &smb_stream_ops,
"ipv4", address, &port,
- lp_socket_options(lp_ctx),
+ lpcfg_socket_options(lp_ctx),
NULL);
NT_STATUS_NOT_OK_RETURN(status);
}
task_server_set_title(task, "task[smbsrv]");
- if (lp_interfaces(task->lp_ctx) && lp_bind_interfaces_only(task->lp_ctx)) {
+ if (lpcfg_interfaces(task->lp_ctx) && lpcfg_bind_interfaces_only(task->lp_ctx)) {
int num_interfaces;
int i;
struct interface *ifaces;
- load_interfaces(task, lp_interfaces(task->lp_ctx), &ifaces);
+ load_interfaces(task, lpcfg_interfaces(task->lp_ctx), &ifaces);
num_interfaces = iface_count(ifaces);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
} else {
- /* Just bind to lp_socket_address() (usually 0.0.0.0) */
- status = smbsrv_add_socket(task->event_ctx, task->lp_ctx, task->model_ops,
- lp_socket_address(task->lp_ctx));
+ /* Just bind to lpcfg_socket_address() (usually 0.0.0.0) */
+ status = smbsrv_add_socket(task->event_ctx, task->lp_ctx, task->model_ops,
+ lpcfg_socket_address(task->lp_ctx));
if (!NT_STATUS_IS_OK(status)) goto failed;
}
/* function to create a task */
void (*new_task)(struct tevent_context *,
- struct loadparm_context *lp_ctx,
+ struct loadparm_context *lp_ctx,
const char *service_name,
void (*)(struct tevent_context *,
struct loadparm_context *, struct server_id,
void *);
/* function to terminate a connection or task */
- void (*terminate)(struct tevent_context *, struct loadparm_context *lp_ctx,
+ void (*terminate)(struct tevent_context *, struct loadparm_context *lp_ctx,
const char *reason);
/* function to set a title for the connection or task */
static void prefork_new_task(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *service_name,
- void (*new_task_fn)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
+ void (*new_task_fn)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
void *private_data)
{
pid_t pid;
/* setup this new connection: process will bind to it's sockets etc */
new_task_fn(ev2, lp_ctx, cluster_id(pid, 0), private_data);
- num_children = lp_parm_int(lp_ctx, NULL, "prefork children", service_name, 0);
+ num_children = lpcfg_parm_int(lp_ctx, NULL, "prefork children", service_name, 0);
if (num_children == 0) {
/* We don't want any kids hanging around for this one,
/* The cluster_id(0, fd) cannot collide with the incrementing
* task below, as the first component is 0, not 1 */
- new_conn(ev, lp_ctx, connected_socket,
+ new_conn(ev, lp_ctx, connected_socket,
cluster_id(0, socket_get_fd(connected_socket)), private_data);
}
called to startup a new task
*/
static void single_new_task(struct tevent_context *ev,
- struct loadparm_context *lp_ctx,
+ struct loadparm_context *lp_ctx,
const char *service_name,
void (*new_task)(struct tevent_context *, struct loadparm_context *, struct server_id, void *),
void *private_data)
/* called when a task goes down */
-static void single_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx, const char *reason)
+static void single_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx, const char *reason)
{
DEBUG(3,("single_terminate: reason[%s]\n",reason));
}
static void standard_new_task(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *service_name,
- void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
+ void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
void *private_data)
{
pid_t pid;
/* called when a task goes down */
-_NORETURN_ static void standard_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx,
+_NORETURN_ static void standard_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx,
const char *reason)
{
DEBUG(2,("standard_terminate: reason[%s]\n",reason));
called when a listening socket becomes readable
*/
static void thread_accept_connection(struct tevent_context *ev,
- struct loadparm_context *lp_ctx,
+ struct loadparm_context *lp_ctx,
struct socket_context *sock,
void (*new_conn)(struct tevent_context *,
struct loadparm_context *,
{
struct new_task_state *new_task = talloc_get_type(thread_parm, struct new_task_state);
- new_task->new_task(new_task->ev, new_task->lp_ctx, pthread_self(),
+ new_task->new_task(new_task->ev, new_task->lp_ctx, pthread_self(),
new_task->private_data);
/* run this connection from here */
}
/* called when a task goes down */
-static void thread_terminate(struct tevent_context *event_ctx, struct loadparm_context *lp_ctx, const char *reason)
+static void thread_terminate(struct tevent_context *event_ctx, struct loadparm_context *lp_ctx, const char *reason)
{
DEBUG(10,("thread_terminate: reason[%s]\n",reason));
NTSTATUS status;
msg = messaging_init(talloc_autofree_context(),
- lp_messaging_path(event_ctx, lp_ctx),
+ lpcfg_messaging_path(event_ctx, lp_ctx),
cluster_id(0, SAMBA_PARENT_TASKID), event_ctx);
NT_STATUS_HAVE_NO_MEMORY(msg);
cleanup_tmp_files(cmdline_lp_ctx);
- if (!directory_exist(lp_lockdir(cmdline_lp_ctx))) {
- mkdir(lp_lockdir(cmdline_lp_ctx), 0755);
+ if (!directory_exist(lpcfg_lockdir(cmdline_lp_ctx))) {
+ mkdir(lpcfg_lockdir(cmdline_lp_ctx), 0755);
}
- pidfile_create(lp_piddir(cmdline_lp_ctx), binary_name);
+ pidfile_create(lpcfg_piddir(cmdline_lp_ctx), binary_name);
/* Do *not* remove this, until you have removed
* passdb/secrets.c, and proved that Samba still builds... */
return 1;
}
- if (lp_server_role(cmdline_lp_ctx) == ROLE_DOMAIN_CONTROLLER) {
- if (!open_schannel_session_store(talloc_autofree_context(), lp_private_dir(cmdline_lp_ctx))) {
+ if (lpcfg_server_role(cmdline_lp_ctx) == ROLE_DOMAIN_CONTROLLER) {
+ if (!open_schannel_session_store(talloc_autofree_context(), lpcfg_private_dir(cmdline_lp_ctx))) {
DEBUG(0,("ERROR: Samba cannot open schannel store for secured NETLOGON operations.\n"));
exit(1);
}
DEBUG(0,("%s: using '%s' process model\n", binary_name, model));
status = server_service_startup(event_ctx, cmdline_lp_ctx, model,
- lp_server_services(cmdline_lp_ctx));
+ lpcfg_server_services(cmdline_lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Starting Services failed - %s\n", nt_errstr(status)));
return 1;
goto fail;
}
- dirname = talloc_asprintf(pipe_sock, "%s/np", lp_ncalrpc_dir(lp_ctx));
+ dirname = talloc_asprintf(pipe_sock, "%s/np", lpcfg_ncalrpc_dir(lp_ctx));
if (dirname == NULL) {
goto fail;
}
srv_conn->event.ctx = ev;
srv_conn->lp_ctx = lp_ctx;
- if (!socket_check_access(sock, "smbd", lp_hostsallow(NULL, lp_default_service(lp_ctx)), lp_hostsdeny(NULL, lp_default_service(lp_ctx)))) {
+ if (!socket_check_access(sock, "smbd", lpcfg_hostsallow(NULL, lpcfg_default_service(lp_ctx)), lpcfg_hostsdeny(NULL, lpcfg_default_service(lp_ctx)))) {
stream_terminate_connection(srv_conn, "denied by access rules");
return;
}
/* setup to receive internal messages on this connection */
srv_conn->msg_ctx = messaging_init(srv_conn,
- lp_messaging_path(srv_conn, lp_ctx),
+ lpcfg_messaging_path(srv_conn, lp_ctx),
srv_conn->server_id, ev);
if (!srv_conn->msg_ctx) {
stream_terminate_connection(srv_conn, "messaging_init() failed");
/* ask the process model to create us a process for this new
connection. When done, it calls stream_new_connection()
with the newly created socket */
- stream_socket->model_ops->accept_connection(ev, stream_socket->lp_ctx,
+ stream_socket->model_ops->accept_connection(ev, stream_socket->lp_ctx,
stream_socket->sock,
stream_new_connection, stream_socket);
}
task->lp_ctx = lp_ctx;
task->msg_ctx = messaging_init(task,
- lp_messaging_path(task, task->lp_ctx),
+ lpcfg_messaging_path(task, task->lp_ctx),
task->server_id,
task->event_ctx);
if (!task->msg_ctx) {
torture_assert_ntstatus_ok(tctx,
gensec_client_start(mem_ctx, &gensec_security,
- tctx->ev, lp_gensec_settings(tctx, tctx->lp_ctx)),
+ tctx->ev, lpcfg_gensec_settings(tctx, tctx->lp_ctx)),
"gensec client start");
gensec_set_credentials(gensec_security, cmdline_credentials);
torture_assert_ntstatus_ok(tctx,
gensec_client_start(mem_ctx, &gensec_security,
- tctx->ev, lp_gensec_settings(tctx, tctx->lp_ctx)),
+ tctx->ev, lpcfg_gensec_settings(tctx, tctx->lp_ctx)),
"Failed to start GENSEC for NTLMSSP");
gensec_set_credentials(gensec_security, cmdline_credentials);
}
/* We need an input, and this one requires no underlying database */
- nt_status = auth_anonymous_server_info(mem_ctx, lp_netbios_name(tctx->lp_ctx), &server_info);
+ nt_status = auth_anonymous_server_info(mem_ctx, lpcfg_netbios_name(tctx->lp_ctx), &server_info);
if (!NT_STATUS_IS_OK(nt_status)) {
krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
const char *host = torture_setting_string(tctx, "host", NULL);
struct smbcli_options options;
- make_nbt_name_client(&calling, lp_netbios_name(tctx->lp_ctx));
+ make_nbt_name_client(&calling, lpcfg_netbios_name(tctx->lp_ctx));
nbt_choose_called_name(NULL, &called, host, NBT_NAME_SERVER);
goto failed;
}
- lp_smbcli_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &options);
- if (!smbcli_socket_connect(cli, host, lp_smb_ports(tctx->lp_ctx), tctx->ev,
- lp_resolve_context(tctx->lp_ctx), &options,
- lp_socket_options(tctx->lp_ctx))) {
+ if (!smbcli_socket_connect(cli, host, lpcfg_smb_ports(tctx->lp_ctx), tctx->ev,
+ lpcfg_resolve_context(tctx->lp_ctx), &options,
+ lpcfg_socket_options(tctx->lp_ctx))) {
torture_comment(tctx, "Failed to connect with %s\n", host);
goto failed;
}
for (i=0;i<100;i++) {
struct smbcli_request *req;
- req = smb_raw_negotiate_send(cli->transport, lp_unicode(tctx->lp_ctx), PROTOCOL_NT1);
+ req = smb_raw_negotiate_send(cli->transport, lpcfg_unicode(tctx->lp_ctx), PROTOCOL_NT1);
event_loop_once(cli->transport->socket->event.ctx);
if (req->state == SMBCLI_REQUEST_ERROR) {
if (i > 0) {
union smb_open io;
NTSTATUS status;
- nt_status_support = lp_nt_status_support(tctx->lp_ctx);
+ nt_status_support = lpcfg_nt_status_support(tctx->lp_ctx);
- if (!lp_set_cmdline(tctx->lp_ctx, "nt status support", "yes")) {
+ if (!lpcfg_set_cmdline(tctx->lp_ctx, "nt status support", "yes")) {
torture_comment(tctx, "Could not set 'nt status support = yes'\n");
goto fail;
}
goto fail;
}
- if (!lp_set_cmdline(tctx->lp_ctx, "nt status support", "no")) {
+ if (!lpcfg_set_cmdline(tctx->lp_ctx, "nt status support", "no")) {
torture_comment(tctx, "Could not set 'nt status support = yes'\n");
goto fail;
}
goto fail;
}
- if (!lp_set_cmdline(tctx->lp_ctx, "nt status support",
+ if (!lpcfg_set_cmdline(tctx->lp_ctx, "nt status support",
nt_status_support ? "yes":"no")) {
torture_comment(tctx, "Could not reset 'nt status support = yes'");
goto fail;
}
SSVAL(ucs_name, i*2, 0);
- if (!convert_string_talloc_convenience(ucs_name, lp_iconv_convenience(tctx->lp_ctx), CH_UTF16, CH_UNIX, ucs_name, (1+u_name_len)*2, (void **)&fname, &i, false)) {
+ if (!convert_string_talloc_convenience(ucs_name, lpcfg_iconv_convenience(tctx->lp_ctx), CH_UTF16, CH_UNIX, ucs_name, (1+u_name_len)*2, (void **)&fname, &i, false)) {
torture_comment(tctx, "Failed to convert UCS2 Name into unix - convert_string_talloc() failure\n");
talloc_free(ucs_name);
return NT_STATUS_NO_MEMORY;
unsigned int blocksize;
unsigned int writeratio;
int num_parallel_requests;
- } *lp_params;
+ } *lpcfg_params;
};
/*
- init params using lp_parm_xxx
+ init params using lpcfg_parm_xxx
return number of unclist entries
*/
static int init_benchrw_params(struct torture_context *tctx,
lpar->writeratio = torture_setting_int(tctx, "writeratio",5);
lpar->num_parallel_requests = torture_setting_int(
tctx, "parallel_requests", 5);
- lpar->workgroup = lp_workgroup(tctx->lp_ctx);
+ lpar->workgroup = lpcfg_workgroup(tctx->lp_ctx);
p = torture_setting_string(tctx, "unclist", NULL);
if (p) {
union smb_write wr;
/* randomize between writes and reads*/
- if (random() % state->lp_params->writeratio == 0) {
+ if (random() % state->lpcfg_params->writeratio == 0) {
torture_comment(tctx, "Callback WRITE file:%d (%d/%d)\n",
state->nr,state->completed,torture_numops);
wr.generic.level = RAW_WRITE_WRITEX ;
wr.writex.in.offset = 0;
wr.writex.in.wmode = 0 ;
wr.writex.in.remaining = 0;
- wr.writex.in.count = state->lp_params->blocksize;
+ wr.writex.in.count = state->lpcfg_params->blocksize;
wr.writex.in.data = state->buffer;
state->readcnt=0;
req = smb_raw_write_send(state->cli,&wr);
torture_comment(tctx,
"Callback READ file:%d (%d/%d) Offset:%d\n",
state->nr,state->completed,torture_numops,
- (state->readcnt*state->lp_params->blocksize));
+ (state->readcnt*state->lpcfg_params->blocksize));
rd.generic.level = RAW_READ_READX;
rd.readx.in.file.fnum = state->fnum ;
- rd.readx.in.offset = state->readcnt*state->lp_params->blocksize;
- rd.readx.in.mincnt = state->lp_params->blocksize;
+ rd.readx.in.offset = state->readcnt*state->lpcfg_params->blocksize;
+ rd.readx.in.mincnt = state->lpcfg_params->blocksize;
rd.readx.in.maxcnt = rd.readx.in.mincnt;
rd.readx.in.remaining = 0 ;
rd.readx.out.data = state->buffer;
rd.readx.in.read_for_execute = false;
- if(state->readcnt < state->lp_params->writeblocks){
+ if(state->readcnt < state->lpcfg_params->writeblocks){
state->readcnt++;
}else{
/*start reading from beginn of file*/
}
torture_comment(tctx, "Write initial test file:%d (%d/%d)\n",state->nr,
- (state->writecnt+1)*state->lp_params->blocksize,
- (state->lp_params->writeblocks*state->lp_params->blocksize));
+ (state->writecnt+1)*state->lpcfg_params->blocksize,
+ (state->lpcfg_params->writeblocks*state->lpcfg_params->blocksize));
wr.generic.level = RAW_WRITE_WRITEX ;
wr.writex.in.file.fnum = state->fnum ;
wr.writex.in.offset = state->writecnt *
- state->lp_params->blocksize;
+ state->lpcfg_params->blocksize;
wr.writex.in.wmode = 0 ;
- wr.writex.in.remaining = (state->lp_params->writeblocks *
- state->lp_params->blocksize)-
+ wr.writex.in.remaining = (state->lpcfg_params->writeblocks *
+ state->lpcfg_params->blocksize)-
((state->writecnt+1)*state->
- lp_params->blocksize);
- wr.writex.in.count = state->lp_params->blocksize;
+ lpcfg_params->blocksize);
+ wr.writex.in.count = state->lpcfg_params->blocksize;
wr.writex.in.data = state->buffer;
state->writecnt++;
- if(state->writecnt == state->lp_params->writeblocks){
+ if(state->writecnt == state->lpcfg_params->writeblocks){
state->mode=READ_WRITE_DATA;
}
req = smb_raw_write_send(state->cli,&wr);
open_parms->openx.in.timeout = 0;
open_parms->openx.in.fname = state->fname;
- writedata = talloc_size(tctx,state->lp_params->blocksize);
+ writedata = talloc_size(tctx,state->lpcfg_params->blocksize);
NT_STATUS_HAVE_NO_MEMORY(writedata);
- generate_random_buffer(writedata,state->lp_params->blocksize);
+ generate_random_buffer(writedata,state->lpcfg_params->blocksize);
state->buffer=writedata;
state->writecnt=1;
state->readcnt=0;
break;
case READ_WRITE_DATA:
while (state->num_parallel_requests
- < state->lp_params->num_parallel_requests) {
+ < state->lpcfg_params->num_parallel_requests) {
NTSTATUS status;
status = benchrw_readwrite(tctx,state);
if (!NT_STATUS_IS_OK(status)){
{
struct benchrw_state *state = con->async.private_data;
struct torture_context *tctx = state->tctx;
- int retry = state->lp_params->retry;
+ int retry = state->lpcfg_params->retry;
if (NT_STATUS_IS_OK(con->status)) {
state->cli=((struct smb_composite_connect*)
torture_comment(tctx, "Open Connection to %s/%s\n",host,share);
smb->in.dest_host=talloc_strdup(mem_ctx,host);
smb->in.service=talloc_strdup(mem_ctx,share);
- smb->in.dest_ports=lp_smb_ports(tctx->lp_ctx);
- smb->in.socket_options = lp_socket_options(tctx->lp_ctx);
+ smb->in.dest_ports=lpcfg_smb_ports(tctx->lp_ctx);
+ smb->in.socket_options = lpcfg_socket_options(tctx->lp_ctx);
smb->in.called_name = strupper_talloc(mem_ctx, host);
smb->in.service_type=NULL;
smb->in.credentials=cmdline_credentials;
smb->in.fallback_to_anonymous=false;
- smb->in.gensec_settings = lp_gensec_settings(mem_ctx, tctx->lp_ctx);
+ smb->in.gensec_settings = lpcfg_gensec_settings(mem_ctx, tctx->lp_ctx);
smb->in.workgroup=workgroup;
- lp_smbcli_options(tctx->lp_ctx, &smb->in.options);
- lp_smbcli_session_options(tctx->lp_ctx, &smb->in.session_options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &smb->in.options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &smb->in.session_options);
return smb_composite_connect_send(smb,mem_ctx,
- lp_resolve_context(tctx->lp_ctx),ev);
+ lpcfg_resolve_context(tctx->lp_ctx),ev);
}
bool run_benchrw(struct torture_context *tctx)
ev = tctx->ev;
state = talloc_array(tctx, struct benchrw_state *, torture_nprocs);
- /* init params using lp_parm_xxx */
+ /* init params using lpcfg_parm_xxx */
num_unc_names = init_benchrw_params(tctx,&lpparams);
/* init private data structs*/
state[i]->tctx = tctx;
state[i]->completed=0;
state[i]->num_parallel_requests=0;
- state[i]->lp_params=&lpparams;
+ state[i]->lpcfg_params=&lpparams;
state[i]->nr=i;
state[i]->dname=talloc_asprintf(tctx,"benchrw%d",i);
state[i]->fname=talloc_asprintf(tctx,"%s%s",
struct smbcli_session *session;
struct smbcli_session_options options;
- lp_smbcli_session_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &options);
session = smbcli_session_init(cli->transport, cli, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
- setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
setup.in.credentials = cli_credentials_init(session);
- setup.in.gensec_settings = lp_gensec_settings(tctx, tctx->lp_ctx);
+ setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
cli_credentials_set_conf(setup.in.credentials, tctx->lp_ctx);
cli_credentials_set_domain(setup.in.credentials, "INVALID-DOMAIN", CRED_SPECIFIED);
NTSTATUS status;
struct smbcli_options smb_options;
struct smbcli_session_options smb_session_options;
- lp_smbcli_options(lp_ctx, &smb_options);
- lp_smbcli_session_options(lp_ctx, &smb_session_options);
+ lpcfg_smbcli_options(lp_ctx, &smb_options);
+ lpcfg_smbcli_session_options(lp_ctx, &smb_session_options);
printf("Connecting to \\\\%s\\%s as %s - instance %d\n",
servers[i].server_name, servers[i].share_name,
if (options.smb2) {
status = smb2_connect(NULL, servers[i].server_name,
- lp_smb_ports(lp_ctx),
+ lpcfg_smb_ports(lp_ctx),
servers[i].share_name,
- lp_resolve_context(lp_ctx),
+ lpcfg_resolve_context(lp_ctx),
servers[i].credentials,
&servers[i].smb2_tree[j],
ev, &smb_options,
- lp_socket_options(lp_ctx),
- lp_gensec_settings(lp_ctx, lp_ctx)
+ lpcfg_socket_options(lp_ctx),
+ lpcfg_gensec_settings(lp_ctx, lp_ctx)
);
} else {
status = smbcli_tree_full_connection(NULL,
&servers[i].smb_tree[j],
servers[i].server_name,
- lp_smb_ports(lp_ctx),
+ lpcfg_smb_ports(lp_ctx),
servers[i].share_name, "A:",
- lp_socket_options(lp_ctx),
+ lpcfg_socket_options(lp_ctx),
servers[i].credentials,
- lp_resolve_context(lp_ctx), ev,
+ lpcfg_resolve_context(lp_ctx), ev,
&smb_options,
&smb_session_options,
- lp_gensec_settings(lp_ctx, lp_ctx));
+ lpcfg_gensec_settings(lp_ctx, lp_ctx));
}
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to connect to \\\\%s\\%s - %s\n",
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_UNCLIST:
- lp_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
break;
case 'U':
if (username_count == 2) {
ret = tsocket_address_inet_from_strings(tctx, "ip",
dest,
- lp_cldap_port(tctx->lp_ctx),
+ lpcfg_cldap_port(tctx->lp_ctx),
&dest_addr);
CHECK_VAL(ret, 0);
ret = tsocket_address_inet_from_strings(tctx, "ip",
dest,
- lp_cldap_port(tctx->lp_ctx),
+ lpcfg_cldap_port(tctx->lp_ctx),
&dest_addr);
CHECK_VAL(ret, 0);
ret = tsocket_address_inet_from_strings(tctx, "ip",
dest,
- lp_cldap_port(tctx->lp_ctx),
+ lpcfg_cldap_port(tctx->lp_ctx),
&dest_addr);
CHECK_VAL(ret, 0);
"rootDomainNamingContext" */
ZERO_STRUCT(search2);
search2.in.dest_address = dest;
- search2.in.dest_port = lp_cldap_port(tctx->lp_ctx);
+ search2.in.dest_port = lpcfg_cldap_port(tctx->lp_ctx);
search2.in.timeout = 10;
search2.in.retries = 3;
search2.in.filter = "(objectclass=*)";
ret = tsocket_address_inet_from_strings(tctx, "ip",
dest,
- lp_cldap_port(tctx->lp_ctx),
+ lpcfg_cldap_port(tctx->lp_ctx),
&dest_addr);
CHECK_VAL(ret, 0);
ret = tsocket_address_inet_from_strings(tctx, "ip",
address,
- lp_cldap_port(tctx->lp_ctx),
+ lpcfg_cldap_port(tctx->lp_ctx),
&dest_addr);
CHECK_VAL(ret, 0);
ret = tsocket_address_inet_from_strings(tctx, "ip",
address,
- lp_cldap_port(tctx->lp_ctx),
+ lpcfg_cldap_port(tctx->lp_ctx),
&dest_addr);
CHECK_VAL(ret, 0);
make_nbt_name_server(&name, torture_setting_string(torture, "host", NULL));
/* do an initial name resolution to find its IP */
- status = resolve_name(lp_resolve_context(torture->lp_ctx), &name, torture, &address, torture->ev);
+ status = resolve_name(lpcfg_resolve_context(torture->lp_ctx), &name, torture, &address, torture->ev);
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to resolve %s - %s\n",
name.name, nt_errstr(status));
return false;
}
- name.string = lp_workgroup(torture->lp_ctx);
+ name.string = lpcfg_workgroup(torture->lp_ctx);
/*
* Testing synchronous version
}
b = p->binding_handle;
- name.string = lp_workgroup(torture->lp_ctx);
+ name.string = lpcfg_workgroup(torture->lp_ctx);
/*
* Testing synchronous version
torture_assert_ntstatus_ok(torture, status, "RPC connection");
b = p->binding_handle;
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) {
ret = false;
goto done;
torture_assert_ntstatus_ok(torture, torture_temp_dir(torture, "libnet_BecomeDC", &location),
"torture_temp_dir should return NT_STATUS_OK" );
- netbios_name = lp_parm_string(torture->lp_ctx, NULL, "become dc", "smbtorture dc");
+ netbios_name = lpcfg_parm_string(torture->lp_ctx, NULL, "become dc", "smbtorture dc");
if (!netbios_name || !netbios_name[0]) {
netbios_name = "smbtorturedc";
}
make_nbt_name_server(&name, torture_setting_string(torture, "host", NULL));
/* do an initial name resolution to find its IP */
- status = resolve_name(lp_resolve_context(torture->lp_ctx),
+ status = resolve_name(lpcfg_resolve_context(torture->lp_ctx),
&name, torture, &address, torture->ev);
torture_assert_ntstatus_ok(torture, status, talloc_asprintf(torture,
"Failed to resolve %s - %s\n",
"Failed to get loaded dsdb_schema\n");
/* Make sure we get this from the command line */
- if (lp_parm_bool(torture->lp_ctx, NULL, "become dc", "do not unjoin", false)) {
+ if (lpcfg_parm_bool(torture->lp_ctx, NULL, "become dc", "do not unjoin", false)) {
talloc_free(s);
return ret;
}
/* we're accessing domain controller so the domain name should be
passed (it's going to be resolved to dc name and address) instead
of specific server name. */
- domain_name = lp_workgroup(torture->lp_ctx);
+ domain_name = lpcfg_workgroup(torture->lp_ctx);
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
if (ctx == NULL) {
goto done;
}
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
if (!test_opendomain_lsa(torture, p->binding_handle, torture, &h, &domain_name, &access_mask)) {
torture_comment(torture, "failed to open domain on lsa service\n");
/* we're accessing domain controller so the domain name should be
passed (it's going to be resolved to dc name and address) instead
of specific server name. */
- domain_name = lp_workgroup(torture->lp_ctx);
+ domain_name = lpcfg_workgroup(torture->lp_ctx);
/*
* Testing synchronous version
goto done;
}
- domain_name.string = talloc_strdup(mem_ctx, lp_workgroup(torture->lp_ctx));
+ domain_name.string = talloc_strdup(mem_ctx, lpcfg_workgroup(torture->lp_ctx));
if (!test_opendomain_samr(torture, p->binding_handle, torture, &h, &domain_name, &access_mask, &sid)) {
torture_comment(torture, "failed to open domain on samr service\n");
return false;
}
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
if (!test_domain_open(torture, p->binding_handle, &domain_name, prep_mem_ctx, &h, NULL)) {
ret = false;
goto done;
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
ctx->cred = cmdline_credentials;
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
mem_ctx = talloc_init("torture group list");
ZERO_STRUCT(req);
ctx->cred = cmdline_credentials;
req.in.group_name = TEST_GROUPNAME;
- req.in.domain_name = lp_workgroup(torture->lp_ctx);
+ req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
req.out.error_string = NULL;
status = libnet_CreateGroup(ctx, mem_ctx, &req);
goto done;
}
- lookup->in.domain_name = lp_workgroup(torture->lp_ctx);
+ lookup->in.domain_name = lpcfg_workgroup(torture->lp_ctx);
lookup->in.name_type = NBT_NAME_PDC;
status = libnet_LookupDCs(ctx, mem_ctx, lookup);
if (mem_ctx == NULL) return false;
r.in.name = "Administrator";
- r.in.domain_name = lp_workgroup(torture->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
status = libnet_LookupName(ctx, mem_ctx, &r);
/* we're accessing domain controller so the domain name should be
passed (it's going to be resolved to dc name and address) instead
of specific server name. */
- domain_name = lp_workgroup(torture->lp_ctx);
+ domain_name = lpcfg_workgroup(torture->lp_ctx);
return torture_rpc_connect(torture, level, NULL, domain_name);
}
/* we're accessing domain controller so the domain name should be
passed (it's going to be resolved to dc name and address) instead
of specific server name. */
- domain_name = lp_workgroup(torture->lp_ctx);
+ domain_name = lpcfg_workgroup(torture->lp_ctx);
return torture_rpc_connect(torture, level, NULL, domain_name);
}
/* we're accessing domain controller so the domain name should be
passed (it's going to be resolved to dc name and address) instead
of specific server name. */
- domain_name = lp_workgroup(torture->lp_ctx);
+ domain_name = lpcfg_workgroup(torture->lp_ctx);
return torture_rpc_connect(torture, level, NULL, domain_name);
}
}
req.in.user_name = TEST_USERNAME;
- req.in.domain_name = lp_workgroup(torture->lp_ctx);
+ req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
req.out.error_string = NULL;
status = libnet_CreateUser(ctx, mem_ctx, &req);
prep_mem_ctx = talloc_init("prepare test_deleteuser");
req.in.user_name = TEST_USERNAME;
- req.in.domain_name = lp_workgroup(torture->lp_ctx);
+ req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
status = torture_rpc_connection(torture,
&p,
goto done;
}
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
if (!test_domain_open(torture, p->binding_handle, &domain_name, prep_mem_ctx, &h, NULL)) {
ret = false;
goto done;
name = talloc_strdup(prep_mem_ctx, TEST_USERNAME);
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
if (!test_domain_open(torture, b, &domain_name, prep_mem_ctx, &h, NULL)) {
ret = false;
goto done;
for (fld = USER_FIELD_FIRST; fld <= USER_FIELD_LAST; fld++) {
ZERO_STRUCT(req);
- req.in.domain_name = lp_workgroup(torture->lp_ctx);
+ req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
req.in.user_name = name;
set_test_changes(torture, torture, &req, 1, &name, fld);
}
ZERO_STRUCT(user_req);
- user_req.in.domain_name = lp_workgroup(torture->lp_ctx);
+ user_req.in.domain_name = lpcfg_workgroup(torture->lp_ctx);
user_req.in.data.user_name = name;
user_req.in.level = USER_INFO_BY_NAME;
}
b = p->binding_handle;
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
if (!test_domain_open(torture, b, &domain_name, prep_mem_ctx, &h, NULL)) {
ret = false;
goto done;
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
ctx->cred = cmdline_credentials;
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
mem_ctx = talloc_init("torture user list");
ZERO_STRUCT(req);
}
b = p->binding_handle;
- name.string = lp_workgroup(torture->lp_ctx);
+ name.string = lpcfg_workgroup(torture->lp_ctx);
/*
* Testing synchronous version
torture_assert_ntstatus_ok(torture, status, "RPC connect failed");
b = p->binding_handle;
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) {
ret = false;
goto done;
}
b = p->binding_handle;
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) {
ret = false;
goto done;
torture_assert_ntstatus_ok(torture, status, "RPC connect");
b = p->binding_handle;
- domain_name.string = lp_workgroup(torture->lp_ctx);
+ domain_name.string = lpcfg_workgroup(torture->lp_ctx);
name = talloc_strdup(mem_ctx, TEST_USERNAME);
if (!test_domain_open(torture, b, &domain_name, mem_ctx, &h, &sid)) {
torture_comment(torture, "Testing ldb speed for sidmap\n");
- ldb = ldb_wrap_connect(tmp_ctx, torture->ev, torture->lp_ctx, "tdb://test.ldb",
+ ldb = ldb_wrap_connect(tmp_ctx, torture->ev, torture->lp_ctx, "tdb://test.ldb",
NULL, NULL, LDB_FLG_NOSYNC);
if (!ldb) {
torture_result(torture, TORTURE_FAIL, "Failed to open test.ldb");
struct smbcli_options options;
struct smbcli_session_options session_options;
- lp_smbcli_options(lp_ctx, &options);
- lp_smbcli_session_options(lp_ctx, &session_options);
+ lpcfg_smbcli_options(lp_ctx, &options);
+ lpcfg_smbcli_session_options(lp_ctx, &session_options);
printf("connect_one(%s, %d, %d)\n", share, snum, conn);
char **unc_list = NULL;
int num_unc_names;
const char *p;
- p = lp_parm_string(lp_ctx, NULL, "torture", "unclist");
+ p = lpcfg_parm_string(lp_ctx, NULL, "torture", "unclist");
if (p) {
char *h, *s;
unc_list = file_lines_load(p, &num_unc_names, 0, NULL);
printf("\\\\%s\\%s\n", server, share);
status = smbcli_full_connection(NULL, &c,
server,
- lp_smb_ports(lp_ctx),
+ lpcfg_smb_ports(lp_ctx),
share, NULL,
- lp_socket_options(lp_ctx),
+ lpcfg_socket_options(lp_ctx),
servers[snum],
- lp_resolve_context(lp_ctx),
+ lpcfg_resolve_context(lp_ctx),
ev, &options, &session_options,
- lp_gensec_settings(mem_ctx, lp_ctx));
+ lpcfg_gensec_settings(mem_ctx, lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
sleep(2);
}
}
talloc_free(cli[server][conn]);
}
- cli[server][conn] = connect_one(ev, lp_ctx, mem_ctx, share[server],
+ cli[server][conn] = connect_one(ev, lp_ctx, mem_ctx, share[server],
server, conn);
if (!cli[server][conn]) {
DEBUG(0,("Failed to connect to %s\n", share[server]));
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_UNCLIST:
- lp_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
break;
case 'U':
if (username_count == 2) {
nt_status = smbcli_full_connection(NULL,
&c, myname, server_n, ports, share, NULL,
- username, lp_workgroup(), password, ev,
+ username, lpcfg_workgroup(), password, ev,
options, session_options, gensec_settings);
if (!NT_STATUS_IS_OK(nt_status)) {
DEBUG(0, ("smbcli_full_connection failed with error %s\n", nt_errstr(nt_status)));
argv += 4;
lp_ctx = loadparm_init(mem_ctx);
- lp_load(lp_ctx, dyn_CONFIGFILE);
+ lpcfg_load(lp_ctx, dyn_CONFIGFILE);
if (getenv("USER")) {
username = talloc_strdup(mem_ctx, getenv("USER"));
ev = s4_event_context_init(mem_ctx);
locking_init(1);
- lp_smbcli_options(lp_ctx, &options);
- lp_smbcli_session_options(lp_ctx, &session_options);
+ lpcfg_smbcli_options(lp_ctx, &options);
+ lpcfg_smbcli_session_options(lp_ctx, &session_options);
test_locks(mem_ctx, share1, share2, nfspath1, nfspath2,
- lp_smb_ports(lp_ctx),
- &options, &session_options, lp_gensec_settings(lp_ctx), ev);
+ lpcfg_smb_ports(lp_ctx),
+ &options, &session_options, lpcfg_gensec_settings(lp_ctx), ev);
return(0);
}
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_UNCLIST:
- lp_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
break;
}
}
gensec_init(lp_ctx);
- lp_smbcli_options(lp_ctx, &options);
- lp_smbcli_session_options(lp_ctx, &session_options);
+ lpcfg_smbcli_options(lp_ctx, &options);
+ lpcfg_smbcli_session_options(lp_ctx, &session_options);
- cli = connect_one(lp_resolve_context(lp_ctx), ev, mem_ctx, share,
- lp_smb_ports(lp_ctx), lp_socket_options(lp_ctx),
+ cli = connect_one(lpcfg_resolve_context(lp_ctx), ev, mem_ctx, share,
+ lpcfg_smb_ports(lp_ctx), lpcfg_socket_options(lp_ctx),
&options, &session_options,
- lp_gensec_settings(mem_ctx, lp_ctx));
+ lpcfg_gensec_settings(mem_ctx, lp_ctx));
if (!cli) {
DEBUG(0,("Failed to connect to %s\n", share));
exit(1);
NTSTATUS status;
bool ret = true;
- name.name = lp_workgroup();
+ name.name = lpcfg_workgroup();
name.type = NBT_NAME_BROWSER;
name.scope = NULL;
struct interface *ifaces;
- name.name = lp_workgroup(tctx->lp_ctx);
+ name.name = lpcfg_workgroup(tctx->lp_ctx);
name.type = NBT_NAME_LOGON;
name.scope = NULL;
/* do an initial name resolution to find its IP */
torture_assert_ntstatus_ok(tctx,
- resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
+ resolve_name(lpcfg_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
talloc_asprintf(tctx, "Failed to resolve %s", name.name));
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- myaddress, lp_dgram_port(tctx->lp_ctx));
+ myaddress, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, socket_address != NULL, "Error getting address");
/* try receiving replies on port 138 first, which will only
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- address, lp_dgram_port(tctx->lp_ctx));
+ address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
struct cli_credentials *machine_credentials;
const struct dom_sid *dom_sid;
- name.name = lp_workgroup(tctx->lp_ctx);
+ name.name = lpcfg_workgroup(tctx->lp_ctx);
name.type = NBT_NAME_LOGON;
name.scope = NULL;
/* do an initial name resolution to find its IP */
torture_assert_ntstatus_ok(tctx,
- resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
+ resolve_name(lpcfg_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
talloc_asprintf(tctx, "Failed to resolve %s", name.name));
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- myaddress, lp_dgram_port(tctx->lp_ctx));
+ myaddress, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, socket_address != NULL, "Error getting address");
/* try receiving replies on port 138 first, which will only
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- address, lp_dgram_port(tctx->lp_ctx));
+ address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- address, lp_dgram_port(tctx->lp_ctx));
+ address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
torture_assert(tctx, join_ctx != NULL,
talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
- lp_workgroup(tctx->lp_ctx), TEST_NAME));
+ lpcfg_workgroup(tctx->lp_ctx), TEST_NAME));
dom_sid = torture_join_sid(join_ctx);
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- address, lp_dgram_port(tctx->lp_ctx));
+ address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- address, lp_dgram_port(tctx->lp_ctx));
+ address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- address, lp_dgram_port(tctx->lp_ctx));
+ address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
struct interface *ifaces;
- name.name = lp_workgroup(tctx->lp_ctx);
+ name.name = lpcfg_workgroup(tctx->lp_ctx);
name.type = NBT_NAME_LOGON;
name.scope = NULL;
/* do an initial name resolution to find its IP */
torture_assert_ntstatus_ok(tctx,
- resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
+ resolve_name(lpcfg_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
talloc_asprintf(tctx, "Failed to resolve %s", name.name));
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- myaddress, lp_dgram_port(tctx->lp_ctx));
+ myaddress, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, socket_address != NULL, "Error getting address");
/* try receiving replies on port 138 first, which will only
torture_assert(tctx, join_ctx != NULL,
talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
- lp_workgroup(tctx->lp_ctx), TEST_NAME));
+ lpcfg_workgroup(tctx->lp_ctx), TEST_NAME));
/* setup a temporary mailslot listener for replies */
dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- address, lp_dgram_port(tctx->lp_ctx));
+ address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock,
&name, dest,
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- address, lp_dgram_port(tctx->lp_ctx));
+ address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock,
&name, dest,
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- address, lp_dgram_port(tctx->lp_ctx));
+ address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock,
&name, dest,
make_nbt_name_client(&myname, TEST_NAME);
dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- address, lp_dgram_port(tctx->lp_ctx));
+ address, lpcfg_dgram_port(tctx->lp_ctx));
torture_assert(tctx, dest != NULL, "Error getting address");
status = dgram_mailslot_netlogon_send(dgmsock,
&name, dest,
/* do an initial name resolution to find its IP */
torture_assert_ntstatus_ok(tctx,
- resolve_name(lp_resolve_context(tctx->lp_ctx), name, tctx, address, tctx->ev),
+ resolve_name(lpcfg_resolve_context(tctx->lp_ctx), name, tctx, address, tctx->ev),
talloc_asprintf(tctx,
"Failed to resolve %s", name->name));
io.in.name = name;
io.in.dest_addr = address;
- io.in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ io.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
io.in.broadcast = false;
io.in.wins_lookup = false;
io.in.timeout = 1;
if (!torture_nbt_get_name(tctx, &name, &address))
return false;
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
myaddress = iface_best_ip(ifaces, address);
io.in.name = name;
io.in.dest_addr = address;
- io.in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ io.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
io.in.address = myaddress;
io.in.nb_flags = NBT_NODE_B | NBT_NM_ACTIVE;
io.in.register_demand = false;
if (!torture_nbt_get_name(tctx, &name, &address))
return false;
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
myaddress = iface_best_ip(ifaces, address);
io.in.name = name;
io.in.dest_addr = address;
- io.in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ io.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
io.in.address = myaddress;
io.in.nb_flags = NBT_NODE_B | NBT_NM_ACTIVE;
io.in.broadcast = false;
struct interface *ifaces;
bool low_port = try_low_port;
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
myaddress = talloc_strdup(tctx, iface_best_ip(ifaces, address));
socket_address = socket_address_from_strings(tctx,
nbtsock->sock->backend_name,
- myaddress, lp_nbt_port(tctx->lp_ctx));
+ myaddress, lpcfg_nbt_port(tctx->lp_ctx));
torture_assert(tctx, socket_address != NULL,
"Error getting address");
torture_comment(tctx, "release the name\n");
release.in.name = *name;
- release.in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ release.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
release.in.dest_addr = address;
release.in.address = myaddress;
release.in.nb_flags = nb_flags;
} else {
torture_comment(tctx, "register the name with a wrong address (makes the next request slow!)\n");
io.in.name = *name;
- io.in.wins_port = lp_nbt_port(tctx->lp_ctx);
+ io.in.wins_port = lpcfg_nbt_port(tctx->lp_ctx);
io.in.wins_servers = const_str_list(
str_list_make_single(tctx, address));
io.in.addresses = const_str_list(
torture_comment(tctx, "register the name correct address\n");
name_register.in.name = *name;
- name_register.in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ name_register.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
name_register.in.dest_addr = address;
name_register.in.address = myaddress;
name_register.in.nb_flags = nb_flags;
torture_comment(tctx, "register the name correct address\n");
io.in.name = *name;
- io.in.wins_port = lp_nbt_port(tctx->lp_ctx);
+ io.in.wins_port = lpcfg_nbt_port(tctx->lp_ctx);
io.in.wins_servers = (const char **)str_list_make_single(tctx, address);
io.in.addresses = (const char **)str_list_make_single(tctx, myaddress);
io.in.nb_flags = nb_flags;
torture_comment(tctx, "query the name to make sure its there\n");
query.in.name = *name;
query.in.dest_addr = address;
- query.in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ query.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
query.in.broadcast = false;
query.in.wins_lookup = true;
query.in.timeout = 3;
torture_comment(tctx, "refresh the name\n");
refresh.in.name = *name;
- refresh.in.wins_port = lp_nbt_port(tctx->lp_ctx);
+ refresh.in.wins_port = lpcfg_nbt_port(tctx->lp_ctx);
refresh.in.wins_servers = (const char **)str_list_make_single(tctx, address);
refresh.in.addresses = (const char **)str_list_make_single(tctx, myaddress);
refresh.in.nb_flags = nb_flags;
printf("release the name\n");
release.in.name = *name;
- release.in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ release.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
release.in.dest_addr = address;
release.in.address = myaddress;
release.in.nb_flags = nb_flags;
} else {
torture_comment(tctx, "register the name with a wrong address (makes the next request slow!)\n");
io.in.name = *name;
- io.in.wins_port = lp_nbt_port(tctx->lp_ctx);
+ io.in.wins_port = lpcfg_nbt_port(tctx->lp_ctx);
io.in.wins_servers = const_str_list(
str_list_make_single(tctx, address));
io.in.addresses = const_str_list(
torture_comment(tctx, "refresh the name with the correct address\n");
refresh.in.name = *name;
- refresh.in.wins_port = lp_nbt_port(tctx->lp_ctx);
+ refresh.in.wins_port = lpcfg_nbt_port(tctx->lp_ctx);
refresh.in.wins_servers = const_str_list(
str_list_make_single(tctx, address));
refresh.in.addresses = const_str_list(
torture_comment(tctx, "release the name\n");
release.in.name = *name;
- release.in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ release.in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
release.in.dest_addr = address;
release.in.address = myaddress;
release.in.nb_flags = nb_flags;
state->num_names = torture_entries;
state->registered = talloc_zero_array(state, bool, state->num_names);
state->wins_server = address;
- state->wins_port = lp_nbt_port(tctx->lp_ctx);
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ state->wins_port = lpcfg_nbt_port(tctx->lp_ctx);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
state->my_ip = talloc_strdup(tctx, iface_best_ip(ifaces, address));
state->ttl = timelimit;
ctx->nbtsock = nbt_name_socket_init(ctx, tctx->ev);
if (!ctx->nbtsock) return NULL;
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
ctx->myaddr = socket_address_from_strings(tctx, ctx->nbtsock->sock->backend_name, iface_best_ip(ifaces, address), 0);
if (!ctx->myaddr) return NULL;
if (!ctx->nbtsock_srv) return NULL;
/* Make a port 137 version of ctx->myaddr */
- nbt_srv_addr = socket_address_from_strings(tctx, ctx->nbtsock_srv->sock->backend_name, ctx->myaddr->addr, lp_nbt_port(tctx->lp_ctx));
+ nbt_srv_addr = socket_address_from_strings(tctx, ctx->nbtsock_srv->sock->backend_name, ctx->myaddr->addr, lpcfg_nbt_port(tctx->lp_ctx));
if (!nbt_srv_addr) return NULL;
/* And if possible, bind to it. This won't work unless we are root or in sockewrapper */
nbt_srv_addr = socket_address_from_strings(tctx,
ctx->nbtsock_srv->sock->backend_name,
ctx->myaddr2->addr,
- lp_nbt_port(tctx->lp_ctx));
+ lpcfg_nbt_port(tctx->lp_ctx));
if (!nbt_srv_addr) return NULL;
/* And if possible, bind to it. This won't work unless we are root or in sockewrapper */
*/
name_register->in.name = records[i].name;
name_register->in.dest_addr = ctx->address;
- name_register->in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ name_register->in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
name_register->in.address = records[i].wins.ips[0].ip;
name_register->in.nb_flags = records[i].wins.nb_flags;
name_register->in.register_demand= false;
/* release the record */
release->in.name = records[i].name;
- release->in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ release->in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
release->in.dest_addr = ctx->address;
release->in.address = records[i].wins.ips[0].ip;
release->in.nb_flags = records[i].wins.nb_flags;
} else {
release->in.name = records[i].name;
release->in.dest_addr = ctx->address;
- release->in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ release->in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
release->in.address = records[i].wins.ips[0].ip;
release->in.nb_flags = records[i].wins.nb_flags;
release->in.broadcast = false;
if (!ctx->nbtsock_srv) {
torture_comment(tctx, "SKIP: Test Replica records vs. owned active records: not bound to port[%d]\n",
- lp_nbt_port(tctx->lp_ctx));
+ lpcfg_nbt_port(tctx->lp_ctx));
return true;
}
name_register->in.name = records[i].name;
name_register->in.dest_addr = ctx->address;
- name_register->in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ name_register->in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
name_register->in.address = records[i].wins.ips[j].ip;
name_register->in.nb_flags = records[i].wins.nb_flags;
name_register->in.register_demand= false;
release->in.name = records[i].name;
release->in.dest_addr = ctx->address;
- release->in.dest_port = lp_nbt_port(tctx->lp_ctx);
+ release->in.dest_port = lpcfg_nbt_port(tctx->lp_ctx);
release->in.address = records[i].wins.ips[j].ip;
release->in.nb_flags = records[i].wins.nb_flags;
release->in.broadcast = false;
unix_address = talloc_asprintf(signd_client,
"%s/socket",
- lp_ntp_signd_socket_directory(tctx->lp_ctx));
+ lpcfg_ntp_signd_socket_directory(tctx->lp_ctx));
rc = tsocket_address_unix_from_path(mem_ctx,
unix_address,
&signd_client->remote_address);
torture_comment(tctx, "Testing rap_NetUserPasswordSet2(%s)\n", r.in.UserName);
torture_assert_ntstatus_ok(tctx,
- smbcli_rap_netuserpasswordset2(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+ smbcli_rap_netuserpasswordset2(cli->tree, lpcfg_iconv_convenience(tctx->lp_ctx), tctx, &r),
"smbcli_rap_netuserpasswordset2 failed");
if (!W_ERROR_IS_OK(W_ERROR(r.out.status))) {
torture_warning(tctx, "RAP NetUserPasswordSet2 gave: %s\n",
torture_comment(tctx, "Testing rap_NetUserPasswordSet2(%s)\n", r.in.UserName);
torture_assert_ntstatus_ok(tctx,
- smbcli_rap_netuserpasswordset2(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+ smbcli_rap_netuserpasswordset2(cli->tree, lpcfg_iconv_convenience(tctx->lp_ctx), tctx, &r),
"smbcli_rap_netuserpasswordset2 failed");
if (!W_ERROR_IS_OK(W_ERROR(r.out.status))) {
torture_warning(tctx, "RAP NetUserPasswordSet2 gave: %s\n",
torture_comment(tctx, "Testing rap_NetOEMChangePassword(%s)\n", r.in.UserName);
torture_assert_ntstatus_ok(tctx,
- smbcli_rap_netoemchangepassword(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r),
+ smbcli_rap_netoemchangepassword(cli->tree, lpcfg_iconv_convenience(tctx->lp_ctx), tctx, &r),
"smbcli_rap_netoemchangepassword failed");
if (!W_ERROR_IS_OK(W_ERROR(r.out.status))) {
torture_warning(tctx, "RAP NetOEMChangePassword gave: %s\n",
}
io2.in.dest_host = torture_setting_string(tctx, "host", NULL);
- io2.in.ports = lp_smb_ports(tctx->lp_ctx);
+ io2.in.ports = lpcfg_smb_ports(tctx->lp_ctx);
io2.in.called_name = torture_setting_string(tctx, "host", NULL);
io2.in.service = torture_setting_string(tctx, "share", NULL);
io2.in.service_type = "A:";
io2.in.credentials = cmdline_credentials;
- io2.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ io2.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
io2.in.filename = fname;
- io2.in.resolve_ctx = lp_resolve_context(tctx->lp_ctx);
- io2.in.gensec_settings = lp_gensec_settings(tctx, tctx->lp_ctx);
- lp_smbcli_options(tctx->lp_ctx, &io2.in.options);
- lp_smbcli_session_options(tctx->lp_ctx, &io2.in.session_options);
+ io2.in.resolve_ctx = lpcfg_resolve_context(tctx->lp_ctx);
+ io2.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
+ lpcfg_smbcli_options(tctx->lp_ctx, &io2.in.options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &io2.in.session_options);
printf("Testing parallel fetchfile with %d ops\n", torture_numops);
bool ret = true;
io1.in.dest_host = torture_setting_string(tctx, "host", NULL);
- io1.in.dest_ports = lp_smb_ports(tctx->lp_ctx);
- io1.in.socket_options = lp_socket_options(tctx->lp_ctx);
+ io1.in.dest_ports = lpcfg_smb_ports(tctx->lp_ctx);
+ io1.in.socket_options = lpcfg_socket_options(tctx->lp_ctx);
io1.in.called_name = torture_setting_string(tctx, "host", NULL);
io1.in.service = torture_setting_string(tctx, "share", NULL);
io1.in.service_type = "A:";
io1.in.credentials = cmdline_credentials;
- io1.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ io1.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
io1.in.level = RAW_QFS_OBJECTID_INFORMATION;
- io1.in.gensec_settings = lp_gensec_settings(tctx, tctx->lp_ctx);
+ io1.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
printf("Testing parallel queryfsinfo [Object ID] with %d ops\n",
torture_numops);
c = talloc_array(tctx, struct composite_context *, torture_numops);
for (i=0; i<torture_numops; i++) {
- c[i] = smb_composite_fsinfo_send(cli->tree, &io1, lp_resolve_context(tctx->lp_ctx));
+ c[i] = smb_composite_fsinfo_send(cli->tree, &io1, lpcfg_resolve_context(tctx->lp_ctx));
c[i]->async.fn = loadfile_complete;
c[i]->async.private_data = count;
}
printf("create a second security context on the same transport\n");
- lp_smbcli_session_options(tctx->lp_ctx, &options);
- gensec_settings = lp_gensec_settings(tctx, tctx->lp_ctx);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &options);
+ gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
session = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */
- setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
setup.in.credentials = cmdline_credentials;
setup.in.gensec_settings = gensec_settings;
session2->vuid = session->vuid;
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */
- setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
setup.in.credentials = cmdline_credentials;
session3->vuid = session->vuid;
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities &= ~CAP_EXTENDED_SECURITY; /* force a non extended security login (should fail) */
- setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
setup.in.credentials = cmdline_credentials;
session4->vuid = session->vuid;
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities &= ~CAP_EXTENDED_SECURITY; /* force a non extended security login (should fail) */
- setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
anon_creds = cli_credentials_init(tctx);
cli_credentials_set_conf(anon_creds, tctx->lp_ctx);
for (i=0; i <ARRAY_SIZE(sessions); i++) {
setups[i].in.sesskey = cli->transport->negotiate.sesskey;
setups[i].in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */
- setups[i].in.workgroup = lp_workgroup(tctx->lp_ctx);
+ setups[i].in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
setups[i].in.credentials = cmdline_credentials;
setups[i].in.gensec_settings = gensec_settings;
share = torture_setting_string(tctx, "share", NULL);
host = torture_setting_string(tctx, "host", NULL);
- lp_smbcli_session_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &options);
printf("create the first new sessions\n");
session1 = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
- setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
setup.in.credentials = cmdline_credentials;
- setup.in.gensec_settings = lp_gensec_settings(tctx, tctx->lp_ctx);
+ setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
status = smb_composite_sesssetup(session1, &setup);
CHECK_STATUS(status, NT_STATUS_OK);
session1->vuid = setup.out.vuid;
session2 = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
- setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
setup.in.credentials = cmdline_credentials;
- setup.in.gensec_settings = lp_gensec_settings(tctx, tctx->lp_ctx);
+ setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
status = smb_composite_sesssetup(session2, &setup);
CHECK_STATUS(status, NT_STATUS_OK);
session2->vuid = setup.out.vuid;
return false;
}
- lp_smbcli_session_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &options);
printf("create a second security context on the same transport\n");
session = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */
- setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
setup.in.credentials = cmdline_credentials;
- setup.in.gensec_settings = lp_gensec_settings(tctx, tctx->lp_ctx);
+ setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
status = smb_composite_sesssetup(session, &setup);
CHECK_STATUS(status, NT_STATUS_OK);
struct smbcli_state *cli)
{
bool ret = true;
- if (lp_use_spnego(torture->lp_ctx)) {
+ if (lpcfg_use_spnego(torture->lp_ctx)) {
ret &= torture_raw_context_int(torture, cli);
- lp_set_cmdline(torture->lp_ctx, "use spnego", "False");
+ lpcfg_set_cmdline(torture->lp_ctx, "use spnego", "False");
}
ret &= torture_raw_context_int(torture, cli);
return false;
}
- lp_smbcli_session_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &options);
torture_comment(tctx, "Testing LOCKING_ANDX_CANCEL_LOCK\n");
io.generic.level = RAW_LOCK_LOCKX;
session = smbcli_session_init(cli->transport, tctx, false, options);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
- setup.in.workgroup = lp_workgroup(tctx->lp_ctx);
+ setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);
setup.in.credentials = cmdline_credentials;
- setup.in.gensec_settings = lp_gensec_settings(tctx, tctx->lp_ctx);
+ setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);
status = smb_composite_sesssetup(session, &setup);
CHECK_STATUS(status, NT_STATUS_OK);
session->vuid = setup.out.vuid;
io->in.dest_host = state->dest_host;
io->in.dest_ports = state->dest_ports;
- io->in.gensec_settings = lp_gensec_settings(state->mem_ctx, state->tctx->lp_ctx);
- io->in.socket_options = lp_socket_options(state->tctx->lp_ctx);
+ io->in.gensec_settings = lpcfg_gensec_settings(state->mem_ctx, state->tctx->lp_ctx);
+ io->in.socket_options = lpcfg_socket_options(state->tctx->lp_ctx);
io->in.called_name = state->called_name;
io->in.service = share;
io->in.service_type = state->service_type;
io->in.credentials = cmdline_credentials;
io->in.fallback_to_anonymous = false;
- io->in.workgroup = lp_workgroup(state->tctx->lp_ctx);
- lp_smbcli_options(state->tctx->lp_ctx, &io->in.options);
- lp_smbcli_session_options(state->tctx->lp_ctx, &io->in.session_options);
+ io->in.workgroup = lpcfg_workgroup(state->tctx->lp_ctx);
+ lpcfg_smbcli_options(state->tctx->lp_ctx, &io->in.options);
+ lpcfg_smbcli_session_options(state->tctx->lp_ctx, &io->in.session_options);
/* kill off the remnants of the old connection */
talloc_free(state->tree);
state->tree = NULL;
ctx = smb_composite_connect_send(io, state->mem_ctx,
- lp_resolve_context(state->tctx->lp_ctx),
+ lpcfg_resolve_context(state->tctx->lp_ctx),
state->ev);
if (ctx == NULL) {
DEBUG(0,("Failed to setup async reconnect\n"));
io->in.dest_host = state->dest_host;
io->in.dest_ports = state->dest_ports;
- io->in.socket_options = lp_socket_options(state->tctx->lp_ctx);
+ io->in.socket_options = lpcfg_socket_options(state->tctx->lp_ctx);
io->in.called_name = state->called_name;
io->in.service = share;
io->in.service_type = state->service_type;
io->in.credentials = cmdline_credentials;
io->in.fallback_to_anonymous = false;
- io->in.workgroup = lp_workgroup(state->tctx->lp_ctx);
- io->in.gensec_settings = lp_gensec_settings(state->mem_ctx, state->tctx->lp_ctx);
- lp_smbcli_options(state->tctx->lp_ctx, &io->in.options);
- lp_smbcli_session_options(state->tctx->lp_ctx, &io->in.session_options);
+ io->in.workgroup = lpcfg_workgroup(state->tctx->lp_ctx);
+ io->in.gensec_settings = lpcfg_gensec_settings(state->mem_ctx, state->tctx->lp_ctx);
+ lpcfg_smbcli_options(state->tctx->lp_ctx, &io->in.options);
+ lpcfg_smbcli_session_options(state->tctx->lp_ctx, &io->in.session_options);
/* kill off the remnants of the old connection */
talloc_free(state->tree);
state->close_fnum = -1;
ctx = smb_composite_connect_send(io, state->mem_ctx,
- lp_resolve_context(state->tctx->lp_ctx),
+ lpcfg_resolve_context(state->tctx->lp_ctx),
state->ev);
if (ctx == NULL) {
DEBUG(0,("Failed to setup async reconnect\n"));
struct smbcli_options options;
struct smbcli_session_options session_options;
- lp_smbcli_options(tctx->lp_ctx, &options);
- lp_smbcli_session_options(tctx->lp_ctx, &session_options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &session_options);
options.use_level2_oplocks = false;
status = smbcli_full_connection(tctx, c,
torture_setting_string(tctx, "host", NULL),
- lp_smb_ports(tctx->lp_ctx),
+ lpcfg_smb_ports(tctx->lp_ctx),
torture_setting_string(tctx, "share", NULL),
- NULL, lp_socket_options(tctx->lp_ctx), cmdline_credentials,
- lp_resolve_context(tctx->lp_ctx),
+ NULL, lpcfg_socket_options(tctx->lp_ctx), cmdline_credentials,
+ lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev, &options, &session_options,
- lp_gensec_settings(tctx, tctx->lp_ctx));
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
torture_comment(tctx, "Failed to open connection - %s\n",
nt_errstr(status));
return false;
}
- nt_status_support = lp_nt_status_support(torture->lp_ctx);
+ nt_status_support = lpcfg_nt_status_support(torture->lp_ctx);
- if (!lp_set_cmdline(torture->lp_ctx, "nt status support", "yes")) {
+ if (!lpcfg_set_cmdline(torture->lp_ctx, "nt status support", "yes")) {
printf("Could not set 'nt status support = yes'\n");
goto fail;
}
goto fail;
}
- if (!lp_set_cmdline(torture->lp_ctx, "nt status support", "no")) {
+ if (!lpcfg_set_cmdline(torture->lp_ctx, "nt status support", "no")) {
printf("Could not set 'nt status support = yes'\n");
goto fail;
}
goto fail;
}
- if (!lp_set_cmdline(torture->lp_ctx, "nt status support",
+ if (!lpcfg_set_cmdline(torture->lp_ctx, "nt status support",
nt_status_support ? "yes":"no")) {
printf("Could not reset 'nt status support = yes'");
goto fail;
struct smbcli_options options;
struct smbcli_session_options session_options;
- lp_smbcli_options(tctx->lp_ctx, &options);
- lp_smbcli_session_options(tctx->lp_ctx, &session_options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &session_options);
child = fork();
if (child == -1) {
NTSTATUS status;
status = smbcli_full_connection(NULL, &cli,
- host, lp_smb_ports(tctx->lp_ctx), share,
- NULL, lp_socket_options(tctx->lp_ctx), cmdline_credentials,
- lp_resolve_context(tctx->lp_ctx),
+ host, lpcfg_smb_ports(tctx->lp_ctx), share,
+ NULL, lpcfg_socket_options(tctx->lp_ctx), cmdline_credentials,
+ lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev, &options, &session_options,
- lp_gensec_settings(tctx, tctx->lp_ctx));
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
printf("failed to connect to //%s/%s: %s\n",
const char *iface_name;
bool ret = true;
const struct ndr_interface_list *l;
- iface_name = lp_parm_string(torture->lp_ctx, NULL, "countcalls", "interface");
+ iface_name = lpcfg_parm_string(torture->lp_ctx, NULL, "countcalls", "interface");
if (iface_name != NULL) {
iface = ndr_table_by_name(iface_name);
if (!iface) {
r.in.req->req5.highwatermark.highest_usn = 0;
r.in.req->req5.uptodateness_vector = NULL;
r.in.req->req5.replica_flags = 0;
- if (lp_parm_bool(tctx->lp_ctx, NULL, "drsuapi", "compression", false)) {
+ if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "drsuapi", "compression", false)) {
r.in.req->req5.replica_flags |= DRSUAPI_DRS_USE_COMPRESSION;
}
r.in.req->req5.max_object_count = 0;
r.in.req->req8.highwatermark.highest_usn = 0;
r.in.req->req8.uptodateness_vector = NULL;
r.in.req->req8.replica_flags = 0;
- if (lp_parm_bool(tctx->lp_ctx, NULL, "drsuapi", "compression", false)) {
+ if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "drsuapi", "compression", false)) {
r.in.req->req8.replica_flags |= DRSUAPI_DRS_USE_COMPRESSION;
}
- if (lp_parm_bool(tctx->lp_ctx, NULL, "drsuapi", "neighbour_writeable", true)) {
+ if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "drsuapi", "neighbour_writeable", true)) {
r.in.req->req8.replica_flags |= DRSUAPI_DRS_WRIT_REP;
}
r.in.req->req8.replica_flags |= DRSUAPI_DRS_INIT_SYNC
make_nbt_name_server(&name, ctx->drsuapi_binding->host);
/* do an initial name resolution to find its IP */
- status = resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx,
+ status = resolve_name(lpcfg_resolve_context(tctx->lp_ctx), &name, tctx,
&ctx->dest_address, tctx->ev);
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to resolve %s - %s\n",
our_bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
our_bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7;
our_bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT;
- if (lp_parm_bool(tctx->lp_ctx, NULL, "dssync", "xpress", false)) {
+ if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "dssync", "xpress", false)) {
our_bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS;
}
our_bind_info28->site_guid = GUID_zero();
ldb_set_modules_dir(ldb,
talloc_asprintf(ldb,
"%s/ldb",
- lp_modulesdir(tctx->lp_ctx)));
+ lpcfg_modulesdir(tctx->lp_ctx)));
if (ldb_set_opaque(ldb, "credentials", credentials)) {
talloc_free(ldb);
ret2 = tsocket_address_inet_from_strings(tctx, "ip",
ctx->dest_address,
- lp_cldap_port(tctx->lp_ctx),
+ lpcfg_cldap_port(tctx->lp_ctx),
&dest_addr);
if (ret2 != 0) {
printf("failed to create tsocket_address for '%s' port %u - %s\n",
- ctx->drsuapi_binding->host, lp_cldap_port(tctx->lp_ctx),
+ ctx->drsuapi_binding->host, lpcfg_cldap_port(tctx->lp_ctx),
strerror(errno));
return false;
}
r.in.req->req1.format_flags = DRSUAPI_DS_NAME_FLAG_NO_FLAGS;
r.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
r.in.req->req1.format_desired = DRSUAPI_DS_NAME_FORMAT_FQDN_1779;
- names[0].str = talloc_asprintf(ctx, "%s\\", lp_workgroup(tctx->lp_ctx));
+ names[0].str = talloc_asprintf(ctx, "%s\\", lpcfg_workgroup(tctx->lp_ctx));
r.out.level_out = &level_out;
r.out.ctr = &ctr;
talloc_free(search_req);
}
- if (!lp_parm_bool(tctx->lp_ctx, NULL, "dssync", "print_pwd_blobs", false)) {
+ if (!lpcfg_parm_bool(tctx->lp_ctx, NULL, "dssync", "print_pwd_blobs", false)) {
talloc_free(objs);
return true;
}
- save_values_dir = lp_parm_string(tctx->lp_ctx, NULL, "dssync", "save_pwd_blobs_dir");
+ save_values_dir = lpcfg_parm_string(tctx->lp_ctx, NULL, "dssync", "save_pwd_blobs_dir");
for (cur = first_object; cur; cur = cur->next_object) {
const char *dn;
ZERO_STRUCT(null_guid);
ZERO_STRUCT(null_sid);
- partition = lp_parm_string(tctx->lp_ctx, NULL, "dssync", "partition");
+ partition = lpcfg_parm_string(tctx->lp_ctx, NULL, "dssync", "partition");
if (partition == NULL) {
partition = ctx->domain_dn;
printf("dssync:partition not specified, defaulting to %s.\n", ctx->domain_dn);
}
- highest_usn = lp_parm_int(tctx->lp_ctx, NULL, "dssync", "highest_usn", 0);
+ highest_usn = lpcfg_parm_int(tctx->lp_ctx, NULL, "dssync", "highest_usn", 0);
- array[0].level = lp_parm_int(tctx->lp_ctx, NULL, "dssync", "get_nc_changes_level", array[0].level);
+ array[0].level = lpcfg_parm_int(tctx->lp_ctx, NULL, "dssync", "get_nc_changes_level", array[0].level);
- if (lp_parm_bool(tctx->lp_ctx, NULL, "dssync", "print_pwd_blobs", false)) {
+ if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "dssync", "print_pwd_blobs", false)) {
const struct samr_Password *nthash;
nthash = cli_credentials_get_nt_hash(ctx->new_dc.credentials, ctx);
if (nthash) {
r.in.req->req5.highwatermark.highest_usn = highest_usn;
r.in.req->req5.uptodateness_vector = NULL;
r.in.req->req5.replica_flags = 0;
- if (lp_parm_bool(tctx->lp_ctx, NULL, "dssync", "compression", false)) {
+ if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "dssync", "compression", false)) {
r.in.req->req5.replica_flags |= DRSUAPI_DRS_USE_COMPRESSION;
}
- if (lp_parm_bool(tctx->lp_ctx, NULL, "dssync", "neighbour_writeable", true)) {
+ if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "dssync", "neighbour_writeable", true)) {
r.in.req->req5.replica_flags |= DRSUAPI_DRS_WRIT_REP;
}
r.in.req->req5.replica_flags |= DRSUAPI_DRS_INIT_SYNC
r.in.req->req8.highwatermark.highest_usn = highest_usn;
r.in.req->req8.uptodateness_vector = NULL;
r.in.req->req8.replica_flags = 0;
- if (lp_parm_bool(tctx->lp_ctx, NULL, "dssync", "compression", false)) {
+ if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "dssync", "compression", false)) {
r.in.req->req8.replica_flags |= DRSUAPI_DRS_USE_COMPRESSION;
}
- if (lp_parm_bool(tctx->lp_ctx, NULL, "dssync", "neighbour_writeable", true)) {
+ if (lpcfg_parm_bool(tctx->lp_ctx, NULL, "dssync", "neighbour_writeable", true)) {
r.in.req->req8.replica_flags |= DRSUAPI_DRS_WRIT_REP;
}
r.in.req->req8.replica_flags |= DRSUAPI_DRS_INIT_SYNC
r.out.info = &info;
r.out.level_out = &level_out;
- req.req1.flags = lp_parm_int(tctx->lp_ctx, NULL,
+ req.req1.flags = lpcfg_parm_int(tctx->lp_ctx, NULL,
"dssync", "nt4changelog_flags",
DRSUAPI_NT4_CHANGELOG_GET_CHANGELOG |
DRSUAPI_NT4_CHANGELOG_GET_SERIAL_NUMBERS);
- req.req1.preferred_maximum_length = lp_parm_int(tctx->lp_ctx, NULL,
+ req.req1.preferred_maximum_length = lpcfg_parm_int(tctx->lp_ctx, NULL,
"dssync", "nt4changelog_preferred_len",
0x00004000);
r.in.replica_set_guid = NULL;
r.in.connection_guid = NULL;
- r.in.replica_set_name = lp_dnsdomain(tctx->lp_ctx);
+ r.in.replica_set_name = lpcfg_dnsdomain(tctx->lp_ctx);
r.in.partner_dns_name = dcerpc_server_name(p);
torture_assert_ntstatus_ok(tctx,
return false;
}
- lp_smbcli_options(torture->lp_ctx, &options);
- lp_smbcli_session_options(torture->lp_ctx, &session_options);
+ lpcfg_smbcli_options(torture->lp_ctx, &options);
+ lpcfg_smbcli_session_options(torture->lp_ctx, &session_options);
status = smbcli_full_connection(tj, &cli, host,
- lp_smb_ports(torture->lp_ctx),
+ lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
- lp_socket_options(torture->lp_ctx),
+ lpcfg_socket_options(torture->lp_ctx),
machine_account,
- lp_resolve_context(torture->lp_ctx),
+ lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
- lp_gensec_settings(torture, torture->lp_ctx));
+ lpcfg_gensec_settings(torture, torture->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("%s failed to connect to IPC$ with workstation credentials\n",
TORTURE_NETBIOS_NAME));
}
status = smbcli_full_connection(tj, &cli, host,
- lp_smb_ports(torture->lp_ctx),
+ lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
- lp_socket_options(torture->lp_ctx),
+ lpcfg_socket_options(torture->lp_ctx),
machine_account,
- lp_resolve_context(torture->lp_ctx),
+ lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
- lp_gensec_settings(torture, torture->lp_ctx));
+ lpcfg_gensec_settings(torture, torture->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("%s failed to connect to IPC$ with workstation credentials\n",
TORTURE_NETBIOS_NAME));
continue;
}
- lp_set_cmdline(torture->lp_ctx, "torture:binding", dcerpc_binding_string(loop_ctx, b));
+ lpcfg_set_cmdline(torture->lp_ctx, "torture:binding", dcerpc_binding_string(loop_ctx, b));
status = torture_rpc_connection(torture, &p, &ndr_table_mgmt);
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
int i;
struct dcerpc_binding_handle *b = p->binding_handle;
int flags = CLI_CRED_NTLM_AUTH;
- if (lp_client_lanman_auth(tctx->lp_ctx)) {
+ if (lpcfg_client_lanman_auth(tctx->lp_ctx)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth(tctx->lp_ctx)) {
+ if (lpcfg_client_ntlmv2_auth(tctx->lp_ctx)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
struct dcerpc_binding_handle *b = p->binding_handle;
r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.domainname = lp_workgroup(tctx->lp_ctx);
+ r.in.domainname = lpcfg_workgroup(tctx->lp_ctx);
r.out.dcname = &dcname;
torture_assert_ntstatus_ok(tctx, dcerpc_netr_GetDcName_r(b, tctx, &r),
const char *dcname = NULL;
struct dcerpc_binding_handle *b = p->binding_handle;
- r.in.domainname = lp_workgroup(tctx->lp_ctx);
+ r.in.domainname = lpcfg_workgroup(tctx->lp_ctx);
r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
r.out.dcname = &dcname;
int i;
struct dcerpc_binding_handle *b = p->binding_handle;
- data.domain = lp_workgroup(tctx->lp_ctx);
+ data.domain = lpcfg_workgroup(tctx->lp_ctx);
r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
torture_assert_ntstatus_ok(tctx, status, "LogonControl");
}
- data.domain = lp_workgroup(tctx->lp_ctx);
+ data.domain = lpcfg_workgroup(tctx->lp_ctx);
r.in.function_code = NETLOGON_CONTROL_TC_QUERY;
r.in.data = &data;
torture_assert_ntstatus_ok(tctx, status, "LogonControl");
}
- data.domain = lp_workgroup(tctx->lp_ctx);
+ data.domain = lpcfg_workgroup(tctx->lp_ctx);
r.in.function_code = NETLOGON_CONTROL_TRANSPORT_NOTIFY;
r.in.data = &data;
int i;
struct dcerpc_binding_handle *b = p->binding_handle;
- data.domain = lp_workgroup(tctx->lp_ctx);
+ data.domain = lpcfg_workgroup(tctx->lp_ctx);
r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
torture_assert_ntstatus_ok(tctx, status, "LogonControl");
}
- data.domain = lp_workgroup(tctx->lp_ctx);
+ data.domain = lpcfg_workgroup(tctx->lp_ctx);
r.in.function_code = NETLOGON_CONTROL_TC_QUERY;
r.in.data = &data;
torture_assert_ntstatus_ok(tctx, status, "LogonControl");
}
- data.domain = lp_workgroup(tctx->lp_ctx);
+ data.domain = lpcfg_workgroup(tctx->lp_ctx);
r.in.function_code = NETLOGON_CONTROL_TRANSPORT_NOTIFY;
r.in.data = &data;
struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_unc = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.domain_name = lp_dnsdomain(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_dnsdomain(tctx->lp_ctx);
r.in.domain_guid = NULL;
r.in.site_guid = NULL;
r.in.flags = DS_RETURN_DNS_NAME;
torture_assert_ntstatus_ok(tctx, status, "DsRGetDCName");
torture_assert_werr_ok(tctx, r.out.result, "DsRGetDCName");
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
status = dcerpc_netr_DsRGetDCName_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "DsRGetDCName");
struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_unc = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.domain_name = lp_dnsdomain(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_dnsdomain(tctx->lp_ctx);
r.in.domain_guid = NULL;
r.in.site_name = NULL;
r.in.flags = DS_RETURN_DNS_NAME;
torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx");
torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx");
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
status = dcerpc_netr_DsRGetDCNameEx_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx");
r.in.server_unc = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
r.in.client_account = NULL;
r.in.mask = 0x00000000;
- r.in.domain_name = lp_dnsdomain(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_dnsdomain(tctx->lp_ctx);
r.in.domain_guid = NULL;
r.in.site_name = NULL;
r.in.flags = DS_RETURN_DNS_NAME;
torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx2");
torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx2");
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
status = dcerpc_netr_DsRGetDCNameEx2_r(b, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx2");
ZERO_STRUCT(q1);
q1.dns_hostname = talloc_asprintf(tctx, "%s.%s", TEST_MACHINE_NAME,
- lp_dnsdomain(tctx->lp_ctx));
+ lpcfg_dnsdomain(tctx->lp_ctx));
q1.sitename = "Default-First-Site-Name";
q1.os_version.os = &os;
q1.os_name.string = talloc_asprintf(tctx,
/* Change also the DNS hostname to test differences in behaviour */
talloc_free(discard_const_p(char, q1.dns_hostname));
q1.dns_hostname = talloc_asprintf(tctx, "%s2.%s", TEST_MACHINE_NAME,
- lp_dnsdomain(tctx->lp_ctx));
+ lpcfg_dnsdomain(tctx->lp_ctx));
/* The workstation handles the "servicePrincipalName" and DNS hostname
updates */
/* Change also the DNS hostname to test differences in behaviour */
talloc_free(discard_const_p(char, q1.dns_hostname));
q1.dns_hostname = talloc_asprintf(tctx, "%s2.%s", TEST_MACHINE_NAME,
- lp_dnsdomain(tctx->lp_ctx));
+ lpcfg_dnsdomain(tctx->lp_ctx));
/* Wipe out the osVersion, and prove which values still 'stick' */
q1.os_version.os = NULL;
/* Put the DNS hostname back */
talloc_free(discard_const_p(char, q1.dns_hostname));
q1.dns_hostname = talloc_asprintf(tctx, "%s.%s", TEST_MACHINE_NAME,
- lp_dnsdomain(tctx->lp_ctx));
+ lpcfg_dnsdomain(tctx->lp_ctx));
/* The workstation handles the "servicePrincipalName" and DNS hostname
updates */
ZERO_STRUCT(q1);
q1.dns_hostname = talloc_asprintf(tctx, "%s.%s", TEST_MACHINE_NAME,
- lp_dnsdomain(tctx->lp_ctx));
+ lpcfg_dnsdomain(tctx->lp_ctx));
q1.sitename = "Default-First-Site-Name";
q1.os_name.string = "UNIX/Linux or similar";
torture_assert_ntstatus_ok(tctx, status, "torture_temp_dir failed");
status = gensec_client_start(tctx, &gensec_client_context, tctx->ev,
- lp_gensec_settings(tctx, tctx->lp_ctx));
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
torture_assert_ntstatus_ok(tctx, status, "gensec_client_start (client) failed");
status = gensec_set_target_hostname(gensec_client_context, test_machine_name);
torture_assert_ntstatus_ok(tctx, status, "gensec_start_mech_by_sasl_name (client) failed");
status = gensec_server_start(tctx, tctx->ev,
- lp_gensec_settings(tctx, tctx->lp_ctx),
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx),
NULL, &gensec_server_context);
torture_assert_ntstatus_ok(tctx, status, "gensec_server_start (server) failed");
torture_assert_ntstatus_ok(tctx, status, "torture_temp_dir failed");
status = gensec_client_start(tctx, &gensec_client_context, tctx->ev,
- lp_gensec_settings(tctx, tctx->lp_ctx));
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
torture_assert_ntstatus_ok(tctx, status, "gensec_client_start (client) failed");
status = gensec_set_target_hostname(gensec_client_context, test_machine_name);
torture_assert_ntstatus_ok(tctx, status, "gensec_start_mech_by_sasl_name (client) failed");
status = gensec_server_start(tctx, tctx->ev,
- lp_gensec_settings(tctx, tctx->lp_ctx),
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx),
NULL, &gensec_server_context);
torture_assert_ntstatus_ok(tctx, status, "gensec_server_start (server) failed");
cli_credentials_set_impersonate_principal(credentials, cli_credentials_get_principal(cmdline_credentials, tmp_ctx));
status = gensec_client_start(tctx, &gensec_client_context, tctx->ev,
- lp_gensec_settings(tctx, tctx->lp_ctx));
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
torture_assert_ntstatus_ok(tctx, status, "gensec_client_start (client) failed");
status = gensec_set_target_hostname(gensec_client_context, test_machine_name);
torture_assert_ntstatus_ok(tctx, status, "gensec_start_mech_by_sasl_name (client) failed");
status = gensec_server_start(tctx, tctx->ev,
- lp_gensec_settings(tctx, tctx->lp_ctx),
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx),
NULL, &gensec_server_context);
torture_assert_ntstatus_ok(tctx, status, "gensec_server_start (server) failed");
return false;
}
- lp_smbcli_options(torture->lp_ctx, &options);
- lp_smbcli_session_options(torture->lp_ctx, &session_options);
+ lpcfg_smbcli_options(torture->lp_ctx, &options);
+ lpcfg_smbcli_session_options(torture->lp_ctx, &session_options);
status = smbcli_full_connection(mem_ctx, &cli,
torture_setting_string(torture, "host", NULL),
- lp_smb_ports(torture->lp_ctx),
+ lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
- lp_socket_options(torture->lp_ctx),
+ lpcfg_socket_options(torture->lp_ctx),
cmdline_credentials,
- lp_resolve_context(torture->lp_ctx),
+ lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
- lp_gensec_settings(torture, torture->lp_ctx));
+ lpcfg_gensec_settings(torture, torture->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
torture_comment(torture, "smbcli_full_connection failed: %s\n",
nt_errstr(status));
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.workgroup = "";
setup.in.credentials = anon_creds;
- setup.in.gensec_settings = lp_gensec_settings(torture, torture->lp_ctx);
+ setup.in.gensec_settings = lpcfg_gensec_settings(torture, torture->lp_ctx);
status = smb_composite_sesssetup(session2, &setup);
if (!NT_STATUS_IS_OK(status)) {
}
status = dcerpc_bind_auth(lsa_pipe, &ndr_table_lsarpc,
- credentials, lp_gensec_settings(tctx->lp_ctx, tctx->lp_ctx), auth_type, auth_level,
+ credentials, lpcfg_gensec_settings(tctx->lp_ctx, tctx->lp_ctx), auth_type, auth_level,
NULL);
if (!NT_STATUS_IS_OK(status)) {
torture_comment(tctx, "dcerpc_bind_auth failed: %s\n", nt_errstr(status));
return false;
}
- lp_smbcli_options(torture->lp_ctx, &options);
- lp_smbcli_session_options(torture->lp_ctx, &session_options);
+ lpcfg_smbcli_options(torture->lp_ctx, &options);
+ lpcfg_smbcli_session_options(torture->lp_ctx, &session_options);
status = smbcli_full_connection(mem_ctx, &cli,
torture_setting_string(torture, "host", NULL),
- lp_smb_ports(torture->lp_ctx),
+ lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
- lp_socket_options(torture->lp_ctx),
+ lpcfg_socket_options(torture->lp_ctx),
cmdline_credentials,
- lp_resolve_context(torture->lp_ctx),
+ lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
- lp_gensec_settings(torture, torture->lp_ctx));
+ lpcfg_gensec_settings(torture, torture->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
torture_comment(torture, "smbcli_full_connection failed: %s\n",
nt_errstr(status));
if (admin_creds != NULL) {
torture_assert_ntstatus_ok(tctx,
dcerpc_bind_auth(samr_pipe, &ndr_table_samr,
- admin_creds, lp_gensec_settings(tctx->lp_ctx, tctx->lp_ctx), auth_type, auth_level,
+ admin_creds, lpcfg_gensec_settings(tctx->lp_ctx, tctx->lp_ctx), auth_type, auth_level,
NULL),
"dcerpc_bind_auth failed");
} else {
#if 1
net_pipe->conn->flags |= (DCERPC_SIGN | DCERPC_SEAL);
status = dcerpc_bind_auth(net_pipe, &ndr_table_netlogon,
- wks_creds, lp_gensec_settings(tctx->lp_ctx, tctx->lp_ctx), DCERPC_AUTH_TYPE_SCHANNEL,
+ wks_creds, lpcfg_gensec_settings(tctx->lp_ctx, tctx->lp_ctx), DCERPC_AUTH_TYPE_SCHANNEL,
DCERPC_AUTH_LEVEL_PRIVACY,
NULL);
#else
goto done;
}
- lp_smbcli_options(torture->lp_ctx, &options);
- lp_smbcli_session_options(torture->lp_ctx, &session_options);
+ lpcfg_smbcli_options(torture->lp_ctx, &options);
+ lpcfg_smbcli_session_options(torture->lp_ctx, &session_options);
status = smbcli_full_connection(mem_ctx, &cli,
torture_setting_string(torture, "host", NULL),
- lp_smb_ports(torture->lp_ctx),
+ lpcfg_smb_ports(torture->lp_ctx),
"IPC$", NULL,
- lp_socket_options(torture->lp_ctx),
+ lpcfg_socket_options(torture->lp_ctx),
anon_creds,
- lp_resolve_context(torture->lp_ctx),
+ lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
- lp_gensec_settings(torture, torture->lp_ctx));
+ lpcfg_gensec_settings(torture, torture->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
torture_comment(torture, "smbcli_full_connection failed: %s\n",
nt_errstr(status));
struct smbcli_options options;
struct smbcli_session_options session_options;
- lp_smbcli_options(tctx->lp_ctx, &options);
- lp_smbcli_session_options(tctx->lp_ctx, &session_options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &session_options);
status = smbcli_full_connection(tctx, &cli,
torture_setting_string(tctx, "host", NULL),
- lp_smb_ports(tctx->lp_ctx),
- "IPC$", NULL, lp_socket_options(tctx->lp_ctx),
- smb_creds, lp_resolve_context(tctx->lp_ctx),
+ lpcfg_smb_ports(tctx->lp_ctx),
+ "IPC$", NULL, lpcfg_socket_options(tctx->lp_ctx),
+ smb_creds, lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev, &options, &session_options,
- lp_gensec_settings(tctx, tctx->lp_ctx));
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
torture_assert_ntstatus_ok(tctx, status,
"smbcli_full_connection failed");
return false;
}
- lp_smbcli_options(torture->lp_ctx, &options);
- lp_smbcli_session_options(torture->lp_ctx, &session_options);
+ lpcfg_smbcli_options(torture->lp_ctx, &options);
+ lpcfg_smbcli_session_options(torture->lp_ctx, &session_options);
status = smbcli_full_connection(
mem_ctx, &cli, torture_setting_string(torture, "host", NULL),
- lp_smb_ports(torture->lp_ctx),
- "IPC$", NULL, lp_socket_options(torture->lp_ctx), cmdline_credentials,
- lp_resolve_context(torture->lp_ctx), torture->ev, &options,
- &session_options, lp_gensec_settings(torture, torture->lp_ctx));
+ lpcfg_smb_ports(torture->lp_ctx),
+ "IPC$", NULL, lpcfg_socket_options(torture->lp_ctx), cmdline_credentials,
+ lpcfg_resolve_context(torture->lp_ctx), torture->ev, &options,
+ &session_options, lpcfg_gensec_settings(torture, torture->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
torture_warning(torture, "smbcli_full_connection failed: %s\n",
nt_errstr(status));
status = smbcli_full_connection(
mem_ctx, &cli, torture_setting_string(torture, "host", NULL),
- lp_smb_ports(torture->lp_ctx), "IPC$", NULL,
- lp_socket_options(torture->lp_ctx), anon_creds,
- lp_resolve_context(torture->lp_ctx),
+ lpcfg_smb_ports(torture->lp_ctx), "IPC$", NULL,
+ lpcfg_socket_options(torture->lp_ctx), anon_creds,
+ lpcfg_resolve_context(torture->lp_ctx),
torture->ev, &options, &session_options,
- lp_gensec_settings(torture, torture->lp_ctx));
+ lpcfg_gensec_settings(torture, torture->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
torture_warning(torture, "anon smbcli_full_connection failed: %s\n",
nt_errstr(status));
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.workgroup = "";
setup.in.credentials = user_creds;
- setup.in.gensec_settings = lp_gensec_settings(torture, torture->lp_ctx);
+ setup.in.gensec_settings = lpcfg_gensec_settings(torture, torture->lp_ctx);
status = smb_composite_sesssetup(session2, &setup);
if (!NT_STATUS_IS_OK(status)) {
ZERO_STRUCT(userlevel1);
userlevel1.client = talloc_asprintf(
- torture, "\\\\%s", lp_netbios_name(torture->lp_ctx));
+ torture, "\\\\%s", lpcfg_netbios_name(torture->lp_ctx));
userlevel1.user = cli_credentials_get_username(cmdline_credentials);
userlevel1.build = 2600;
userlevel1.major = 3;
samlogon_state.account_name = account_name;
samlogon_state.account_domain = account_domain;
samlogon_state.password = plain_pass;
- samlogon_state.workgroup = lp_workgroup(tctx->lp_ctx);
- samlogon_state.netbios_name = lp_netbios_name(tctx->lp_ctx);
+ samlogon_state.workgroup = lpcfg_workgroup(tctx->lp_ctx);
+ samlogon_state.netbios_name = lpcfg_netbios_name(tctx->lp_ctx);
samlogon_state.p = p;
samlogon_state.creds = creds;
samlogon_state.expected_error = expected_error;
ld_r.in.connect_handle = &connect_handle;
ld_r.in.domain_name = &domName;
- ld_r.in.domain_name->string = lp_workgroup(torture->lp_ctx);
+ ld_r.in.domain_name->string = lpcfg_workgroup(torture->lp_ctx);
ld_r.out.sid = &domSid;
torture_assert_ntstatus_ok(torture,
return false;
}
- userdomain = torture_setting_string(torture, "userdomain", lp_workgroup(torture->lp_ctx));
+ userdomain = torture_setting_string(torture, "userdomain", lpcfg_workgroup(torture->lp_ctx));
user_ctx = torture_create_testuser(torture,
TEST_USER_NAME,
.username = talloc_asprintf(mem_ctx,
"%s@%s",
TEST_USER_NAME,
- lp_realm(torture->lp_ctx)),
+ lpcfg_realm(torture->lp_ctx)),
.password = user_password,
.network_login = true,
.expected_interactive_error = NT_STATUS_OK,
torture_assert_ntstatus_ok(tctx, dcerpc_schannel_creds(p->conn->security_state.generic_state, tctx, &creds), "");
- if (lp_client_lanman_auth(tctx->lp_ctx)) {
+ if (lpcfg_client_lanman_auth(tctx->lp_ctx)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth(tctx->lp_ctx)) {
+ if (lpcfg_client_ntlmv2_auth(tctx->lp_ctx)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
ld.in.connect_handle = &ch;
ld.in.domain_name = &dn;
ld.out.sid = &sid;
- dn.string = lp_workgroup(tctx->lp_ctx);
+ dn.string = lpcfg_workgroup(tctx->lp_ctx);
torture_assert_ntstatus_ok(tctx, dcerpc_samr_LookupDomain_r(b, tctx, &ld),
"LookupDomain failed");
ld.in.connect_handle = &ch;
ld.in.domain_name = &dn;
ld.out.sid = &sid;
- dn.string = lp_workgroup(tctx->lp_ctx);
+ dn.string = lpcfg_workgroup(tctx->lp_ctx);
torture_assert_ntstatus_ok(tctx, dcerpc_samr_LookupDomain_r(b, tctx, &ld),
"LookupDomain failed");
ld.in.connect_handle = &ch;
ld.in.domain_name = &dn;
ld.out.sid = &sid;
- dn.string = lp_workgroup(tctx->lp_ctx);
+ dn.string = lpcfg_workgroup(tctx->lp_ctx);
torture_assert_ntstatus_ok(tctx, dcerpc_samr_LookupDomain_r(b, tctx, &ld),
"LookupDomain failed");
if (!NT_STATUS_IS_OK(ld.out.result)) {
}
/* create a test user */
- testuser = torture_create_testuser(tctx, TEST_USER_NAME, lp_workgroup(tctx->lp_ctx),
+ testuser = torture_create_testuser(tctx, TEST_USER_NAME, lpcfg_workgroup(tctx->lp_ctx),
ACB_NORMAL, &testuser_passwd);
if (!testuser) {
printf("Failed to create test user\n");
}
test_credentials = cli_credentials_init(tctx);
cli_credentials_set_workstation(test_credentials, "localhost", CRED_SPECIFIED);
- cli_credentials_set_domain(test_credentials, lp_workgroup(tctx->lp_ctx),
+ cli_credentials_set_domain(test_credentials, lpcfg_workgroup(tctx->lp_ctx),
CRED_SPECIFIED);
cli_credentials_set_username(test_credentials, TEST_USER_NAME, CRED_SPECIFIED);
cli_credentials_set_password(test_credentials, testuser_passwd, CRED_SPECIFIED);
torture_assert(tctx,
test_samr_domain(tctx, b, SEC_FLAG_MAXIMUM_ALLOWED,
- lp_workgroup(tctx->lp_ctx),
+ lpcfg_workgroup(tctx->lp_ctx),
&connect_handle, &domain_handle),
"failed to test domain");
test_machine_account = talloc_asprintf(mem_ctx, "%s$", TEST_MACHINE_NAME);
join_ctx = torture_create_testuser(torture, test_machine_account,
- lp_workgroup(torture->lp_ctx), ACB_SVRTRUST,
+ lpcfg_workgroup(torture->lp_ctx), ACB_SVRTRUST,
&machine_password);
if (!join_ctx) {
talloc_free(mem_ctx);
}
test_wksta_machine_account = talloc_asprintf(mem_ctx, "%s$", TEST_WKSTA_MACHINE_NAME);
- join_ctx2 = torture_create_testuser(torture, test_wksta_machine_account, lp_workgroup(torture->lp_ctx), ACB_WSTRUST, &wksta_machine_password);
+ join_ctx2 = torture_create_testuser(torture, test_wksta_machine_account, lpcfg_workgroup(torture->lp_ctx), ACB_WSTRUST, &wksta_machine_password);
if (!join_ctx2) {
talloc_free(mem_ctx);
torture_comment(torture, "Failed to join as member\n");
}
user_ctx = torture_create_testuser(torture, TEST_USER_NAME,
- lp_workgroup(torture->lp_ctx),
+ lpcfg_workgroup(torture->lp_ctx),
ACB_NORMAL, NULL);
if (!user_ctx) {
talloc_free(mem_ctx);
ret, failed,
"samr_Connect failed");
- domain_policy = samsync_open_domain(torture, mem_ctx, samsync_state, lp_workgroup(torture->lp_ctx), NULL);
+ domain_policy = samsync_open_domain(torture, mem_ctx, samsync_state, lpcfg_workgroup(torture->lp_ctx), NULL);
if (!domain_policy) {
torture_comment(torture, "samrsync_open_domain failed\n");
ret = false;
credentials = cli_credentials_init(mem_ctx);
cli_credentials_set_workstation(credentials, TEST_MACHINE_NAME, CRED_SPECIFIED);
- cli_credentials_set_domain(credentials, lp_workgroup(torture->lp_ctx), CRED_SPECIFIED);
+ cli_credentials_set_domain(credentials, lpcfg_workgroup(torture->lp_ctx), CRED_SPECIFIED);
cli_credentials_set_username(credentials, test_machine_account, CRED_SPECIFIED);
cli_credentials_set_password(credentials, machine_password, CRED_SPECIFIED);
cli_credentials_set_secure_channel_type(credentials,
credentials_wksta = cli_credentials_init(mem_ctx);
cli_credentials_set_workstation(credentials_wksta, TEST_WKSTA_MACHINE_NAME, CRED_SPECIFIED);
- cli_credentials_set_domain(credentials_wksta, lp_workgroup(torture->lp_ctx), CRED_SPECIFIED);
+ cli_credentials_set_domain(credentials_wksta, lpcfg_workgroup(torture->lp_ctx), CRED_SPECIFIED);
cli_credentials_set_username(credentials_wksta, test_wksta_machine_account, CRED_SPECIFIED);
cli_credentials_set_password(credentials_wksta, wksta_machine_password, CRED_SPECIFIED);
cli_credentials_set_secure_channel_type(credentials_wksta,
b->endpoint = talloc_strdup(b, l->table->name);
}
- lp_set_cmdline(torture->lp_ctx, "torture:binding", dcerpc_binding_string(torture, b));
+ lpcfg_set_cmdline(torture->lp_ctx, "torture:binding", dcerpc_binding_string(torture, b));
status = torture_rpc_connection(torture, &p, &ndr_table_mgmt);
if (!NT_STATUS_IS_OK(status)) {
int flags = CLI_CRED_NTLM_AUTH;
struct dcerpc_binding_handle *b = p->binding_handle;
- if (lp_client_lanman_auth(tctx->lp_ctx)) {
+ if (lpcfg_client_lanman_auth(tctx->lp_ctx)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth(tctx->lp_ctx)) {
+ if (lpcfg_client_ntlmv2_auth(tctx->lp_ctx)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
struct policy_handle handle;
struct policy_handle domain_handle;
- name.string = lp_workgroup(tctx->lp_ctx);
+ name.string = lpcfg_workgroup(tctx->lp_ctx);
r.in.domain_name = &name;
r.out.info = &info;
torture_assert_ntstatus_ok(tctx, status, "seconday connection");
status = dcerpc_bind_auth(p_netlogon, &ndr_table_netlogon,
- credentials, lp_gensec_settings(tctx, tctx->lp_ctx),
+ credentials, lpcfg_gensec_settings(tctx, tctx->lp_ctx),
DCERPC_AUTH_TYPE_SCHANNEL,
dcerpc_auth_level(p->conn),
NULL);
torture_assert_ntstatus_ok(tctx, status, "seconday connection");
status = dcerpc_bind_auth(p_lsa, &ndr_table_lsarpc,
- credentials, lp_gensec_settings(tctx, tctx->lp_ctx),
+ credentials, lpcfg_gensec_settings(tctx, tctx->lp_ctx),
DCERPC_AUTH_TYPE_SCHANNEL,
dcerpc_auth_level(p->conn),
NULL);
/* and now setup an SCHANNEL bind on netlogon */
status = dcerpc_bind_auth(p_netlogon2, &ndr_table_netlogon,
- credentials, lp_gensec_settings(tctx, tctx->lp_ctx),
+ credentials, lpcfg_gensec_settings(tctx, tctx->lp_ctx),
DCERPC_AUTH_TYPE_SCHANNEL,
dcerpc_auth_level(p_samr2->conn),
NULL);
user_creds = s->user2_creds;
}
- if (lp_client_lanman_auth(s->tctx->lp_ctx)) {
+ if (lpcfg_client_lanman_auth(s->tctx->lp_ctx)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth(s->tctx->lp_ctx)) {
+ if (lpcfg_client_ntlmv2_auth(s->tctx->lp_ctx)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
NTSTATUS status;
struct dcerpc_binding_handle *b;
- lp_set_cmdline(torture->lp_ctx, "ntlmssp client:keyexchange", settings->keyexchange?"True":"False");
- lp_set_cmdline(torture->lp_ctx, "ntlmssp_client:ntlm2", settings->ntlm2?"True":"False");
- lp_set_cmdline(torture->lp_ctx, "ntlmssp_client:lm_key", settings->lm_key?"True":"False");
+ lpcfg_set_cmdline(torture->lp_ctx, "ntlmssp client:keyexchange", settings->keyexchange?"True":"False");
+ lpcfg_set_cmdline(torture->lp_ctx, "ntlmssp_client:ntlm2", settings->ntlm2?"True":"False");
+ lpcfg_set_cmdline(torture->lp_ctx, "ntlmssp_client:lm_key", settings->lm_key?"True":"False");
torture_assert_ntstatus_ok(torture, torture_rpc_binding(torture, &binding),
"Getting bindoptions");
torture_comment(tctx, "Connecting printer driver share '%s' on '%s'\n",
share_name, server_name);
- lp_smbcli_options(tctx->lp_ctx, &smb_options);
- lp_smbcli_session_options(tctx->lp_ctx, &smb_session_options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &smb_options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &smb_session_options);
torture_assert_ntstatus_ok(tctx,
smbcli_full_connection(tctx, cli, server_name,
- lp_smb_ports(tctx->lp_ctx),
+ lpcfg_smb_ports(tctx->lp_ctx),
share_name, NULL,
- lp_socket_options(tctx->lp_ctx),
+ lpcfg_socket_options(tctx->lp_ctx),
cmdline_credentials,
- lp_resolve_context(tctx->lp_ctx),
+ lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev,
&smb_options,
&smb_session_options,
- lp_gensec_settings(tctx, tctx->lp_ctx)),
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx)),
"failed to open driver share");
return true;
test_credentials = cli_credentials_init(tctx);
cli_credentials_set_workstation(test_credentials, "localhost", CRED_SPECIFIED);
- cli_credentials_set_domain(test_credentials, lp_workgroup(tctx->lp_ctx),
+ cli_credentials_set_domain(test_credentials, lpcfg_workgroup(tctx->lp_ctx),
CRED_SPECIFIED);
cli_credentials_set_username(test_credentials, t->user.username, CRED_SPECIFIED);
cli_credentials_set_password(test_credentials, testuser_passwd, CRED_SPECIFIED);
torture_assert_ntstatus_ok(tctx, dcerpc_register_ep_server(&ep_server),
"unable to register spoolss server");
- lp_set_cmdline(tctx->lp_ctx, "dcerpc endpoint servers", "spoolss");
+ lpcfg_set_cmdline(tctx->lp_ctx, "dcerpc endpoint servers", "spoolss");
- load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+ load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
address = iface_n_ip(ifaces, 0);
torture_comment(tctx, "Listening for callbacks on %s\n", address);
u.info21.description.string = talloc_asprintf(join,
"Samba4 torture account created by host %s: %s",
- lp_netbios_name(torture->lp_ctx),
+ lpcfg_netbios_name(torture->lp_ctx),
timestring(join, time(NULL)));
printf("Resetting ACB flags, force pw change time\n");
return NULL;
}
- libnet_ctx = libnet_context_init(tctx->ev, tctx->lp_ctx);
+ libnet_ctx = libnet_context_init(tctx->ev, tctx->lp_ctx);
if (!libnet_ctx) {
talloc_free(tj);
return NULL;
u.info21.description.string = talloc_asprintf(tj,
"Samba4 torture account created by host %s: %s",
- lp_netbios_name(tctx->lp_ctx), timestring(tj, time(NULL)));
+ lpcfg_netbios_name(tctx->lp_ctx), timestring(tj, time(NULL)));
status = dcerpc_samr_SetUserInfo_r(tj->p->binding_handle, tj, &s);
if (!NT_STATUS_IS_OK(status)) {
NTSTATUS status;
struct wkssvc_NetrWkstaUserGetInfo r;
union wkssvc_NetrWkstaUserInfo info;
- const char *dom = lp_workgroup(tctx->lp_ctx);
+ const char *dom = lpcfg_workgroup(tctx->lp_ctx);
struct cli_credentials *creds = cmdline_credentials;
const char *user = cli_credentials_get_username(creds);
int i;
struct wkssvc_NetrLogonDomainNameAdd r;
struct dcerpc_binding_handle *b = p->binding_handle;
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
torture_comment(tctx, "Testing NetrLogonDomainNameAdd\n");
struct wkssvc_NetrLogonDomainNameDel r;
struct dcerpc_binding_handle *b = p->binding_handle;
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
torture_comment(tctx, "Testing NetrLogonDomainNameDel\n");
for (i=0; i<ARRAY_SIZE(levels); i++) {
r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.name = lp_workgroup(tctx->lp_ctx);
+ r.in.name = lpcfg_workgroup(tctx->lp_ctx);
r.in.Account = NULL;
r.in.Password = NULL;
r.in.name_type = levels[i];
for (i=0; i<ARRAY_SIZE(levels); i++) {
r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.name = lp_workgroup(tctx->lp_ctx);
+ r.in.name = lpcfg_workgroup(tctx->lp_ctx);
r.in.Account = NULL;
r.in.EncryptedPassword = NULL;
r.in.name_type = levels[i];
struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
r.in.Account = NULL;
r.in.unknown = NULL;
r.in.num_ous = r.out.num_ous = &num_ous;
struct dcerpc_binding_handle *b = p->binding_handle;
r.in.server_name = dcerpc_server_name(p);
- r.in.domain_name = lp_workgroup(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_workgroup(tctx->lp_ctx);
r.in.Account = NULL;
r.in.EncryptedPassword = NULL;
r.in.num_ous = r.out.num_ous = &num_ous;
struct dcerpc_binding_handle *b = p->binding_handle;
admin_account = talloc_asprintf(tctx, "%s\\%s",
- lp_workgroup(tctx->lp_ctx),
+ lpcfg_workgroup(tctx->lp_ctx),
user);
r.in.server_name = dcerpc_server_name(p);
struct dcerpc_binding_handle *b = p->binding_handle;
admin_account = talloc_asprintf(tctx, "%s\\%s",
- lp_workgroup(tctx->lp_ctx),
+ lpcfg_workgroup(tctx->lp_ctx),
user);
r.in.server_name = dcerpc_server_name(p);
- r.in.domain_name = lp_dnsdomain(tctx->lp_ctx);
+ r.in.domain_name = lpcfg_dnsdomain(tctx->lp_ctx);
r.in.account_ou = NULL;
r.in.Account = admin_account;
r.in.password = NULL;
switch (argc) {
case 0:
- lp_dump(tctx->lp_ctx, stdout,
+ lpcfg_dump(tctx->lp_ctx, stdout,
false /* show_defaults */,
0 /* skip services */);
break;
case 2:
name = talloc_asprintf(NULL, "torture:%s", argv[0]);
- lp_set_cmdline(tctx->lp_ctx, name, argv[1]);
+ lpcfg_set_cmdline(tctx->lp_ctx, name, argv[1]);
talloc_free(name);
break;
struct cli_credentials *credentials = cmdline_credentials;
struct smbcli_options options;
- lp_smbcli_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &options);
options.use_level2_oplocks = false;
status = smb2_connect(tctx, host,
- lp_smb_ports(tctx->lp_ctx), share,
- lp_resolve_context(tctx->lp_ctx),
+ lpcfg_smb_ports(tctx->lp_ctx), share,
+ lpcfg_resolve_context(tctx->lp_ctx),
credentials, tree, tctx->ev, &options,
- lp_socket_options(tctx->lp_ctx),
- lp_gensec_settings(tctx, tctx->lp_ctx));
+ lpcfg_socket_options(tctx->lp_ctx),
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
torture_comment(tctx, "Failed to connect to SMB2 share "
"\\\\%s\\%s - %s\n", host, share,
struct smb2_request *req;
struct smbcli_options options;
- lp_smbcli_options(torture->lp_ctx, &options);
+ lpcfg_smbcli_options(torture->lp_ctx, &options);
status = smb2_connect(mem_ctx, host,
- lp_smb_ports(torture->lp_ctx),
+ lpcfg_smb_ports(torture->lp_ctx),
share,
- lp_resolve_context(torture->lp_ctx),
+ lpcfg_resolve_context(torture->lp_ctx),
credentials, &tree, torture->ev, &options,
- lp_socket_options(torture->lp_ctx),
- lp_gensec_settings(torture, torture->lp_ctx));
+ lpcfg_socket_options(torture->lp_ctx),
+ lpcfg_gensec_settings(torture, torture->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
printf("Connection failed - %s\n", nt_errstr(status));
return false;
if (!smb2_request_receive(req)) {
talloc_free(tree);
status = smb2_connect(mem_ctx, host,
- lp_smb_ports(torture->lp_ctx),
+ lpcfg_smb_ports(torture->lp_ctx),
share,
- lp_resolve_context(torture->lp_ctx),
+ lpcfg_resolve_context(torture->lp_ctx),
credentials, &tree, torture->ev, &options,
- lp_socket_options(torture->lp_ctx),
- lp_gensec_settings(mem_ctx, torture->lp_ctx));
+ lpcfg_socket_options(torture->lp_ctx),
+ lpcfg_gensec_settings(mem_ctx, torture->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
printf("Connection failed - %s\n", nt_errstr(status));
return false;
struct cli_credentials *credentials = cmdline_credentials;
struct smbcli_options options;
- lp_smbcli_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &options);
status = smb2_connect(tctx, host,
- lp_smb_ports(tctx->lp_ctx),
+ lpcfg_smb_ports(tctx->lp_ctx),
share,
- lp_resolve_context(tctx->lp_ctx),
+ lpcfg_resolve_context(tctx->lp_ctx),
credentials, tree,
tctx->ev, &options,
- lp_socket_options(tctx->lp_ctx),
- lp_gensec_settings(tctx, tctx->lp_ctx)
+ lpcfg_socket_options(tctx->lp_ctx),
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx)
);
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to connect to SMB2 share \\\\%s\\%s - %s\n",
}
}
- cd = smb_iconv_open_ex(tctx, to, from, lp_parm_bool(tctx->lp_ctx, NULL, "iconv", "native", true));
+ cd = smb_iconv_open_ex(tctx, to, from, lpcfg_parm_bool(tctx->lp_ctx, NULL, "iconv", "native", true));
if((int)cd == -1) {
DEBUG(0,("unable to find from or to encoding, exiting...\n"));
if (out != stdout) fclose(out);
d_printf("Invalid option: %s is not a valid torture target (share or binding string)\n\n", target);
return false;
}
- lp_set_cmdline(lp_ctx, "torture:host", binding_struct->host);
- if (lp_parm_string(lp_ctx, NULL, "torture", "share") == NULL)
- lp_set_cmdline(lp_ctx, "torture:share", "IPC$");
- lp_set_cmdline(lp_ctx, "torture:binding", target);
+ lpcfg_set_cmdline(lp_ctx, "torture:host", binding_struct->host);
+ if (lpcfg_parm_string(lp_ctx, NULL, "torture", "share") == NULL)
+ lpcfg_set_cmdline(lp_ctx, "torture:share", "IPC$");
+ lpcfg_set_cmdline(lp_ctx, "torture:binding", target);
} else {
- lp_set_cmdline(lp_ctx, "torture:host", host);
- lp_set_cmdline(lp_ctx, "torture:share", share);
- lp_set_cmdline(lp_ctx, "torture:binding", host);
+ lpcfg_set_cmdline(lp_ctx, "torture:host", host);
+ lpcfg_set_cmdline(lp_ctx, "torture:share", share);
+ lpcfg_set_cmdline(lp_ctx, "torture:binding", host);
}
return true;
/* retrievieng the userdn */
p = strchr_m(dns, '#');
if (!p) {
- lp_set_cmdline(lp_ctx, "torture:ldap_userdn", "");
- lp_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
- lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_userdn", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", "");
return;
}
userdn = strndup(dns, p - dns);
- lp_set_cmdline(lp_ctx, "torture:ldap_userdn", userdn);
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_userdn", userdn);
/* retrieve the basedn */
d = p + 1;
p = strchr_m(d, '#');
if (!p) {
- lp_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
- lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", "");
return;
}
basedn = strndup(d, p - d);
- lp_set_cmdline(lp_ctx, "torture:ldap_basedn", basedn);
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_basedn", basedn);
/* retrieve the secret */
p = p + 1;
if (!p) {
- lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", "");
return;
}
secret = strdup(p);
- lp_set_cmdline(lp_ctx, "torture:ldap_secret", secret);
+ lpcfg_set_cmdline(lp_ctx, "torture:ldap_secret", secret);
printf ("%s - %s - %s\n", userdn, basedn, secret);
while((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_LOADFILE:
- lp_set_cmdline(cmdline_lp_ctx, "torture:loadfile", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:loadfile", poptGetOptArg(pc));
break;
case OPT_UNCLIST:
- lp_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
break;
case OPT_TIMELIMIT:
- lp_set_cmdline(cmdline_lp_ctx, "torture:timelimit", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:timelimit", poptGetOptArg(pc));
break;
case OPT_NUMPROGS:
- lp_set_cmdline(cmdline_lp_ctx, "torture:nprocs", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:nprocs", poptGetOptArg(pc));
break;
case OPT_DNS:
parse_dns(cmdline_lp_ctx, poptGetOptArg(pc));
break;
case OPT_DANGEROUS:
- lp_set_cmdline(cmdline_lp_ctx, "torture:dangerous", "Yes");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:dangerous", "Yes");
break;
case OPT_ASYNC:
- lp_set_cmdline(cmdline_lp_ctx, "torture:async", "Yes");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:async", "Yes");
break;
case OPT_SMB_PORTS:
- lp_set_cmdline(cmdline_lp_ctx, "smb ports", poptGetOptArg(pc));
+ lpcfg_set_cmdline(cmdline_lp_ctx, "smb ports", poptGetOptArg(pc));
break;
case OPT_EXTRA_USER:
{
char *option = talloc_asprintf(NULL, "torture:extra_user%u",
++num_extra_users);
const char *value = poptGetOptArg(pc);
- lp_set_cmdline(cmdline_lp_ctx, option, value);
+ lpcfg_set_cmdline(cmdline_lp_ctx, option, value);
talloc_free(option);
}
break;
}
if (strcmp(target, "samba3") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:samba3", "true");
- lp_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba3", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
} else if (strcmp(target, "samba4") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
} else if (strcmp(target, "winxp") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:winxp", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:winxp", "true");
} else if (strcmp(target, "w2k3") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:w2k3", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:w2k3", "true");
} else if (strcmp(target, "w2k8") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:w2k8", "true");
- lp_set_cmdline(cmdline_lp_ctx,
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:w2k8", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx,
"torture:invalid_lock_range_support", "false");
} else if (strcmp(target, "win7") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:win7", "true");
- lp_set_cmdline(cmdline_lp_ctx, "torture:cn_max_buffer_size",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:win7", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:cn_max_buffer_size",
"0x00010000");
- lp_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
/* RAW-SEARCH for fails for inexplicable reasons against win7 */
- lp_set_cmdline(cmdline_lp_ctx, "torture:search_ea_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:search_ea_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:hide_on_access_denied",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:hide_on_access_denied",
"true");
} else if (strcmp(target, "onefs") == 0) {
- lp_set_cmdline(cmdline_lp_ctx, "torture:onefs", "true");
- lp_set_cmdline(cmdline_lp_ctx, "torture:openx_deny_dos_support",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:onefs", "true");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:openx_deny_dos_support",
"false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:range_not_locked_on_file_close", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:sacl_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:ea_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:smbexit_pdu_support",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:range_not_locked_on_file_close", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:sacl_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:ea_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:smbexit_pdu_support",
"false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:smblock_pdu_support",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:smblock_pdu_support",
"false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:2_step_break_to_none",
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:2_step_break_to_none",
"true");
- lp_set_cmdline(cmdline_lp_ctx, "torture:deny_dos_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:deny_fcb_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:read_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:writeclose_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:raw_search_search", "false");
- lp_set_cmdline(cmdline_lp_ctx, "torture:search_ea_size", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:deny_dos_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:deny_fcb_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:read_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:writeclose_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:resume_key_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:rewind_support", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:raw_search_search", "false");
+ lpcfg_set_cmdline(cmdline_lp_ctx, "torture:search_ea_size", "false");
}
if (max_runtime) {
struct smbcli_options options;
struct smbcli_session_options session_options;
- lp_smbcli_options(tctx->lp_ctx, &options);
- lp_smbcli_session_options(tctx->lp_ctx, &session_options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &session_options);
status = smbcli_full_connection(tctx, &cli, host,
- lp_smb_ports(tctx->lp_ctx),
- share, NULL, lp_socket_options(tctx->lp_ctx),
+ lpcfg_smb_ports(tctx->lp_ctx),
+ share, NULL, lpcfg_socket_options(tctx->lp_ctx),
cmdline_credentials,
- lp_resolve_context(tctx->lp_ctx),
+ lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev, &options, &session_options,
- lp_gensec_settings(tctx, tctx->lp_ctx));
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
printf("failed to connect to //%s/%s: %s\n",
struct smbcli_options options;
struct smbcli_session_options session_options;
- lp_smbcli_options(tctx->lp_ctx, &options);
- lp_smbcli_session_options(tctx->lp_ctx, &session_options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &session_options);
status = smbcli_full_connection(tctx, &cli, host,
- lp_smb_ports(tctx->lp_ctx),
- share, NULL, lp_socket_options(tctx->lp_ctx),
- creds, lp_resolve_context(tctx->lp_ctx),
+ lpcfg_smb_ports(tctx->lp_ctx),
+ share, NULL, lpcfg_socket_options(tctx->lp_ctx),
+ creds, lpcfg_resolve_context(tctx->lp_ctx),
tctx->ev, &options, &session_options,
- lp_gensec_settings(tctx, tctx->lp_ctx));
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
printf("failed to connect to //%s/%s: %s\n",
struct smbcli_options options;
struct smbcli_session_options session_options;
- lp_smbcli_options(tctx->lp_ctx, &options);
- lp_smbcli_session_options(tctx->lp_ctx, &session_options);
+ lpcfg_smbcli_options(tctx->lp_ctx, &options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &session_options);
options.use_oplocks = torture_setting_bool(tctx, "use_oplocks", true);
options.use_level2_oplocks = torture_setting_bool(tctx, "use_level2_oplocks", true);
status = smbcli_full_connection(mem_ctx, c, hostname,
- lp_smb_ports(tctx->lp_ctx),
+ lpcfg_smb_ports(tctx->lp_ctx),
sharename, NULL,
- lp_socket_options(tctx->lp_ctx),
+ lpcfg_socket_options(tctx->lp_ctx),
cmdline_credentials,
- lp_resolve_context(tctx->lp_ctx),
+ lpcfg_resolve_context(tctx->lp_ctx),
ev, &options, &session_options,
- lp_gensec_settings(tctx, tctx->lp_ctx));
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to open connection - %s\n", nt_errstr(status));
return false;
printf("asprintf failed\n");
return -1;
}
- lp_set_cmdline(tctx->lp_ctx, "netbios name", myname);
+ lpcfg_set_cmdline(tctx->lp_ctx, "netbios name", myname);
free(myname);
separator = torture_setting_string(torture,
"winbindd_separator",
- lp_winbind_separator(torture->lp_ctx));
+ lpcfg_winbind_separator(torture->lp_ctx));
torture_assert_int_equal(torture,
rep.data.info.winbind_separator,
expected = torture_setting_string(torture,
"winbindd_netbios_name",
- lp_netbios_name(torture->lp_ctx));
+ lpcfg_netbios_name(torture->lp_ctx));
expected = strupper_talloc(torture, expected);
torture_assert_str_equal(torture,
expected = torture_setting_string(torture,
"winbindd_netbios_domain",
- lp_workgroup(torture->lp_ctx));
+ lpcfg_workgroup(torture->lp_ctx));
get_winbind_domain(torture, &domain);
bool strict = torture_setting_bool(torture, "strict mode", false);
const char *domain_name = torture_setting_string(torture,
"winbindd_netbios_domain",
- lp_workgroup(torture->lp_ctx));
+ lpcfg_workgroup(torture->lp_ctx));
struct torture_trust_domain *listd = NULL;
uint32_t i, count = 0;
char *name;
const char *domain_name = torture_setting_string(torture,
"winbindd_netbios_domain",
- lp_workgroup(torture->lp_ctx));
+ lpcfg_workgroup(torture->lp_ctx));
ZERO_STRUCT(req);
ZERO_STRUCT(rep);
* user, needed for a token */
status = authsam_make_server_info(gp_ctx,
gp_ctx->ldb_ctx,
- lp_netbios_name(gp_ctx->lp_ctx),
- lp_sam_name(gp_ctx->lp_ctx),
+ lpcfg_netbios_name(gp_ctx->lp_ctx),
+ lpcfg_sam_name(gp_ctx->lp_ctx),
ldb_get_default_basedn(gp_ctx->ldb_ctx),
result->msgs[0],
dummy,
return -1;
}
/* prepare parameters for the join */
- r->in.netbios_name = lp_netbios_name(ctx->lp_ctx);
+ r->in.netbios_name = lpcfg_netbios_name(ctx->lp_ctx);
r->in.domain_name = domain_name;
r->in.join_type = secure_channel_type;
r->in.level = LIBNET_JOIN_AUTOMATIC;
nt_status = ntlm_password_check(mem_ctx,
- lp_lanman_auth(lp_ctx),
- lp_ntlm_auth(lp_ctx),
+ lpcfg_lanman_auth(lp_ctx),
+ lpcfg_ntlm_auth(lp_ctx),
MSV1_0_ALLOW_SERVER_TRUST_ACCOUNT |
MSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNT,
challenge,
if (NT_STATUS_IS_OK(nt_status)) {
if (unix_name) {
if (asprintf(unix_name, "%s%c%s", domain,
- *lp_winbind_separator(lp_ctx),
+ *lpcfg_winbind_separator(lp_ctx),
username) < 0) {
nt_status = NT_STATUS_NO_MEMORY;
}
/* setup the client side */
nt_status = gensec_client_start(NULL, &state->gensec_state, ev,
- lp_gensec_settings(NULL, lp_ctx));
+ lpcfg_gensec_settings(NULL, lp_ctx));
if (!NT_STATUS_IS_OK(nt_status)) {
talloc_free(mem_ctx);
exit(1);
const char *winbind_method[] = { "winbind", NULL };
struct auth_context *auth_context;
- msg = messaging_client_init(state, lp_messaging_path(state, lp_ctx), ev);
+ msg = messaging_client_init(state, lpcfg_messaging_path(state, lp_ctx), ev);
if (!msg) {
talloc_free(mem_ctx);
exit(1);
}
if (!NT_STATUS_IS_OK(gensec_server_start(state, ev,
- lp_gensec_settings(state, lp_ctx),
+ lpcfg_gensec_settings(state, lp_ctx),
auth_context, &state->gensec_state))) {
talloc_free(mem_ctx);
exit(1);
reply_code = "AF";
reply_arg = talloc_asprintf(state->gensec_state,
"%s%s%s", session_info->server_info->domain_name,
- lp_winbind_separator(lp_ctx), session_info->server_info->account_name);
+ lpcfg_winbind_separator(lp_ctx), session_info->server_info->account_name);
talloc_free(session_info);
}
} else if (state->gensec_state->gensec_role == GENSEC_CLIENT) {
} else if (plaintext_password) {
/* handle this request as plaintext */
if (!full_username) {
- if (asprintf(&full_username, "%s%c%s", domain, *lp_winbind_separator(lp_ctx), username) < 0) {
+ if (asprintf(&full_username, "%s%c%s", domain, *lpcfg_winbind_separator(lp_ctx), username) < 0) {
mux_printf(mux_id, "Error: Out of memory in asprintf!\n.\n");
return;
}
SAFE_FREE(domain);
if (!parse_ntlm_auth_domain_user(full_username, &username,
&domain,
- *lp_winbind_separator(lp_ctx))) {
+ *lpcfg_winbind_separator(lp_ctx))) {
/* username might be 'tainted', don't print into our new-line deleimianted stream */
mux_printf(mux_id, "Error: Could not parse into domain and username\n");
}
}
if (!domain) {
- domain = smb_xstrdup(lp_workgroup(lp_ctx));
+ domain = smb_xstrdup(lpcfg_workgroup(lp_ctx));
}
if (ntlm_server_1_lm_session_key)
local_pw_check_specified(lp_ctx,
username,
domain,
- lp_netbios_name(lp_ctx),
+ lpcfg_netbios_name(lp_ctx),
&challenge,
&lm_response,
&nt_response,
}
}
-static void manage_squid_request(struct loadparm_context *lp_ctx, enum stdio_helper_mode helper_mode,
+static void manage_squid_request(struct loadparm_context *lp_ctx, enum stdio_helper_mode helper_mode,
stdio_helper_function fn, void **private2)
{
char *buf;
talloc_free(buf);
}
-static void squid_stream(struct loadparm_context *lp_ctx,
+static void squid_stream(struct loadparm_context *lp_ctx,
enum stdio_helper_mode stdio_mode,
stdio_helper_function fn) {
/* initialize FDescs */
gensec_init(cmdline_lp_ctx);
if (opt_domain == NULL) {
- opt_domain = lp_workgroup(cmdline_lp_ctx);
+ opt_domain = lpcfg_workgroup(cmdline_lp_ctx);
}
if (helper_protocol) {
}
if (opt_workstation == NULL) {
- opt_workstation = lp_netbios_name(cmdline_lp_ctx);
+ opt_workstation = lpcfg_netbios_name(cmdline_lp_ctx);
}
if (!opt_password) {
char *user;
if (asprintf(&user, "%s%c%s", opt_domain,
- *lp_winbind_separator(cmdline_lp_ctx),
+ *lpcfg_winbind_separator(cmdline_lp_ctx),
opt_username) < 0) {
return 1;
}
static void websrv_task_init(struct task_server *task)
{
NTSTATUS status;
- uint16_t port = lp_web_port(task->lp_ctx);
+ uint16_t port = lpcfg_web_port(task->lp_ctx);
const struct model_ops *model_ops;
struct web_server_data *wdata;
model_ops = process_model_startup(task->event_ctx, "single");
if (!model_ops) goto failed;
- if (lp_interfaces(task->lp_ctx) && lp_bind_interfaces_only(task->lp_ctx)) {
+ if (lpcfg_interfaces(task->lp_ctx) && lpcfg_bind_interfaces_only(task->lp_ctx)) {
int num_interfaces;
int i;
struct interface *ifaces;
- load_interfaces(NULL, lp_interfaces(task->lp_ctx), &ifaces);
+ load_interfaces(NULL, lpcfg_interfaces(task->lp_ctx), &ifaces);
num_interfaces = iface_count(ifaces);
for(i = 0; i < num_interfaces; i++) {
const char *address = iface_n_ip(ifaces, i);
status = stream_setup_socket(task->event_ctx,
- task->lp_ctx, model_ops,
+ task->lp_ctx, model_ops,
&web_stream_ops,
"ipv4", address,
- &port, lp_socket_options(task->lp_ctx),
+ &port, lpcfg_socket_options(task->lp_ctx),
task);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
} else {
status = stream_setup_socket(task->event_ctx, task->lp_ctx,
model_ops, &web_stream_ops,
- "ipv4", lp_socket_address(task->lp_ctx),
- &port, lp_socket_options(task->lp_ctx), task);
+ "ipv4", lpcfg_socket_address(task->lp_ctx),
+ &port, lpcfg_socket_options(task->lp_ctx), task);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
idmap_ctx->lp_ctx = lp_ctx;
idmap_ctx->ldb_ctx = ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx,
- lp_idmap_url(lp_ctx),
+ lpcfg_idmap_url(lp_ctx),
system_session(lp_ctx),
NULL, 0);
if (idmap_ctx->ldb_ctx == NULL) {
*
* If no mapping exists, a new mapping will be created.
*
- * \todo Check if SIDs can be resolved if lp_idmap_trusted_only() == true
+ * \todo Check if SIDs can be resolved if lpcfg_idmap_trusted_only() == true
* \todo Fix backwards compatibility for Samba3
*
* \param idmap_ctx idmap context to use
goto failed;
}
- /*FIXME: if lp_idmap_trusted_only() == true, check if SID can be
+ /*FIXME: if lpcfg_idmap_trusted_only() == true, check if SID can be
* resolved here. */
ret = idmap_get_bounds(idmap_ctx, &low, &high);
WBSRV_SAMBA3_SET_STRING(pw->pw_passwd, "*");
WBSRV_SAMBA3_SET_STRING(pw->pw_gecos, user_info->out.full_name);
WBSRV_SAMBA3_SET_STRING(pw->pw_dir,
- lp_template_homedir(state->service->task->lp_ctx));
+ lpcfg_template_homedir(state->service->task->lp_ctx));
all_string_sub(pw->pw_dir, "%WORKGROUP%", state->workgroup_name,
sizeof(fstring) - 1);
all_string_sub(pw->pw_dir, "%ACCOUNTNAME%", user_info->out.account_name,
sizeof(fstring) - 1);
WBSRV_SAMBA3_SET_STRING(pw->pw_shell,
- lp_template_shell(state->service->task->lp_ctx));
+ lpcfg_template_shell(state->service->task->lp_ctx));
state->group_sid = dom_sid_dup(state, user_info->out.primary_group_sid);
if(composite_nomem(state->group_sid, state->ctx)) return;
WBSRV_SAMBA3_SET_STRING(pw->pw_passwd, "*");
WBSRV_SAMBA3_SET_STRING(pw->pw_gecos, user_info->out.full_name);
WBSRV_SAMBA3_SET_STRING(pw->pw_dir,
- lp_template_homedir(state->service->task->lp_ctx));
+ lpcfg_template_homedir(state->service->task->lp_ctx));
all_string_sub(pw->pw_dir, "%WORKGROUP%", state->workgroup,
sizeof(fstring) - 1);
all_string_sub(pw->pw_dir, "%ACCOUNTNAME%", user_info->out.account_name,
sizeof(fstring) - 1);
WBSRV_SAMBA3_SET_STRING(pw->pw_shell,
- lp_template_shell(state->service->task->lp_ctx));
+ lpcfg_template_shell(state->service->task->lp_ctx));
pw->pw_uid = state->uid;
dom_sid = dom_sid_dup(mem_ctx, sid);
if (dom_sid == NULL) goto failed;
- ctx = finddcs_send(mem_ctx, lp_netbios_name(service->task->lp_ctx),
- lp_nbt_port(service->task->lp_ctx),
+ ctx = finddcs_send(mem_ctx, lpcfg_netbios_name(service->task->lp_ctx),
+ lpcfg_nbt_port(service->task->lp_ctx),
domain_name, NBT_NAME_LOGON,
dom_sid,
- lp_resolve_context(service->task->lp_ctx),
+ lpcfg_resolve_context(service->task->lp_ctx),
service->task->event_ctx,
service->task->msg_ctx);
if (ctx == NULL) goto failed;
if (*state->info->dcs[0].name == '\\') state->info->dcs[0].name++;
make_nbt_name(&name, state->info->dcs[0].name, 0x20);
- ctx = resolve_name_send(lp_resolve_context(state->service->task->lp_ctx), state,
+ ctx = resolve_name_send(lpcfg_resolve_context(state->service->task->lp_ctx), state,
&name, state->service->task->event_ctx);
composite_continue(state->ctx, ctx, trusted_dom_info_recv_dcaddr,
state->domain->netlogon_pipe = NULL;
if ((!cli_credentials_is_anonymous(state->domain->libnet_ctx->cred)) &&
- ((lp_server_role(service->task->lp_ctx) == ROLE_DOMAIN_MEMBER) ||
- (lp_server_role(service->task->lp_ctx) == ROLE_DOMAIN_CONTROLLER)) &&
+ ((lpcfg_server_role(service->task->lp_ctx) == ROLE_DOMAIN_MEMBER) ||
+ (lpcfg_server_role(service->task->lp_ctx) == ROLE_DOMAIN_CONTROLLER)) &&
(dom_sid_equal(state->domain->info->sid,
state->service->primary_sid))) {
state->domain->netlogon_binding->flags |= DCERPC_SCHANNEL;
/* For debugging, it can be a real pain if all the traffic is encrypted */
- if (lp_winbind_sealed_pipes(service->task->lp_ctx)) {
+ if (lpcfg_winbind_sealed_pipes(service->task->lp_ctx)) {
state->domain->netlogon_binding->flags |= (DCERPC_SIGN | DCERPC_SEAL );
} else {
state->domain->netlogon_binding->flags |= (DCERPC_SIGN);
state->domain->lsa_binding = init_domain_binding(state, &ndr_table_lsarpc);
/* For debugging, it can be a real pain if all the traffic is encrypted */
- if (lp_winbind_sealed_pipes(state->service->task->lp_ctx)) {
+ if (lpcfg_winbind_sealed_pipes(state->service->task->lp_ctx)) {
state->domain->lsa_binding->flags |= (DCERPC_SIGN | DCERPC_SEAL );
} else {
state->domain->lsa_binding->flags |= (DCERPC_SIGN);
state->unix_username = talloc_asprintf(state, "%s%s%s",
state->domain_name,
- lp_winbind_separator(state->lp_ctx),
+ lpcfg_winbind_separator(state->lp_ctx),
state->user_name);
if (composite_nomem(state->unix_username, state->ctx)) return;
const char *user, *domain;
DATA_BLOB chal, nt_resp, lm_resp, names_blob;
int flags = CLI_CRED_NTLM_AUTH;
- if (lp_client_lanman_auth(service->task->lp_ctx)) {
+ if (lpcfg_client_lanman_auth(service->task->lp_ctx)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth(service->task->lp_ctx)) {
+ if (lpcfg_client_ntlmv2_auth(service->task->lp_ctx)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
NTSTATUS wbsrv_samba3_info(struct wbsrv_samba3_call *s3call)
{
s3call->response->result = WINBINDD_OK;
- s3call->response->data.info.winbind_separator = *lp_winbind_separator(s3call->wbconn->lp_ctx);
+ s3call->response->data.info.winbind_separator = *lpcfg_winbind_separator(s3call->wbconn->lp_ctx);
WBSRV_SAMBA3_SET_STRING(s3call->response->data.info.samba_version,
SAMBA_VERSION_STRING);
return NT_STATUS_OK;
{
s3call->response->result = WINBINDD_OK;
WBSRV_SAMBA3_SET_STRING(s3call->response->data.domain_name,
- lp_workgroup(s3call->wbconn->lp_ctx));
+ lpcfg_workgroup(s3call->wbconn->lp_ctx));
return NT_STATUS_OK;
}
{
s3call->response->result = WINBINDD_OK;
WBSRV_SAMBA3_SET_STRING(s3call->response->data.netbios_name,
- lp_netbios_name(s3call->wbconn->lp_ctx));
+ lpcfg_netbios_name(s3call->wbconn->lp_ctx));
return NT_STATUS_OK;
}
NTSTATUS wbsrv_samba3_priv_pipe_dir(struct wbsrv_samba3_call *s3call)
{
struct loadparm_context *lp_ctx = s3call->wbconn->listen_socket->service->task->lp_ctx;
- const char *priv_socket_dir = lp_winbindd_privileged_socket_directory(lp_ctx);
+ const char *priv_socket_dir = lpcfg_winbindd_privileged_socket_directory(lp_ctx);
s3call->response->result = WINBINDD_OK;
s3call->response->extra_data.data = discard_const(priv_socket_dir);
}
/* Make sure the directory for the Samba3 socket exists, and is of the correct permissions */
- if (!directory_create_or_exist(lp_winbindd_socket_directory(task->lp_ctx), geteuid(), 0755)) {
+ if (!directory_create_or_exist(lpcfg_winbindd_socket_directory(task->lp_ctx), geteuid(), 0755)) {
task_server_terminate(task,
"Cannot create winbindd pipe directory", true);
return;
}
/* Make sure the directory for the Samba3 socket exists, and is of the correct permissions */
- if (!directory_create_or_exist(lp_winbindd_privileged_socket_directory(task->lp_ctx), geteuid(), 0750)) {
+ if (!directory_create_or_exist(lpcfg_winbindd_privileged_socket_directory(task->lp_ctx), geteuid(), 0750)) {
task_server_terminate(task,
"Cannot create winbindd privileged pipe directory", true);
return;
/* Find the primary SID, depending if we are a standalone
* server (what good is winbind in this case, but anyway...),
* or are in a domain as a member or a DC */
- switch (lp_server_role(service->task->lp_ctx)) {
+ switch (lpcfg_server_role(service->task->lp_ctx)) {
case ROLE_STANDALONE:
primary_sid = secrets_get_domain_sid(service,
service->task->event_ctx,
service->task->lp_ctx,
- lp_netbios_name(service->task->lp_ctx), &errstring);
+ lpcfg_netbios_name(service->task->lp_ctx), &errstring);
if (!primary_sid) {
char *message = talloc_asprintf(task,
"Cannot start Winbind (standalone configuration): %s: "
"Have you provisioned this server (%s) or changed it's name?",
- errstring, lp_netbios_name(service->task->lp_ctx));
+ errstring, lpcfg_netbios_name(service->task->lp_ctx));
task_server_terminate(task, message, true);
return;
}
primary_sid = secrets_get_domain_sid(service,
service->task->event_ctx,
service->task->lp_ctx,
- lp_workgroup(service->task->lp_ctx), &errstring);
+ lpcfg_workgroup(service->task->lp_ctx), &errstring);
if (!primary_sid) {
char *message = talloc_asprintf(task, "Cannot start Winbind (domain member): %s: "
"Have you joined the %s domain?",
- errstring, lp_workgroup(service->task->lp_ctx));
+ errstring, lpcfg_workgroup(service->task->lp_ctx));
task_server_terminate(task, message, true);
return;
}
primary_sid = secrets_get_domain_sid(service,
service->task->event_ctx,
service->task->lp_ctx,
- lp_workgroup(service->task->lp_ctx), &errstring);
+ lpcfg_workgroup(service->task->lp_ctx), &errstring);
if (!primary_sid) {
char *message = talloc_asprintf(task, "Cannot start Winbind (domain controller): %s: "
"Have you provisioned the %s domain?",
- errstring, lp_workgroup(service->task->lp_ctx));
+ errstring, lpcfg_workgroup(service->task->lp_ctx));
task_server_terminate(task, message, true);
return;
}
return;
}
- service->priv_pipe_dir = lp_winbindd_privileged_socket_directory(task->lp_ctx);
- service->pipe_dir = lp_winbindd_socket_directory(task->lp_ctx);
+ service->priv_pipe_dir = lpcfg_winbindd_privileged_socket_directory(task->lp_ctx);
+ service->pipe_dir = lpcfg_winbindd_socket_directory(task->lp_ctx);
/* setup the unprivileged samba3 socket */
listen_socket = talloc(service, struct wbsrv_listen_socket);
status = stream_setup_socket(task->event_ctx, task->lp_ctx, model_ops,
&wbsrv_ops, "unix",
listen_socket->socket_path, &port,
- lp_socket_options(task->lp_ctx),
+ lpcfg_socket_options(task->lp_ctx),
listen_socket);
if (!NT_STATUS_IS_OK(status)) goto listen_failed;
status = stream_setup_socket(task->event_ctx, task->lp_ctx, model_ops,
&wbsrv_ops, "unix",
listen_socket->socket_path, &port,
- lp_socket_options(task->lp_ctx),
+ lpcfg_socket_options(task->lp_ctx),
listen_socket);
if (!NT_STATUS_IS_OK(status)) goto listen_failed;
if (dom_sid_equal(service->primary_sid, sid) ||
dom_sid_in_domain(service->primary_sid, sid)) {
- ctx = wb_get_dom_info_send(state, service, lp_workgroup(service->task->lp_ctx),
+ ctx = wb_get_dom_info_send(state, service, lpcfg_workgroup(service->task->lp_ctx),
service->primary_sid);
if (ctx == NULL) goto failed;
ctx->async.fn = sid2domain_recv_dom_info;
const char *domuser,
char **domain, char **user)
{
- char *p = strchr(domuser, *lp_winbind_separator(lp_ctx));
+ char *p = strchr(domuser, *lpcfg_winbind_separator(lp_ctx));
if (p == NULL) {
- *domain = talloc_strdup(mem_ctx, lp_workgroup(lp_ctx));
+ *domain = talloc_strdup(mem_ctx, lpcfg_workgroup(lp_ctx));
} else {
*domain = talloc_strndup(mem_ctx, domuser,
PTR_DIFF(p, domuser));
bool changed_old_addrs = false;
bool skip_replica_owned_by_us = false;
bool become_owner = true;
- bool propagate = lp_parm_bool(partner->service->task->lp_ctx, NULL, "wreplsrv", "propagate name releases", false);
+ bool propagate = lpcfg_parm_bool(partner->service->task->lp_ctx, NULL, "wreplsrv", "propagate name releases", false);
const char *local_owner = partner->service->wins_db->local_owner;
merge = talloc(mem_ctx, struct winsdb_record);
return NT_STATUS_INTERNAL_ERROR;
}
- if (lp_interfaces(lp_ctx) && lp_bind_interfaces_only(lp_ctx)) {
+ if (lpcfg_interfaces(lp_ctx) && lpcfg_bind_interfaces_only(lp_ctx)) {
int num_interfaces;
int i;
struct interface *ifaces;
- load_interfaces(task, lp_interfaces(lp_ctx), &ifaces);
+ load_interfaces(task, lpcfg_interfaces(lp_ctx), &ifaces);
num_interfaces = iface_count(ifaces);
for(i = 0; i < num_interfaces; i++) {
address = iface_n_ip(ifaces, i);
status = stream_setup_socket(task->event_ctx,
- task->lp_ctx, model_ops,
+ task->lp_ctx, model_ops,
&wreplsrv_stream_ops,
"ipv4", address, &port,
- lp_socket_options(task->lp_ctx),
+ lpcfg_socket_options(task->lp_ctx),
service);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("stream_setup_socket(address=%s,port=%u) failed - %s\n",
}
}
} else {
- address = lp_socket_address(lp_ctx);
- status = stream_setup_socket(task->event_ctx, task->lp_ctx,
+ address = lpcfg_socket_address(lp_ctx);
+ status = stream_setup_socket(task->event_ctx, task->lp_ctx,
model_ops, &wreplsrv_stream_ops,
- "ipv4", address, &port, lp_socket_options(task->lp_ctx),
+ "ipv4", address, &port, lpcfg_socket_options(task->lp_ctx),
service);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("stream_setup_socket(address=%s,port=%u) failed - %s\n",
bool delete_tombstones;
struct timeval tombstone_extra_time;
const char *local_owner = service->wins_db->local_owner;
- bool propagate = lp_parm_bool(service->task->lp_ctx, NULL, "wreplsrv", "propagate name releases", false);
+ bool propagate = lpcfg_parm_bool(service->task->lp_ctx, NULL, "wreplsrv", "propagate name releases", false);
now_timestr = ldb_timestring(tmp_mem, now);
NT_STATUS_HAVE_NO_MEMORY(now_timestr);
struct tevent_context *ev_ctx,
struct loadparm_context *lp_ctx)
{
- return ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx, private_path(mem_ctx,
- lp_ctx, lp_wins_config_url(lp_ctx)),
+ return ldb_wrap_connect(mem_ctx, ev_ctx, lp_ctx, private_path(mem_ctx,
+ lp_ctx, lpcfg_wins_config_url(lp_ctx)),
system_session(lp_ctx), NULL, 0);
}
static NTSTATUS wreplsrv_open_winsdb(struct wreplsrv_service *service,
struct loadparm_context *lp_ctx)
{
- const char *owner = lp_parm_string(lp_ctx, NULL, "winsdb", "local_owner");
+ const char *owner = lpcfg_parm_string(lp_ctx, NULL, "winsdb", "local_owner");
if (owner == NULL) {
struct interface *ifaces;
- load_interfaces(service, lp_interfaces(lp_ctx), &ifaces);
+ load_interfaces(service, lpcfg_interfaces(lp_ctx), &ifaces);
owner = iface_n_ip(ifaces, 0);
}
}
/* the default renew interval is 6 days */
- service->config.renew_interval = lp_parm_int(lp_ctx, NULL,"wreplsrv","renew_interval", 6*24*60*60);
+ service->config.renew_interval = lpcfg_parm_int(lp_ctx, NULL,"wreplsrv","renew_interval", 6*24*60*60);
/* the default tombstone (extinction) interval is 6 days */
- service->config.tombstone_interval= lp_parm_int(lp_ctx, NULL,"wreplsrv","tombstone_interval", 6*24*60*60);
+ service->config.tombstone_interval= lpcfg_parm_int(lp_ctx, NULL,"wreplsrv","tombstone_interval", 6*24*60*60);
/* the default tombstone (extinction) timeout is 1 day */
- service->config.tombstone_timeout = lp_parm_int(lp_ctx, NULL,"wreplsrv","tombstone_timeout", 1*24*60*60);
+ service->config.tombstone_timeout = lpcfg_parm_int(lp_ctx, NULL,"wreplsrv","tombstone_timeout", 1*24*60*60);
/* the default tombstone extra timeout is 3 days */
- service->config.tombstone_extra_timeout = lp_parm_int(lp_ctx, NULL,"wreplsrv","tombstone_extra_timeout", 3*24*60*60);
+ service->config.tombstone_extra_timeout = lpcfg_parm_int(lp_ctx, NULL,"wreplsrv","tombstone_extra_timeout", 3*24*60*60);
/* the default verify interval is 24 days */
- service->config.verify_interval = lp_parm_int(lp_ctx, NULL,"wreplsrv","verify_interval", 24*24*60*60);
+ service->config.verify_interval = lpcfg_parm_int(lp_ctx, NULL,"wreplsrv","verify_interval", 24*24*60*60);
/* the default scavenging interval is 'renew_interval/2' */
- service->config.scavenging_interval=lp_parm_int(lp_ctx, NULL,"wreplsrv","scavenging_interval",
+ service->config.scavenging_interval=lpcfg_parm_int(lp_ctx, NULL,"wreplsrv","scavenging_interval",
service->config.renew_interval/2);
/* the maximun interval to the next periodic processing event */
- service->config.periodic_interval = lp_parm_int(lp_ctx, NULL,"wreplsrv","periodic_interval", 15);
+ service->config.periodic_interval = lpcfg_parm_int(lp_ctx, NULL,"wreplsrv","periodic_interval", 15);
return NT_STATUS_OK;
}
NTSTATUS status;
struct wreplsrv_service *service;
- if (!lp_wins_support(task->lp_ctx)) {
+ if (!lpcfg_wins_support(task->lp_ctx)) {
return;
}