struct auth_context **auth_ctx)
{
const char **auth_methods = NULL;
- switch (lp_server_role()) {
+ switch (lp_server_role(global_loadparm)) {
case ROLE_STANDALONE:
auth_methods = lp_parm_string_list(NULL, "auth methods", "standalone", NULL);
break;
NTSTATUS status;
if (acct_flags & ACB_PWNOTREQ) {
- if (lp_null_passwords()) {
+ if (lp_null_passwords(global_loadparm)) {
DEBUG(3,("Account for user '%s' has no password and null passwords are allowed.\n",
user_info->mapped.account_name));
return NT_STATUS_OK;
}
is_local_name = is_myname(user_info->mapped.domain_name);
- is_my_domain = strequal(user_info->mapped.domain_name, lp_workgroup());
+ is_my_domain = strequal(user_info->mapped.domain_name, lp_workgroup(global_loadparm));
/* check whether or not we service this domain/workgroup name */
- switch (lp_server_role()) {
+ switch (lp_server_role(global_loadparm)) {
case ROLE_STANDALONE:
return NT_STATUS_OK;
const char *domain;
/* check whether or not we service this domain/workgroup name */
- switch (lp_server_role()) {
+ switch (lp_server_role(global_loadparm)) {
case ROLE_STANDALONE:
case ROLE_DOMAIN_MEMBER:
- domain = lp_netbios_name();
+ domain = lp_netbios_name(global_loadparm);
break;
case ROLE_DOMAIN_CONTROLLER:
- domain = lp_workgroup();
+ domain = lp_workgroup(global_loadparm);
break;
default:
DEBUG(4,("smb_pam_auth: PAM: Authenticate User: %s\n", user));
- pam_error = pam_authenticate(pamh, PAM_SILENT | lp_null_passwords() ? 0 : PAM_DISALLOW_NULL_AUTHTOK);
+ pam_error = pam_authenticate(pamh, PAM_SILENT | lp_null_passwords(global_loadparm) ? 0 : PAM_DISALLOW_NULL_AUTHTOK);
switch( pam_error ){
case PAM_AUTH_ERR:
DEBUG(2, ("smb_pam_auth: PAM: Authentication Error for user %s\n", user));
d++;
domain = d;
} else {
- domain = lp_workgroup();
+ domain = lp_workgroup(global_loadparm);
}
*user_info_mapped = talloc(mem_ctx, struct auth_usersupplied_info);
}
chall_blob = data_blob_talloc(mem_ctx, challenge, 8);
- if (lp_client_ntlmv2_auth()) {
- DATA_BLOB names_blob = NTLMv2_generate_names_blob(mem_ctx, lp_netbios_name(), lp_workgroup());
+ if (lp_client_ntlmv2_auth(global_loadparm)) {
+ DATA_BLOB names_blob = NTLMv2_generate_names_blob(mem_ctx, lp_netbios_name(global_loadparm), lp_workgroup(global_loadparm));
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, challenge, blob.data);
user_info_temp->password.response.nt = blob;
- if (lp_client_lanman_auth() && user_info_in->password.hash.lanman) {
+ if (lp_client_lanman_auth(global_loadparm) && 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, challenge, blob.data);
user_info_temp->password.response.lanman = lm_blob;
server_info->home_drive = talloc_strdup(server_info, "");
NT_STATUS_HAVE_NO_MEMORY(server_info->home_drive);
- server_info->logon_server = talloc_strdup(server_info, lp_netbios_name());
+ server_info->logon_server = talloc_strdup(server_info, lp_netbios_name(global_loadparm));
NT_STATUS_HAVE_NO_MEMORY(server_info->logon_server);
server_info->last_logon = 0;
server_info->home_drive = talloc_strdup(server_info, "");
NT_STATUS_HAVE_NO_MEMORY(server_info->home_drive);
- server_info->logon_server = talloc_strdup(server_info, lp_netbios_name());
+ server_info->logon_server = talloc_strdup(server_info, lp_netbios_name(global_loadparm));
NT_STATUS_HAVE_NO_MEMORY(server_info->logon_server);
server_info->last_logon = 0;
return NT_STATUS_NO_MEMORY;
}
- cli_credentials_set_conf(session_info->credentials);
+ cli_credentials_set_conf(session_info->credentials, global_loadparm);
cli_credentials_set_anonymous(session_info->credentials);
*_session_info = session_info;
return NT_STATUS_NO_MEMORY;
}
- cli_credentials_set_conf(session_info->credentials);
+ cli_credentials_set_conf(session_info->credentials, global_loadparm);
if (anonymous_credentials) {
cli_credentials_set_anonymous(session_info->credentials);
struct cli_credentials *anon_credentials;
anon_credentials = cli_credentials_init(mem_ctx);
- cli_credentials_set_conf(anon_credentials);
+ cli_credentials_set_conf(anon_credentials, global_loadparm);
cli_credentials_set_anonymous(anon_credentials);
return anon_credentials;
*
* @param cred Credentials structure to fill in
*/
-void cli_credentials_set_conf(struct cli_credentials *cred)
+void cli_credentials_set_conf(struct cli_credentials *cred,
+ struct loadparm_context *lp_ctx)
{
cli_credentials_set_username(cred, "", CRED_UNINITIALISED);
- cli_credentials_set_domain(cred, lp_workgroup(), CRED_UNINITIALISED);
- cli_credentials_set_workstation(cred, lp_netbios_name(), CRED_UNINITIALISED);
- cli_credentials_set_realm(cred, lp_realm(), 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);
}
/**
{
char *p;
- cli_credentials_set_conf(cred);
+ cli_credentials_set_conf(cred, global_loadparm);
if (getenv("LOGNAME")) {
cli_credentials_set_username(cred, getenv("LOGNAME"), CRED_GUESS_ENV);
}
if (getenv("PASSWD_FD")) {
- cli_credentials_parse_password_fd(cred, atoi(getenv("PASSWD_FD")), CRED_GUESS_FILE);
+ cli_credentials_parse_password_fd(cred, atoi(getenv("PASSWD_FD")),
+ CRED_GUESS_FILE);
}
p = getenv("PASSWD_FILE");
};
struct ldb_context;
+struct loadparm_context;
#include "auth/credentials/credentials_proto.h"
#endif /* __CREDENTIALS_H__ */
talloc_free(gensec_gssapi_state);
return NT_STATUS_INTERNAL_ERROR;
}
- if (lp_realm() && *lp_realm()) {
- char *upper_realm = strupper_talloc(gensec_gssapi_state, lp_realm());
+ if (lp_realm(global_loadparm) && *lp_realm(global_loadparm)) {
+ char *upper_realm = strupper_talloc(gensec_gssapi_state, lp_realm(global_loadparm));
if (!upper_realm) {
- DEBUG(1,("gensec_krb5_start: could not uppercase realm: %s\n", lp_realm()));
+ DEBUG(1,("gensec_krb5_start: could not uppercase realm: %s\n", lp_realm(global_loadparm)));
talloc_free(gensec_gssapi_state);
return NT_STATUS_NO_MEMORY;
}
gensec_gssapi_state->gss_oid = gss_mech_krb5;
principal = gensec_get_target_principal(gensec_security);
- if (principal && lp_client_use_spnego_principal()) {
+ if (principal && lp_client_use_spnego_principal(global_loadparm)) {
name_type = GSS_C_NULL_OID;
} else {
principal = talloc_asprintf(gensec_gssapi_state, "%s@%s",
}
cli_credentials_set_event_context(session_info->credentials, gensec_security->event_ctx);
- cli_credentials_set_conf(session_info->credentials);
+ cli_credentials_set_conf(session_info->credentials, global_loadparm);
/* Just so we don't segfault trying to get at a username */
cli_credentials_set_anonymous(session_info->credentials);
}
in_data.length = 0;
- if (principal && lp_client_use_spnego_principal()) {
+ if (principal && lp_client_use_spnego_principal(global_loadparm)) {
krb5_principal target_principal;
ret = krb5_parse_name(gensec_krb5_state->smb_krb5_context->krb5_context, principal,
&target_principal);
return ret;
}
- if (lp_realm() && *lp_realm()) {
- char *upper_realm = strupper_talloc(tmp_ctx, lp_realm());
+ if (lp_realm(global_loadparm) && *lp_realm(global_loadparm)) {
+ char *upper_realm = strupper_talloc(tmp_ctx, lp_realm(global_loadparm));
if (!upper_realm) {
- DEBUG(1,("gensec_krb5_start: could not uppercase realm: %s\n", lp_realm()));
+ DEBUG(1,("gensec_krb5_start: could not uppercase realm: %s\n", lp_realm(global_loadparm)));
talloc_free(tmp_ctx);
return ENOMEM;
}
}
} else if (client_lanman && stored_lanman) {
- if (!lp_lanman_auth()) {
+ if (!lp_lanman_auth(global_loadparm)) {
DEBUG(3,("ntlm_password_check: Interactive logon: only LANMAN password supplied for user %s, and LM passwords are disabled!\n",
username));
return NT_STATUS_WRONG_PASSWORD;
DEBUG(3,("ntlm_password_check: NTLMv2 password check failed\n"));
}
} else if (nt_response->length == 24 && stored_nt) {
- if (lp_ntlm_auth()) {
+ if (lp_ntlm_auth(global_loadparm)) {
/* We have the NT MD4 hash challenge available - see if we can
use it (ie. does it exist in the smbpasswd file).
*/
/* The LM session key for this response is not very secure,
so use it only if we otherwise allow LM authentication */
- if (lp_lanman_auth() && stored_lanman) {
+ if (lp_lanman_auth(global_loadparm) && stored_lanman) {
*lm_sess_key = data_blob_talloc(mem_ctx, stored_lanman->hash, 8);
}
return NT_STATUS_OK;
return NT_STATUS_WRONG_PASSWORD;
}
- if (!lp_lanman_auth()) {
+ if (!lp_lanman_auth(global_loadparm)) {
DEBUG(3,("ntlm_password_check: Lanman passwords NOT PERMITTED for user %s\n",
username));
} else if (!stored_lanman) {
It not very secure, so use it only if we otherwise
allow LM authentication */
- if (lp_lanman_auth() && stored_lanman) {
+ if (lp_lanman_auth(global_loadparm) && stored_lanman) {
uint8_t first_8_lm_hash[16];
memcpy(first_8_lm_hash, stored_lanman->hash, 8);
memset(first_8_lm_hash + 8, '\0', 8);
- I think this is related to Win9X pass-though authentication
*/
DEBUG(4,("ntlm_password_check: Checking NT MD4 password in LM field\n"));
- if (lp_ntlm_auth()) {
+ if (lp_ntlm_auth(global_loadparm)) {
if (smb_pwd_check_ntlmv1(mem_ctx,
lm_response,
stored_nt->hash, challenge,
It not very secure, so use it only if we otherwise
allow LM authentication */
- if (lp_lanman_auth() && stored_lanman) {
+ if (lp_lanman_auth(global_loadparm) && stored_lanman) {
uint8_t first_8_lm_hash[16];
memcpy(first_8_lm_hash, stored_lanman->hash, 8);
memset(first_8_lm_hash + 8, '\0', 8);
style 'challenge caching' */
char *user;
- char *domain;
+ const char *domain;
const char *workstation;
char *server_domain;
DATA_BLOB *nt_session_key, DATA_BLOB *lm_session_key);
const char *server_name;
- const char *(*get_domain)(void);
bool doing_ntlm2;
"NTLMSSP",
NTLMSSP_NEGOTIATE,
gensec_ntlmssp_state->neg_flags,
- gensec_ntlmssp_state->get_domain(),
+ gensec_ntlmssp_state->domain,
cli_credentials_get_workstation(gensec_security->credentials));
gensec_ntlmssp_state->expected_state = NTLMSSP_CHALLENGE;
if (gensec_ntlmssp_state->use_nt_response) {
flags |= CLI_CRED_NTLM_AUTH;
}
- if (lp_client_lanman_auth()) {
+ if (lp_client_lanman_auth(global_loadparm)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
}
if ((gensec_ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_LM_KEY)
- && lp_client_lanman_auth() && lm_session_key.length == 16) {
+ && lp_client_lanman_auth(global_loadparm) && 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,
gensec_ntlmssp_state->role = NTLMSSP_CLIENT;
- gensec_ntlmssp_state->get_domain = lp_workgroup;
+ gensec_ntlmssp_state->domain = lp_workgroup(global_loadparm);
gensec_ntlmssp_state->unicode = lp_parm_bool(NULL, "ntlmssp_client", "unicode", true);
gensec_ntlmssp_state->use_nt_response = lp_parm_bool(NULL, "ntlmssp_client", "send_nt_reponse", true);
- gensec_ntlmssp_state->allow_lm_key = (lp_client_lanman_auth()
+ gensec_ntlmssp_state->allow_lm_key = (lp_client_lanman_auth(global_loadparm)
&& (lp_parm_bool(NULL, "ntlmssp_client", "allow_lm_key", false)
|| lp_parm_bool(NULL, "ntlmssp_client", "lm_key", false)));
- gensec_ntlmssp_state->use_ntlmv2 = lp_client_ntlmv2_auth();
+ gensec_ntlmssp_state->use_ntlmv2 = lp_client_ntlmv2_auth(global_loadparm);
gensec_ntlmssp_state->expected_state = NTLMSSP_INITIAL;
return gensec_ntlmssp_state->server_name;
} else {
*chal_flags |= NTLMSSP_TARGET_TYPE_DOMAIN;
- return gensec_ntlmssp_state->get_domain();
+ return gensec_ntlmssp_state->domain;
};
} else {
return "";
gensec_ntlmssp_state->role = NTLMSSP_SERVER;
gensec_ntlmssp_state->workstation = NULL;
- gensec_ntlmssp_state->server_name = lp_netbios_name();
+ gensec_ntlmssp_state->server_name = lp_netbios_name(global_loadparm);
- gensec_ntlmssp_state->get_domain = lp_workgroup;
+ gensec_ntlmssp_state->domain = lp_workgroup(global_loadparm);
gensec_ntlmssp_state->expected_state = NTLMSSP_NEGOTIATE;
- gensec_ntlmssp_state->allow_lm_key = (lp_lanman_auth()
+ gensec_ntlmssp_state->allow_lm_key = (lp_lanman_auth(global_loadparm)
&& lp_parm_bool(NULL, "ntlmssp_server", "allow_lm_key", false));
gensec_ntlmssp_state->server_multiple_authentications = False;
gensec_ntlmssp_state->may_set_challenge = auth_ntlmssp_may_set_challenge;
gensec_ntlmssp_state->set_challenge = auth_ntlmssp_set_challenge;
gensec_ntlmssp_state->check_password = auth_ntlmssp_check_password;
- gensec_ntlmssp_state->server_role = lp_server_role();
+ gensec_ntlmssp_state->server_role = lp_server_role(global_loadparm);
return NT_STATUS_OK;
}
server_info->home_drive = talloc_strdup(server_info, str);
NT_STATUS_HAVE_NO_MEMORY(server_info->home_drive);
- server_info->logon_server = talloc_strdup(server_info, lp_netbios_name());
+ server_info->logon_server = talloc_strdup(server_info, lp_netbios_name(global_loadparm));
NT_STATUS_HAVE_NO_MEMORY(server_info->logon_server);
server_info->last_logon = samdb_result_nttime(msg, "lastLogon", 0);
NT_STATUS_HAVE_NO_MEMORY(cldapsock);
socket_address = socket_address_from_strings(cldapsock, cldapsock->sock->backend_name,
- address, lp_cldap_port());
+ address, lp_cldap_port(global_loadparm));
if (!socket_address) {
talloc_free(cldapsock);
return NT_STATUS_NO_MEMORY;
status = socket_listen(cldapsock->sock, socket_address, 0, 0);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to bind to %s:%d - %s\n",
- address, lp_cldap_port(), nt_errstr(status)));
+ address, lp_cldap_port(global_loadparm), nt_errstr(status)));
talloc_free(cldapsock);
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()) {
+ if (!lp_bind_interfaces_only(global_loadparm)) {
status = cldapd_add_socket(cldapd, "0.0.0.0");
NT_STATUS_NOT_OK_RETURN(status);
} else {
const char *dom_attrs[] = {"objectGUID", NULL};
struct ldb_message **ref_res, **dom_res;
int ret, count = 0;
- const char **services = lp_server_services();
+ const char **services = lp_server_services(global_loadparm);
uint32_t server_type;
const char *pdc_name;
struct GUID domain_uuid;
server_type |= NBT_SERVER_KDC;
}
- pdc_name = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
+ pdc_name = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name(global_loadparm));
domain_uuid = samdb_result_guid(dom_res[0], "objectGUID");
- realm = samdb_result_string(ref_res[0], "dnsRoot", lp_realm());
- dns_domain = samdb_result_string(ref_res[0], "dnsRoot", lp_realm());
+ realm = samdb_result_string(ref_res[0], "dnsRoot", lp_realm(global_loadparm));
+ dns_domain = samdb_result_string(ref_res[0], "dnsRoot", lp_realm(global_loadparm));
pdc_dns_name = talloc_asprintf(mem_ctx, "%s.%s",
- strlower_talloc(mem_ctx, lp_netbios_name()),
+ strlower_talloc(mem_ctx,
+ lp_netbios_name(global_loadparm)),
dns_domain);
- flatname = samdb_result_string(ref_res[0], "nETBIOSName", lp_workgroup());
+ flatname = samdb_result_string(ref_res[0], "nETBIOSName",
+ lp_workgroup(global_loadparm));
server_site = "Default-First-Site-Name";
client_site = "Default-First-Site-Name";
pdc_ip = iface_best_ip(src_address);
netlogon->logon5.dns_domain = dns_domain;
netlogon->logon5.pdc_dns_name = pdc_dns_name;
netlogon->logon5.domain = flatname;
- netlogon->logon5.pdc_name = lp_netbios_name();
+ netlogon->logon5.pdc_name = lp_netbios_name(global_loadparm);
netlogon->logon5.user_name = user;
netlogon->logon5.server_site = server_site;
netlogon->logon5.client_site = client_site;
netlogon->logon13.dns_domain = dns_domain;
netlogon->logon13.pdc_dns_name = pdc_dns_name;
netlogon->logon13.domain = flatname;
- netlogon->logon13.pdc_name = lp_netbios_name();
+ netlogon->logon13.pdc_name = lp_netbios_name(global_loadparm);
netlogon->logon13.user_name = user;
netlogon->logon13.server_site = server_site;
netlogon->logon13.client_site = client_site;
}
if (domain_guid == NULL && domain == NULL) {
- domain = lp_realm();
+ domain = lp_realm(global_loadparm);
}
if (version == -1) {
set_max_xmit(MAX(ibs, obs));
DEBUG(4, ("IO buffer size is %llu, max xmit is %d\n",
- (unsigned long long)iomax, lp_max_xmit()));
+ (unsigned long long)iomax, lp_max_xmit(global_loadparm)));
if (!(ifile = open_file("if"))) {
return(FILESYS_EXIT_CODE);
ifile->io_seek(ifile, check_arg_numeric("skip") * ibs);
ofile->io_seek(ofile, check_arg_numeric("seek") * obs);
- DEBUG(4, ("max xmit was negotiated to be %d\n", lp_max_xmit()));
+ DEBUG(4, ("max xmit was negotiated to be %d\n", lp_max_xmit(global_loadparm)));
for (data_size = 0;;) {
const char *server_name;
struct smbcli_state *cli;
- make_nbt_name_client(&calling, lp_netbios_name());
+ make_nbt_name_client(&calling, lp_netbios_name(global_loadparm));
nbt_choose_called_name(NULL, &called, desthost, name_type);
}
if (query_host) {
- return do_host_query(query_host, lp_workgroup());
+ return do_host_query(query_host, lp_workgroup(global_loadparm));
}
if (message) {
pstrcpy(username,getenv("LOGNAME"));
}
- if (!lp_load()) {
+ if (!lp_load(dyn_CONFIGFILE)) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n",
lp_config_file());
}
setup_logging(argv[0], DEBUG_STDOUT);
- if (!lp_load()) {
+ if (!lp_load(dyn_CONFIGFILE)) {
fprintf(stderr, "ERROR: Can't load %s - run testparm to debug it\n", lp_config_file());
return (1);
}
struct dreplsrv_service *service;
uint32_t periodic_startup_interval;
- switch (lp_server_role()) {
+ switch (lp_server_role(global_loadparm)) {
case ROLE_STANDALONE:
task_server_terminate(task, "dreplsrv: no DSDB replication required in standalone configuration");
return;
#include "auth/credentials/credentials.h"
#include "auth/credentials/credentials_krb5.h"
#include "system/kerberos.h"
+#include "param/param.h"
struct dn_list {
struct cli_credentials *creds;
return LDB_ERR_OPERATIONS_ERROR;
}
- cli_credentials_set_conf(item->creds);
+ cli_credentials_set_conf(item->creds, global_loadparm);
status = cli_credentials_set_secrets(item->creds, module->ldb, NULL, filter);
talloc_free(filter);
if (NT_STATUS_IS_OK(status)) {
struct auth_session_info *session_info)
{
struct ldb_context *ldb;
- ldb = ldb_wrap_connect(mem_ctx, lp_sam_url(), session_info,
+ ldb = ldb_wrap_connect(mem_ctx, lp_sam_url(global_loadparm), session_info,
NULL, 0, NULL);
if (!ldb) {
return NULL;
for (i=0; i<num_interfaces; i++) {
const char *address = talloc_strdup(tmp_ctx, iface_n_ip(i));
- status = kdc_add_socket(kdc, address, lp_krb5_port(),
- lp_kpasswd_port());
+ status = kdc_add_socket(kdc, address, lp_krb5_port(global_loadparm),
+ lp_kpasswd_port(global_loadparm));
NT_STATUS_NOT_OK_RETURN(status);
}
NTSTATUS status;
krb5_error_code ret;
- switch (lp_server_role()) {
+ switch (lp_server_role(global_loadparm)) {
case ROLE_STANDALONE:
task_server_terminate(task, "kdc: no KDC required in standalone configuration");
return;
#include "rpc_server/dcerpc_server.h"
#include "rpc_server/samr/proto.h"
#include "libcli/security/security.h"
+#include "param/param.h"
/* hold information about one kdc socket */
struct kpasswd_socket {
/* We want the credentials subsystem to use the krb5 context
* we already have, rather than a new context */
cli_credentials_set_krb5_context(server_credentials, kdc->smb_krb5_context);
- cli_credentials_set_conf(server_credentials);
+ cli_credentials_set_conf(server_credentials, global_loadparm);
nt_status = cli_credentials_set_stored_principal(server_credentials, "kadmin/changepw");
if (!NT_STATUS_IS_OK(nt_status)) {
ret = kpasswdd_make_unauth_error_reply(kdc, mem_ctx,
*/
NTSTATUS ldapsrv_backend_Init(struct ldapsrv_connection *conn)
{
- conn->ldb = ldb_wrap_connect(conn, lp_sam_url(), conn->session_info,
+ conn->ldb = ldb_wrap_connect(conn, lp_sam_url(global_loadparm), conn->session_info,
NULL, conn->global_catalog ? LDB_FLG_RDONLY : 0, NULL);
if (conn->ldb == NULL) {
return NT_STATUS_INTERNAL_DB_CORRUPTION;
return;
}
- cli_credentials_set_conf(server_credentials);
+ cli_credentials_set_conf(server_credentials, global_loadparm);
status = cli_credentials_set_machine_account(server_credentials);
if (!NT_STATUS_IS_OK(status)) {
stream_terminate_connection(c, talloc_asprintf(conn, "Failed to obtain server credentials, perhaps a standalone server?: %s\n", nt_errstr(status)));
NTSTATUS status;
const struct model_ops *model_ops;
- switch (lp_server_role()) {
+ switch (lp_server_role(global_loadparm)) {
case ROLE_STANDALONE:
task_server_terminate(task, "ldap_server: no LDAP server required in standalone configuration");
return;
ldap_service->tls_params = tls_initialise(ldap_service);
if (ldap_service->tls_params == NULL) goto failed;
- if (lp_interfaces() && lp_bind_interfaces_only()) {
+ if (lp_interfaces(global_loadparm) && lp_bind_interfaces_only(global_loadparm)) {
int num_interfaces = iface_count();
int i;
}
} else {
status = add_socket(task->event_ctx, model_ops,
- lp_socket_address(), ldap_service);
+ lp_socket_address(global_loadparm), ldap_service);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
#include "version.h"
#include "lib/cmdline/popt_common.h"
#include "param/param.h"
+#include "dynconfig.h"
/* Handle command line options:
* -d,--debuglevel
struct cli_credentials *cmdline_credentials = NULL;
-static bool PrintSambaVersionString;
-
static void popt_common_callback(poptContext con,
enum poptCallbackReason reason,
const struct poptOption *opt,
const char *pname;
if (reason == POPT_CALLBACK_REASON_POST) {
- if (PrintSambaVersionString) {
- printf( "Version %s\n", SAMBA_VERSION_STRING );
- exit(0);
+ if (!lp_loaded()) {
+ if (getenv("SMB_CONF_PATH"))
+ lp_load(getenv("SMB_CONF_PATH"));
+ else
+ lp_load(dyn_CONFIGFILE);
}
-
- lp_load();
/* Hook any 'every Samba program must do this, after
* the smb.conf is setup' functions here */
return;
/* and logging */
setup_logging(pname, DEBUG_STDOUT);
- if (getenv("SMB_CONF_PATH")) {
- lp_set_cmdline(global_loadparm, "config file", getenv("SMB_CONF_PATH"));
- }
return;
}
break;
case 'V':
- PrintSambaVersionString = true;
- break;
+ printf("Version %s\n", SAMBA_VERSION_STRING );
+ exit(0);
case 'O':
if (arg) {
case 's':
if (arg) {
- lp_set_cmdline(global_loadparm, "config file", arg);
+ lp_load(arg);
}
break;
}
ldb_set_modules_dir(ldb,
- talloc_asprintf(ldb, "%s/ldb", lp_modulesdir()));
+ talloc_asprintf(ldb, "%s/ldb", lp_modulesdir(global_loadparm)));
/* we want to use the existing event context if possible. This
relies on the fact that in smbd, everything is a child of
return NULL;
}
- if (strcmp(lp_sam_url(), url) == 0) {
+ if (strcmp(lp_sam_url(global_loadparm), url) == 0) {
dsdb_set_global_schema(ldb);
}
struct hive_key *hive;
const char *location;
- location = talloc_asprintf(ctx, "%s/%s.ldb", lp_private_dir(), name);
+ location = talloc_asprintf(ctx, "%s/%s.ldb", lp_private_dir(global_loadparm), name);
error = reg_open_hive(ctx, location, auth_info, creds, &hive);
struct composite_context *creq;
make_nbt_name_client(&name, server_address->addr);
creq = resolve_name_send(&name, result->event_ctx,
- lp_name_resolve_order());
+ lp_name_resolve_order(global_loadparm));
if (composite_nomem(creq, result)) return result;
composite_continue(result, creq, continue_resolve_name, result);
return result;
struct composite_context *creq;
make_nbt_name_client(&name, server_address);
creq = resolve_name_send(&name, result->event_ctx,
- lp_name_resolve_order());
+ lp_name_resolve_order(global_loadparm));
if (composite_nomem(creq, result)) goto failed;
composite_continue(result, creq, continue_resolve_name, result);
return result;
return;
}
- ptr = lp_interfaces();
+ ptr = lp_interfaces(global_loadparm);
loopback_ip = interpret_addr2("127.0.0.1");
/* probe the kernel for interfaces */
struct tls_params *params;
int ret;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
- const char *keyfile = private_path(tmp_ctx, lp_tls_keyfile());
- const char *certfile = private_path(tmp_ctx, lp_tls_certfile());
- const char *cafile = private_path(tmp_ctx, lp_tls_cafile());
- const char *crlfile = private_path(tmp_ctx, lp_tls_crlfile());
- const char *dhpfile = private_path(tmp_ctx, lp_tls_dhpfile());
+ const char *keyfile = private_path(tmp_ctx, lp_tls_keyfile(global_loadparm));
+ const char *certfile = private_path(tmp_ctx, lp_tls_certfile(global_loadparm));
+ const char *cafile = private_path(tmp_ctx, lp_tls_cafile(global_loadparm));
+ const char *crlfile = private_path(tmp_ctx, lp_tls_crlfile(global_loadparm));
+ const char *dhpfile = private_path(tmp_ctx, lp_tls_dhpfile(global_loadparm));
void tls_cert_generate(TALLOC_CTX *, const char *, const char *, const char *);
params = talloc(mem_ctx, struct tls_params);
return NULL;
}
- if (!lp_tls_enabled() || keyfile == NULL || *keyfile == 0) {
+ if (!lp_tls_enabled(global_loadparm) || keyfile == NULL || *keyfile == 0) {
params->tls_enabled = False;
talloc_free(tmp_ctx);
return params;
}
new_sock->private_data = tls;
- cafile = private_path(tls, lp_tls_cafile());
+ cafile = private_path(tls, lp_tls_cafile(global_loadparm));
if (!cafile || !*cafile) {
goto failed;
}
req->dest = socket_address_from_strings(req, cldap->sock->backend_name,
io->in.dest_address,
- lp_cldap_port());
+ lp_cldap_port(global_loadparm));
if (!req->dest) goto failed;
req->message_id = idr_get_new_random(cldap->idr, req, UINT16_MAX);
/* wrapper around smb_raw_negotiate() */
NTSTATUS smbcli_negprot(struct smbcli_state *cli)
{
- return smb_raw_negotiate(cli->transport, lp_cli_maxprotocol());
+ return smb_raw_negotiate(cli->transport, lp_cli_maxprotocol(global_loadparm));
}
/* wrapper around smb_raw_sesssetup() */
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
setup.in.credentials = credentials;
- setup.in.workgroup = lp_workgroup();
+ setup.in.workgroup = lp_workgroup(global_loadparm);
status = smb_composite_sesssetup(cli->session, &setup);
return status;
}
- make_nbt_name_client(&myname, lp_netbios_name());
+ make_nbt_name_client(&myname, lp_netbios_name(global_loadparm));
dest = socket_address_from_strings(tmp_ctx, dgmsock->sock->backend_name,
request->src_addr, request->src_port);
if (_dest->port == 0) {
dest = socket_address_from_strings(tmp_ctx, _dest->family,
- _dest->addr, lp_dgram_port());
+ _dest->addr, lp_dgram_port(global_loadparm));
} else {
dest = _dest;
}
return status;
}
- make_nbt_name_client(&myname, lp_netbios_name());
+ make_nbt_name_client(&myname, lp_netbios_name(global_loadparm));
dest = socket_address_from_strings(tmp_ctx, dgmsock->sock->backend_name,
request->src_addr, request->src_port);
return status;
}
- make_nbt_name_client(&myname, lp_netbios_name());
+ make_nbt_name_client(&myname, lp_netbios_name(global_loadparm));
dest = socket_address_from_strings(tmp_ctx,
dgmsock->sock->backend_name,
state->r.in.domainname = state->domain_name;
state->r.in.ip_address = state->dcs[0].address;
- state->r.in.my_computername = lp_netbios_name();
+ state->r.in.my_computername = lp_netbios_name(global_loadparm);
state->r.in.my_accountname = talloc_asprintf(state, "%s$",
- lp_netbios_name());
+ lp_netbios_name(global_loadparm));
if (composite_nomem(state->r.in.my_accountname, state->ctx)) return;
state->r.in.account_control = ACB_WSTRUST;
state->r.in.domain_sid = state->domain_sid;
packet->questions[0].question_class = NBT_QCLASS_IP;
dest = socket_address_from_strings(packet, nbtsock->sock->backend_name,
- io->in.dest_addr, lp_nbt_port());
+ io->in.dest_addr, lp_nbt_port(global_loadparm));
if (dest == NULL) goto failed;
req = nbt_name_request_send(nbtsock, dest, packet,
io->in.timeout, io->in.retries, False);
packet->questions[0].question_class = NBT_QCLASS_IP;
dest = socket_address_from_strings(packet, nbtsock->sock->backend_name,
- io->in.dest_addr, lp_nbt_port());
+ io->in.dest_addr, lp_nbt_port(global_loadparm));
if (dest == NULL) goto failed;
req = nbt_name_request_send(nbtsock, dest, packet,
io->in.timeout, io->in.retries, False);
dest = socket_address_from_strings(nbtsock,
nbtsock->sock->backend_name,
- io->in.dest_addr, lp_nbt_port());
+ io->in.dest_addr, lp_nbt_port(global_loadparm));
if (dest == NULL) goto failed;
req = nbt_name_request_send(nbtsock, dest, packet,
io->in.timeout, io->in.retries, False);
if (packet->additional[0].rdata.netbios.addresses[0].ipaddr == NULL) goto failed;
dest = socket_address_from_strings(packet, nbtsock->sock->backend_name,
- io->in.dest_addr, lp_nbt_port());
+ io->in.dest_addr, lp_nbt_port(global_loadparm));
if (dest == NULL) goto failed;
req = nbt_name_request_send(nbtsock, dest, packet,
io->in.timeout, io->in.retries, False);
talloc_strdup(packet->additional, io->in.address);
dest = socket_address_from_strings(packet, nbtsock->sock->backend_name,
- io->in.dest_addr, lp_nbt_port());
+ io->in.dest_addr, lp_nbt_port(global_loadparm));
if (dest == NULL) goto failed;
req = nbt_name_request_send(nbtsock, dest, packet,
io->in.timeout, io->in.retries, False);
if (state->host_name == NULL) goto failed;
if (port == 0) {
- const char **ports = lp_smb_ports();
+ const char **ports = lp_smb_ports(global_loadparm);
int i;
for (i=0;ports[i];i++) /* noop */ ;
if (!composite_is_ok(state->ctx)) return;
state->ctx->status =
- socket_set_option(sock, lp_socket_options(), NULL);
+ socket_set_option(sock, lp_socket_options(global_loadparm), NULL);
if (!composite_is_ok(state->ctx)) return;
transport->socket = talloc_reference(transport, sock);
}
transport->negotiate.protocol = PROTOCOL_NT1;
- transport->options.use_spnego = lp_use_spnego() && lp_nt_status_support();
- transport->options.max_xmit = lp_max_xmit();
- transport->options.max_mux = lp_maxmux();
+ transport->options.use_spnego = lp_use_spnego(global_loadparm) &&
+ lp_nt_status_support(global_loadparm);
+ transport->options.max_xmit = lp_max_xmit(global_loadparm);
+ transport->options.max_mux = lp_maxmux(global_loadparm);
transport->options.request_timeout = SMB_REQUEST_TIMEOUT;
transport->negotiate.max_xmit = transport->options.max_xmit;
io.in.service_type = service_type;
io.in.credentials = credentials;
io.in.fallback_to_anonymous = False;
- io.in.workgroup = lp_workgroup();
+ io.in.workgroup = lp_workgroup(global_loadparm);
status = smb_composite_connect(&io, parent_ctx, ev);
if (NT_STATUS_IS_OK(status)) {
}
flags2 |= FLAGS2_32_BIT_ERROR_CODES;
- if (lp_unicode()) {
+ if (lp_unicode(global_loadparm)) {
flags2 |= FLAGS2_UNICODE_STRINGS;
}
flags2 |= FLAGS2_EXTENDED_ATTRIBUTES;
}
/* a way to force ascii SMB */
- if (!lp_unicode()) {
+ if (!lp_unicode(global_loadparm)) {
transport->negotiate.capabilities &= ~CAP_UNICODE;
}
- if (!lp_nt_status_support()) {
+ if (!lp_nt_status_support(global_loadparm)) {
transport->negotiate.capabilities &= ~CAP_STATUS32;
}
return False;
}
- switch (lp_client_signing()) {
+ switch (lp_client_signing(global_loadparm)) {
case SMB_SIGNING_OFF:
transport->negotiate.sign_info.allow_smb_signing = False;
break;
struct event_context *ev)
{
struct composite_context *c = resolve_name_send(name, ev,
- lp_name_resolve_order());
+ lp_name_resolve_order(global_loadparm));
return resolve_name_recv(c, mem_ctx, reply_addr);
}
struct event_context *event_ctx,
struct nbt_name *name)
{
- const char **address_list = lp_wins_server_list();
+ const char **address_list = lp_wins_server_list(global_loadparm);
if (address_list == NULL) return NULL;
return resolve_name_nbtlist_send(mem_ctx, event_ctx, name, address_list, False, True);
}
ZERO_STRUCT(name);
name.name = host;
- creq = resolve_name_send(&name, c->event_ctx, lp_name_resolve_order());
+ creq = resolve_name_send(&name, c->event_ctx, lp_name_resolve_order(global_loadparm));
composite_continue(c, creq, continue_resolve, c);
return c;
}
{
struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
- state->req = smb_raw_negotiate_send(state->transport, lp_cli_maxprotocol());
+ state->req = smb_raw_negotiate_send(state->transport, lp_cli_maxprotocol(global_loadparm));
NT_STATUS_HAVE_NO_MEMORY(state->req);
state->req->async.fn = request_handler;
state->io_setup->in.credentials = cli_credentials_init(state);
NT_STATUS_HAVE_NO_MEMORY(state->io_setup->in.credentials);
- cli_credentials_set_conf(state->io_setup->in.credentials);
+ cli_credentials_set_conf(state->io_setup->in.credentials, global_loadparm);
cli_credentials_set_anonymous(state->io_setup->in.credentials);
/* If the preceding attempt was with extended security, we
state->stage = CONNECT_RESOLVE;
make_nbt_name_server(&name, io->in.dest_host);
- state->creq = resolve_name_send(&name, c->event_ctx, lp_name_resolve_order());
+ state->creq = resolve_name_send(&name, c->event_ctx, lp_name_resolve_order(global_loadparm));
if (state->creq == NULL) goto failed;
state->creq->async.private_data = c;
NTSTATUS nt_status;
struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
const char *password = cli_credentials_get_password(io->in.credentials);
- DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, session->transport->socket->hostname, lp_workgroup());
+ DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, session->transport->socket->hostname, lp_workgroup(global_loadparm));
DATA_BLOB session_key;
int flags = CLI_CRED_NTLM_AUTH;
- if (lp_client_lanman_auth()) {
+ if (lp_client_lanman_auth(global_loadparm)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth()) {
+ if (lp_client_ntlmv2_auth(global_loadparm)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
set_user_session_key(session, &session_key);
data_blob_free(&session_key);
- } else if (lp_client_plaintext_auth()) {
+ } else if (lp_client_plaintext_auth(global_loadparm)) {
state->setup.nt1.in.password1 = data_blob_talloc(state, password, strlen(password));
state->setup.nt1.in.password2 = data_blob(NULL, 0);
} else {
NTSTATUS nt_status;
struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
const char *password = cli_credentials_get_password(io->in.credentials);
- DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, session->transport->socket->hostname, lp_workgroup());
+ DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, session->transport->socket->hostname, lp_workgroup(global_loadparm));
DATA_BLOB session_key;
int flags = 0;
- if (lp_client_lanman_auth()) {
+ if (lp_client_lanman_auth(global_loadparm)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth()) {
+ if (lp_client_ntlmv2_auth(global_loadparm)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
set_user_session_key(session, &session_key);
data_blob_free(&session_key);
- } else if (lp_client_plaintext_auth()) {
+ } else if (lp_client_plaintext_auth(global_loadparm)) {
state->setup.old.in.password = data_blob_talloc(state, password, strlen(password));
} else {
/* could match windows client and return 'cannot logon from this workstation', but it just confuses everybody */
the mapping of dos codes, as we want to catch the cases where
a forced dos code is needed
*/
- if (lp_nt_status_support()) {
+ if (lp_nt_status_support(global_loadparm)) {
return NT_STATUS_V(status1) == NT_STATUS_V(status2);
}
ctx->event_ctx = ev;
/* name resolution methods */
- ctx->name_res_methods = str_list_copy(ctx, lp_name_resolve_order());
+ ctx->name_res_methods = str_list_copy(ctx, lp_name_resolve_order(global_loadparm));
/* connected services' params */
ZERO_STRUCT(ctx->samr);
connect_with_info->out.domain_name = talloc_strdup(tmp_ctx, r->in.domain_name);
} else {
/* Bugger, we just lost our way to automaticly find the domain name */
- connect_with_info->out.domain_name = talloc_strdup(tmp_ctx, lp_workgroup());
- connect_with_info->out.realm = talloc_strdup(tmp_ctx, lp_realm());
+ connect_with_info->out.domain_name = talloc_strdup(tmp_ctx, lp_workgroup(global_loadparm));
+ connect_with_info->out.realm = talloc_strdup(tmp_ctx, lp_realm(global_loadparm));
}
}
if (r->in.netbios_name != NULL) {
netbios_name = r->in.netbios_name;
} else {
- netbios_name = talloc_reference(tmp_mem, lp_netbios_name());
+ netbios_name = talloc_reference(tmp_mem, lp_netbios_name(global_loadparm));
if (!netbios_name) {
r->out.error_string = NULL;
talloc_free(tmp_mem);
#include "system/kerberos.h"
#include "auth/credentials/credentials.h"
#include "auth/credentials/credentials_krb5.h"
+#include "param/param.h"
static NTSTATUS samdump_keytab_handle_user(TALLOC_CTX *mem_ctx,
const char *keytab_name,
if (!credentials) {
return NT_STATUS_NO_MEMORY;
}
- cli_credentials_set_conf(credentials);
+ cli_credentials_set_conf(credentials, global_loadparm);
cli_credentials_set_username(credentials, username, CRED_SPECIFIED);
/* We really should consult ldap in the main SamSync code, and
state->secrets = NULL;
state->trusted_domains = NULL;
- state->sam_ldb = ldb_wrap_connect(mem_ctx, lp_sam_url(),
+ state->sam_ldb = ldb_wrap_connect(mem_ctx, lp_sam_url(global_loadparm),
r->in.session_info,
ctx->cred, 0, NULL);
#include "auth/gensec/schannel_proto.h"
#include "librpc/gen_ndr/ndr_netlogon.h"
#include "librpc/gen_ndr/ndr_netlogon_c.h"
+#include "param/param.h"
/**
talloc_free(samsync_ctx);
return NT_STATUS_NO_MEMORY;
}
- cli_credentials_set_conf(machine_account);
+ cli_credentials_set_conf(machine_account, global_loadparm);
nt_status = cli_credentials_set_machine_account(machine_account);
if (!NT_STATUS_IS_OK(nt_status)) {
r->out.error_string = talloc_strdup(mem_ctx, "Could not obtain machine account password - are we joined to the domain?");
conn->in.called_name = s->io.binding->target_hostname;
conn->in.service = "IPC$";
conn->in.service_type = NULL;
- conn->in.workgroup = lp_workgroup();
+ conn->in.workgroup = lp_workgroup(global_loadparm);
/*
* provide proper credentials - user supplied, but allow a
make_nbt_name_server(&name, server);
resolve_req = resolve_name_send(&name, c->event_ctx,
- lp_name_resolve_order());
+ lp_name_resolve_order(global_loadparm));
composite_continue(c, resolve_req, continue_ip_resolve_name, c);
return c;
}
s->conn = conn;
string_replace(canon, '/', '\\');
- s->full_path = talloc_asprintf(canon, "%s/%s", lp_ncalrpc_dir(), canon);
+ s->full_path = talloc_asprintf(canon, "%s/%s", lp_ncalrpc_dir(global_loadparm), canon);
if (composite_nomem(s->full_path, c)) return c;
/* prepare server address using path and transport name */
/* anonymous credentials for rpc connection used to get endpoint mapping */
anon_creds = cli_credentials_init(mem_ctx);
cli_credentials_set_event_context(anon_creds, ev);
- cli_credentials_set_conf(anon_creds);
+ cli_credentials_set_conf(anon_creds, global_loadparm);
cli_credentials_set_anonymous(anon_creds);
/*
for (i=0;i<num_examples;i++) {
char *name=NULL;
asprintf(&name, "%s/rpclog/%s-%u.%d.%s",
- lp_lockdir(), ndr->name, opnum, i,
+ lp_lockdir(global_loadparm), ndr->name, opnum, i,
(flags&NDR_IN)?"in":"out");
if (name == NULL) {
return;
reply.command = NETLOGON_RESPONSE_FROM_PDC;
pdc = &reply.req.response;
- pdc->pdc_name = lp_netbios_name();
+ pdc->pdc_name = lp_netbios_name(global_loadparm);
pdc->unicode_pdc_name = pdc->pdc_name;
pdc->domain_name = samdb_result_string(ref_res[0], "nETBIOSName", name->name);;
pdc->nt_version = 1;
const char *dom_attrs[] = {"objectGUID", NULL};
struct ldb_message **ref_res, **dom_res;
int ret;
- const char **services = lp_server_services();
+ const char **services = lp_server_services(global_loadparm);
const char *my_ip = reply_iface->ip_address;
struct ldb_dn *partitions_basedn;
if (!my_ip) {
}
pdc->domain_uuid = samdb_result_guid(dom_res[0], "objectGUID");
- pdc->forest = samdb_result_string(ref_res[0], "dnsRoot", lp_realm());
- pdc->dns_domain = samdb_result_string(ref_res[0], "dnsRoot", lp_realm());
+ pdc->forest = samdb_result_string(ref_res[0], "dnsRoot",
+ lp_realm(global_loadparm));
+ pdc->dns_domain = samdb_result_string(ref_res[0], "dnsRoot",
+ lp_realm(global_loadparm));
/* TODO: get our full DNS name from somewhere else */
pdc->pdc_dns_name = talloc_asprintf(packet, "%s.%s",
- strlower_talloc(packet, lp_netbios_name()),
+ strlower_talloc(packet,
+ lp_netbios_name(global_loadparm)),
pdc->dns_domain);
pdc->domain = samdb_result_string(ref_res[0], "nETBIOSName", name->name);;
- pdc->pdc_name = lp_netbios_name();
+ pdc->pdc_name = lp_netbios_name(global_loadparm);
pdc->user_name = netlogon->req.pdc2.user_name;
/* TODO: we need to make sure these are in our DNS zone */
pdc->server_site = "Default-First-Site-Name";
reply.command = NTLOGON_SAM_LOGON_REPLY;
logon = &reply.req.reply;
- logon->server = talloc_asprintf(packet, "\\\\%s", lp_netbios_name());
+ logon->server = talloc_asprintf(packet, "\\\\%s",
+ lp_netbios_name(global_loadparm));
logon->user_name = ntlogon->req.logon.user_name;
- logon->domain = lp_workgroup();
+ logon->domain = lp_workgroup(global_loadparm);
logon->nt_version = 1;
logon->lmnt_token = 0xFFFF;
logon->lm20_token = 0xFFFF;
}
bcast_addr = socket_address_from_strings(tmp_ctx, bcast_dgmsock->sock->backend_name,
- iface->bcast_address, lp_dgram_port());
+ iface->bcast_address,
+ lp_dgram_port(global_loadparm));
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(), nt_errstr(status)));
+ iface->bcast_address, lp_dgram_port(global_loadparm),
+ nt_errstr(status)));
return status;
}
}
bind_addr = socket_address_from_strings(tmp_ctx, iface->dgmsock->sock->backend_name,
- bind_address, lp_dgram_port());
+ bind_address, lp_dgram_port(global_loadparm));
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(), nt_errstr(status)));
+ bind_address, lp_dgram_port(global_loadparm), nt_errstr(status)));
return status;
}
}
bcast_address = socket_address_from_strings(bcast_nbtsock, bcast_nbtsock->sock->backend_name,
- bcast, lp_nbt_port());
+ bcast, lp_nbt_port(global_loadparm));
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(), nt_errstr(status)));
+ bcast, lp_nbt_port(global_loadparm), nt_errstr(status)));
talloc_free(iface);
return status;
}
return NT_STATUS_NO_MEMORY;
}
- unicast_address = socket_address_from_strings(iface->nbtsock, iface->nbtsock->sock->backend_name,
- bind_address, lp_nbt_port());
+ unicast_address = socket_address_from_strings(iface->nbtsock,
+ iface->nbtsock->sock->backend_name,
+ bind_address, lp_nbt_port(global_loadparm));
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(), nt_errstr(status)));
+ bind_address, lp_nbt_port(global_loadparm), 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()) {
+ if (!lp_bind_interfaces_only(global_loadparm)) {
const char *primary_address;
/* the primary address is the address we will return
primary_address = iface_n_ip(0);
} else {
primary_address = sys_inet_ntoa(interpret_addr2(
- lp_netbios_name()));
+ lp_netbios_name(global_loadparm)));
}
primary_address = talloc_strdup(tmp_ctx, primary_address);
NT_STATUS_HAVE_NO_MEMORY(primary_address);
NT_STATUS_NOT_OK_RETURN(status);
}
- if (lp_wins_server_list()) {
+ if (lp_wins_server_list(global_loadparm)) {
status = nbtd_add_wins_socket(nbtsrv);
NT_STATUS_NOT_OK_RETURN(status);
}
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()) {
+ if (src->port != lp_nbt_port(global_loadparm)) {
return False;
}
if (!(packet->operation & NBT_FLAG_BROADCAST) &&
(packet->operation & NBT_FLAG_RECURSION_DESIRED) &&
(iname->nb_flags & NBT_NM_GROUP) &&
- lp_wins_support()) {
+ lp_wins_support(global_loadparm)) {
nbtd_winsserver_request(nbtsock, packet, src);
return;
}
uint16_t nb_flags)
{
struct nbtd_iface_name *iname;
- const char *scope = lp_netbios_scope();
+ const char *scope = lp_netbios_scope(global_loadparm);
struct nbt_name_register_bcast io;
struct composite_context *creq;
struct nbtd_server *nbtsrv = iface->nbtsrv;
/* 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(), NBT_NAME_CLIENT, nb_flags);
- nbtd_register_name(nbtsrv, lp_netbios_name(), NBT_NAME_USER, nb_flags);
- nbtd_register_name(nbtsrv, lp_netbios_name(), NBT_NAME_SERVER, nb_flags);
+ nbtd_register_name(nbtsrv, lp_netbios_name(global_loadparm), NBT_NAME_CLIENT, nb_flags);
+ nbtd_register_name(nbtsrv, lp_netbios_name(global_loadparm), NBT_NAME_USER, nb_flags);
+ nbtd_register_name(nbtsrv, lp_netbios_name(global_loadparm), NBT_NAME_SERVER, nb_flags);
- aliases = lp_netbios_aliases();
+ aliases = lp_netbios_aliases(global_loadparm);
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() == ROLE_DOMAIN_CONTROLLER) {
- BOOL is_pdc = samdb_is_pdc(nbtsrv->sam_ctx);
+ if (lp_server_role(global_loadparm) == ROLE_DOMAIN_CONTROLLER) {
+ bool is_pdc = samdb_is_pdc(nbtsrv->sam_ctx);
if (is_pdc) {
- nbtd_register_name(nbtsrv, lp_workgroup(),
+ nbtd_register_name(nbtsrv, lp_workgroup(global_loadparm),
NBT_NAME_PDC, nb_flags);
}
- nbtd_register_name(nbtsrv, lp_workgroup(),
+ nbtd_register_name(nbtsrv, lp_workgroup(global_loadparm),
NBT_NAME_LOGON, nb_flags | NBT_NM_GROUP);
}
nb_flags |= NBT_NM_GROUP;
- nbtd_register_name(nbtsrv, lp_workgroup(), NBT_NAME_CLIENT, nb_flags);
+ nbtd_register_name(nbtsrv, lp_workgroup(global_loadparm), NBT_NAME_CLIENT, nb_flags);
nb_flags |= NBT_NM_PERMANENT;
nbtd_register_name(nbtsrv, "__SAMBA__", NBT_NAME_CLIENT, nb_flags);
void wins_hook(struct winsdb_handle *h, const struct winsdb_record *rec,
enum wins_hook_action action)
{
- const char *script = lp_wins_hook();
+ const char *script = lp_wins_hook(global_loadparm);
uint32_t i, length;
int child;
char *cmd = NULL;
/* setup a wins name register request */
io.in.name = iname->name;
- io.in.wins_servers = lp_wins_server_list();
+ io.in.wins_servers = lp_wins_server_list(global_loadparm);
io.in.addresses = nbtd_address_list(iface, iname);
io.in.nb_flags = iname->nb_flags;
io.in.ttl = iname->ttl;
flags |= LDB_FLG_NOSYNC;
}
- h->ldb = ldb_wrap_connect(h, lock_path(h, lp_wins_url()),
+ h->ldb = ldb_wrap_connect(h, lock_path(h, lp_wins_url(global_loadparm)),
NULL, NULL, flags, NULL);
if (!h->ldb) goto failed;
flags |= LDB_FLG_NOSYNC;
}
- h->ldb = ldb_wrap_connect(h, lock_path(h, lp_wins_url()),
+ h->ldb = ldb_wrap_connect(h, lock_path(h, lp_wins_url(global_loadparm)),
NULL, NULL, flags, NULL);
if (!h->ldb) goto failed;
status = winsdb_lookup(winssrv->wins_db, name, packet, &rec);
if (!NT_STATUS_IS_OK(status)) {
- if (!lp_wins_dns_proxy()) {
+ if (!lp_wins_dns_proxy(global_loadparm)) {
goto notfound;
}
{
uint32_t tmp;
- if (!lp_wins_support()) {
+ if (!lp_wins_support(global_loadparm)) {
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->winssrv->config.min_renew_interval = lp_min_wins_ttl();
+ nbtsrv->winssrv->config.max_renew_interval = lp_max_wins_ttl(global_loadparm);
+ nbtsrv->winssrv->config.min_renew_interval = lp_min_wins_ttl(global_loadparm);
tmp = lp_parm_int(NULL, "wreplsrv", "tombstone_interval", 6*24*60*60);
nbtsrv->winssrv->config.tombstone_interval = tmp;
tmp = lp_parm_int(NULL, "wreplsrv"," tombstone_timeout", 1*24*60*60);
return 0;
}
/* HACK: (this module should not call lp_ funtions) */
- return *lp_winbind_separator();
+ return *lp_winbind_separator(global_loadparm);
}
sep = response.data.info.winbind_separator;
return 0;
}
/* HACK: (this module should not call lp_ funtions) */
- sep = *lp_winbind_separator();
+ sep = *lp_winbind_separator(global_loadparm);
}
return sep;
d_fprintf(stderr, "could not obtain winbind domain name!\n");
/* HACK: (this module should not call lp_ funtions) */
- return lp_workgroup();
+ return lp_workgroup(global_loadparm);
}
fstrcpy(winbind_domain, response.data.domain_name);
generate_random_buffer(request.data.auth_crap.chal, 8);
- if (lp_client_ntlmv2_auth()) {
+ if (lp_client_ntlmv2_auth(global_loadparm)) {
DATA_BLOB server_chal;
DATA_BLOB names_blob;
server_chal = data_blob(request.data.auth_crap.chal, 8);
/* Pretend this is a login to 'us', for blob purposes */
- names_blob = NTLMv2_generate_names_blob(mem_ctx, lp_netbios_name(), lp_workgroup());
+ names_blob = NTLMv2_generate_names_blob(mem_ctx, lp_netbios_name(global_loadparm), lp_workgroup(global_loadparm));
if (!SMBNTLMv2encrypt(mem_ctx, name_user, name_domain, pass, &server_chal,
&names_blob,
data_blob_free(&lm_response);
} else {
- if (lp_client_lanman_auth()
+ if (lp_client_lanman_auth(global_loadparm)
&& SMBencrypt(pass, request.data.auth_crap.chal,
(unsigned char *)request.data.auth_crap.lm_resp)) {
request.data.auth_crap.lm_resp_len = 24;
*/
static struct ldb_context *sptr_db_connect(TALLOC_CTX *mem_ctx)
{
- return ldb_wrap_connect(mem_ctx, lp_spoolss_url(), system_session(mem_ctx),
+ return ldb_wrap_connect(mem_ctx, lp_spoolss_url(global_loadparm), system_session(mem_ctx),
NULL, 0, NULL);
}
r->out.data.binary = blob;
return WERR_OK;
} else if (strcmp("DNSMachineName", r->in.value_name) == 0) {
- if (!lp_realm()) return WERR_INVALID_PARAM;
+ if (!lp_realm(global_loadparm)) return WERR_INVALID_PARAM;
r->out.type = SPOOLSS_PRINTER_DATA_TYPE_STRING;
r->out.data.string = talloc_asprintf(mem_ctx, "%s.%s",
- lp_netbios_name(),
- lp_realm());
+ lp_netbios_name(global_loadparm),
+ lp_realm(global_loadparm));
W_ERROR_HAVE_NO_MEMORY(r->out.data.string);
return WERR_OK;
}
return NT_STATUS_NO_MEMORY;
}
cli_credentials_set_event_context(credentials, ntvfs->ctx->event_ctx);
- cli_credentials_set_conf(credentials);
+ cli_credentials_set_conf(credentials, global_loadparm);
cli_credentials_set_username(credentials, user, CRED_SPECIFIED);
if (domain) {
cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
DEBUG(5, ("CIFS backend: Using machine account\n"));
credentials = cli_credentials_init(private);
cli_credentials_set_event_context(credentials, ntvfs->ctx->event_ctx);
- cli_credentials_set_conf(credentials);
+ cli_credentials_set_conf(credentials, global_loadparm);
if (domain) {
cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
}
io.in.called_name = host;
io.in.credentials = credentials;
io.in.fallback_to_anonymous = False;
- io.in.workgroup = lp_workgroup();
+ io.in.workgroup = lp_workgroup(global_loadparm);
io.in.service = remote_share;
io.in.service_type = "?????";
p = (char *)io->ioctl.out.blob.data;
SSVAL(p,0, 1 /* REWRITE: fsp->rap_print_jobid */);
- push_string(p+2, lp_netbios_name(), 15, STR_TERMINATE|STR_ASCII);
+ push_string(p+2, lp_netbios_name(global_loadparm), 15, STR_TERMINATE|STR_ASCII);
push_string(p+18, ntvfs->ctx->config->name, 13, STR_TERMINATE|STR_ASCII);
return NT_STATUS_OK;
}
static bool bLoaded = false;
-struct loadparm_context *global_loadparm = NULL;
-
#define standard_sub_basic talloc_strdup
static bool do_parameter(const char *, const char *, void *);
{
enum server_role server_role;
- char **smb_ports;
+ const char **smb_ports;
char *ncalrpc_dir;
char *szLockDir;
char *szModulesDir;
char *szServerString;
char *szAutoServices;
char *szPasswdChat;
- char *szConfigFile;
+ const char *szConfigFile;
char *szShareBackend;
char *szSAM_URL;
char *szSECRETS_URL;
char *szWINS_CONFIG_URL;
char *szWINS_URL;
char *szPrivateDir;
- char **jsInclude;
+ const char **jsInclude;
char *jsonrpcServicesDir;
- char **szPasswordServers;
+ const char **szPasswordServers;
char *szSocketOptions;
char *szRealm;
- char **szWINSservers;
- char **szInterfaces;
+ const char **szWINSservers;
+ const char **szInterfaces;
char *szSocketAddress;
char *szAnnounceVersion; /* This is initialised in init_globals */
char *szWorkgroup;
char *szNetbiosName;
- char **szNetbiosAliases;
+ const char **szNetbiosAliases;
char *szNetbiosScope;
char *szDomainOtherSIDs;
- char **szNameResolveOrder;
- char **dcerpc_ep_servers;
- char **server_services;
+ const char **szNameResolveOrder;
+ const char **dcerpc_ep_servers;
+ const char **server_services;
char *ntptr_providor;
char *szWinbindSeparator;
char *szWinbinddSocketDirectory;
char *subfname;
time_t modtime;
} *file_lists;
-} loadparm = {
- .iNumServices = 0,
- .currentService = NULL,
- .bInGlobalSection = true,
- .ServicePtrs = NULL,
- .file_lists = NULL,
-};
+} loadparm;
+
+struct loadparm_context *global_loadparm = &loadparm;
#define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
static struct parm_struct parm_table[] = {
{"Base Options", P_SEP, P_SEPARATOR},
+ {"config file", P_STRING, P_GLOBAL, &loadparm.Globals.szConfigFile, NULL, NULL, FLAG_HIDE},
+
{"server role", P_ENUM, P_GLOBAL, &loadparm.Globals.server_role, NULL, enum_server_role, FLAG_BASIC},
{"dos charset", P_STRING, P_GLOBAL, &dos_charset, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
{"Miscellaneous Options", P_SEP, P_SEPARATOR},
- {"config file", P_STRING, P_GLOBAL, &loadparm.Globals.szConfigFile, NULL, NULL, FLAG_HIDE},
{"share backend", P_STRING, P_GLOBAL, &loadparm.Globals.szShareBackend, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
{"preload", P_STRING, P_GLOBAL, &loadparm.Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
{"auto services", P_STRING, P_GLOBAL, &loadparm.Globals.szAutoServices, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
parameters from the rest of the program are defined
*/
-#define FN_GLOBAL_STRING(fn_name,ptr) \
- const char *fn_name(void) {return(lp_string(*(char **)(ptr) ? *(char **)(ptr) : ""));}
-#define FN_GLOBAL_CONST_STRING(fn_name,ptr) \
- const char *fn_name(void) {return(*(const char **)(ptr) ? *(const char **)(ptr) : "");}
-#define FN_GLOBAL_LIST(fn_name,ptr) \
- const char **fn_name(void) {return(*(const char ***)(ptr));}
-#define FN_GLOBAL_BOOL(fn_name,ptr) \
- bool fn_name(void) {return((bool)*(int *)(ptr));}
+#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) : "";}
+#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 : "";}
+#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;}
+#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
-#define FN_GLOBAL_INTEGER(fn_name,ptr) \
- int fn_name(void) {return(*(int *)(ptr));}
+#define FN_GLOBAL_INTEGER(fn_name,var_name) \
+ int fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return 0; return lp_ctx->Globals.var_name;}
#define FN_LOCAL_STRING(fn_name,val) \
const char *fn_name(struct loadparm_service *service) {return(lp_string((const char *)((service != NULL && service->val != NULL) ? service->val : sDefault.val)));}
#define FN_LOCAL_INTEGER(fn_name,val) \
int fn_name(struct loadparm_service *service) {return((service != NULL)? service->val : sDefault.val);}
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_server_role, &loadparm.Globals.server_role)
-_PUBLIC_ FN_GLOBAL_LIST(lp_smb_ports, &loadparm.Globals.smb_ports)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_nbt_port, &loadparm.Globals.nbt_port)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_dgram_port, &loadparm.Globals.dgram_port)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_cldap_port, &loadparm.Globals.cldap_port)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_krb5_port, &loadparm.Globals.krb5_port)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_kpasswd_port, &loadparm.Globals.kpasswd_port)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_web_port, &loadparm.Globals.web_port)
-_PUBLIC_ FN_GLOBAL_STRING(lp_dos_charset, &dos_charset)
-_PUBLIC_ FN_GLOBAL_STRING(lp_swat_directory, &loadparm.Globals.swat_directory)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_tls_enabled, &loadparm.Globals.tls_enabled)
-_PUBLIC_ FN_GLOBAL_STRING(lp_tls_keyfile, &loadparm.Globals.tls_keyfile)
-_PUBLIC_ FN_GLOBAL_STRING(lp_tls_certfile, &loadparm.Globals.tls_certfile)
-_PUBLIC_ FN_GLOBAL_STRING(lp_tls_cafile, &loadparm.Globals.tls_cafile)
-_PUBLIC_ FN_GLOBAL_STRING(lp_tls_crlfile, &loadparm.Globals.tls_crlfile)
-_PUBLIC_ FN_GLOBAL_STRING(lp_tls_dhpfile, &loadparm.Globals.tls_dhpfile)
-_PUBLIC_ FN_GLOBAL_STRING(lp_unix_charset, &unix_charset)
-_PUBLIC_ FN_GLOBAL_STRING(lp_display_charset, &display_charset)
-_PUBLIC_ FN_GLOBAL_STRING(lp_configfile, &loadparm.Globals.szConfigFile)
-_PUBLIC_ FN_GLOBAL_STRING(lp_share_backend, &loadparm.Globals.szShareBackend)
-_PUBLIC_ FN_GLOBAL_STRING(lp_sam_url, &loadparm.Globals.szSAM_URL)
-_PUBLIC_ FN_GLOBAL_STRING(lp_secrets_url, &loadparm.Globals.szSECRETS_URL)
-_PUBLIC_ FN_GLOBAL_STRING(lp_spoolss_url, &loadparm.Globals.szSPOOLSS_URL)
-_PUBLIC_ FN_GLOBAL_STRING(lp_wins_config_url, &loadparm.Globals.szWINS_CONFIG_URL)
-_PUBLIC_ FN_GLOBAL_STRING(lp_wins_url, &loadparm.Globals.szWINS_URL)
-_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbind_separator, &loadparm.Globals.szWinbindSeparator)
-_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbindd_socket_directory, &loadparm.Globals.szWinbinddSocketDirectory)
-_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_shell, &loadparm.Globals.szTemplateShell)
-_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_homedir, &loadparm.Globals.szTemplateHomedir)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_winbind_sealed_pipes, &loadparm.Globals.bWinbindSealedPipes)
-_PUBLIC_ FN_GLOBAL_STRING(lp_private_dir, &loadparm.Globals.szPrivateDir)
-_PUBLIC_ FN_GLOBAL_STRING(lp_serverstring, &loadparm.Globals.szServerString)
-_PUBLIC_ FN_GLOBAL_STRING(lp_lockdir, &loadparm.Globals.szLockDir)
-_PUBLIC_ FN_GLOBAL_STRING(lp_modulesdir, &loadparm.Globals.szModulesDir)
-_PUBLIC_ FN_GLOBAL_STRING(lp_setupdir, &loadparm.Globals.szSetupDir)
-_PUBLIC_ FN_GLOBAL_STRING(lp_ncalrpc_dir, &loadparm.Globals.ncalrpc_dir)
-_PUBLIC_ FN_GLOBAL_STRING(lp_piddir, &loadparm.Globals.szPidDir)
-_PUBLIC_ FN_GLOBAL_LIST(lp_dcerpc_endpoint_servers, &loadparm.Globals.dcerpc_ep_servers)
-_PUBLIC_ FN_GLOBAL_LIST(lp_server_services, &loadparm.Globals.server_services)
-_PUBLIC_ FN_GLOBAL_STRING(lp_ntptr_providor, &loadparm.Globals.ntptr_providor)
-_PUBLIC_ FN_GLOBAL_STRING(lp_auto_services, &loadparm.Globals.szAutoServices)
-_PUBLIC_ FN_GLOBAL_STRING(lp_passwd_chat, &loadparm.Globals.szPasswdChat)
-_PUBLIC_ FN_GLOBAL_LIST(lp_passwordserver, &loadparm.Globals.szPasswordServers)
-_PUBLIC_ FN_GLOBAL_LIST(lp_name_resolve_order, &loadparm.Globals.szNameResolveOrder)
-_PUBLIC_ FN_GLOBAL_STRING(lp_realm, &loadparm.Globals.szRealm)
-_PUBLIC_ FN_GLOBAL_STRING(lp_socket_options, &loadparm.Globals.socket_options)
-_PUBLIC_ FN_GLOBAL_STRING(lp_workgroup, &loadparm.Globals.szWorkgroup)
-_PUBLIC_ FN_GLOBAL_STRING(lp_netbios_name, &loadparm.Globals.szNetbiosName)
-_PUBLIC_ FN_GLOBAL_STRING(lp_netbios_scope, &loadparm.Globals.szNetbiosScope)
-_PUBLIC_ FN_GLOBAL_LIST(lp_wins_server_list, &loadparm.Globals.szWINSservers)
-_PUBLIC_ FN_GLOBAL_LIST(lp_interfaces, &loadparm.Globals.szInterfaces)
-_PUBLIC_ FN_GLOBAL_STRING(lp_socket_address, &loadparm.Globals.szSocketAddress)
-_PUBLIC_ FN_GLOBAL_LIST(lp_netbios_aliases, &loadparm.Globals.szNetbiosAliases)
-
-_PUBLIC_ FN_GLOBAL_BOOL(lp_disable_netbios, &loadparm.Globals.bDisableNetbios)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_wins_support, &loadparm.Globals.bWINSsupport)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_wins_dns_proxy, &loadparm.Globals.bWINSdnsProxy)
-_PUBLIC_ FN_GLOBAL_STRING(lp_wins_hook, &loadparm.Globals.szWINSHook)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_local_master, &loadparm.Globals.bLocalMaster)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_readraw, &loadparm.Globals.bReadRaw)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_large_readwrite, &loadparm.Globals.bLargeReadwrite)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_writeraw, &loadparm.Globals.bWriteRaw)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_null_passwords, &loadparm.Globals.bNullPasswords)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_obey_pam_restrictions, &loadparm.Globals.bObeyPamRestrictions)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_encrypted_passwords, &loadparm.Globals.bEncryptPasswords)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_time_server, &loadparm.Globals.bTimeServer)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_bind_interfaces_only, &loadparm.Globals.bBindInterfacesOnly)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_unicode, &loadparm.Globals.bUnicode)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_nt_status_support, &loadparm.Globals.bNTStatusSupport)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_lanman_auth, &loadparm.Globals.bLanmanAuth)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_ntlm_auth, &loadparm.Globals.bNTLMAuth)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_client_plaintext_auth, &loadparm.Globals.bClientPlaintextAuth)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_client_lanman_auth, &loadparm.Globals.bClientLanManAuth)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, &loadparm.Globals.bClientNTLMv2Auth)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_client_use_spnego_principal, &loadparm.Globals.client_use_spnego_principal)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_host_msdfs, &loadparm.Globals.bHostMSDfs)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_unix_extensions, &loadparm.Globals.bUnixExtensions)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_use_spnego, &loadparm.Globals.bUseSpnego)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_rpc_big_endian, &loadparm.Globals.bRpcBigEndian)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_max_wins_ttl, &loadparm.Globals.max_wins_ttl)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_min_wins_ttl, &loadparm.Globals.min_wins_ttl)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_maxmux, &loadparm.Globals.max_mux)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_max_xmit, &loadparm.Globals.max_xmit)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_passwordlevel, &loadparm.Globals.pwordlevel)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_maxprotocol, &loadparm.Globals.srv_maxprotocol)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_minprotocol, &loadparm.Globals.srv_minprotocol)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_maxprotocol, &loadparm.Globals.cli_maxprotocol)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_minprotocol, &loadparm.Globals.cli_minprotocol)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_security, &loadparm.Globals.security)
-_PUBLIC_ FN_GLOBAL_BOOL(lp_paranoid_server_security, &loadparm.Globals.paranoid_server_security)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_announce_as, &loadparm.Globals.announce_as)
-_PUBLIC_ FN_GLOBAL_LIST(lp_js_include, &loadparm.Globals.jsInclude)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_server_role, server_role)
+_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_STRING(lp_swat_directory, swat_directory)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_tls_enabled, tls_enabled)
+_PUBLIC_ FN_GLOBAL_STRING(lp_tls_keyfile, tls_keyfile)
+_PUBLIC_ FN_GLOBAL_STRING(lp_tls_certfile, tls_certfile)
+_PUBLIC_ FN_GLOBAL_STRING(lp_tls_cafile, tls_cafile)
+_PUBLIC_ FN_GLOBAL_STRING(lp_tls_crlfile, tls_crlfile)
+_PUBLIC_ FN_GLOBAL_STRING(lp_tls_dhpfile, tls_dhpfile)
+_PUBLIC_ FN_GLOBAL_STRING(lp_share_backend, szShareBackend)
+_PUBLIC_ FN_GLOBAL_STRING(lp_sam_url, szSAM_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_template_shell, szTemplateShell)
+_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_homedir, szTemplateHomedir)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_winbind_sealed_pipes, bWinbindSealedPipes)
+_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_piddir, szPidDir)
+_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)
+_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_STRING(lp_configfile, szConfigFile)
+_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)
+_PUBLIC_ FN_GLOBAL_LIST(lp_js_include, jsInclude)
_PUBLIC_ FN_LOCAL_STRING(lp_servicename, szService)
_PUBLIC_ FN_LOCAL_CONST_STRING(lp_const_servicename, szService)
_PUBLIC_ FN_LOCAL_STRING(lp_pathname, szPath)
_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, &loadparm.Globals.server_signing)
-_PUBLIC_ FN_GLOBAL_INTEGER(lp_client_signing, &loadparm.Globals.client_signing)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_server_signing, server_signing)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_client_signing, client_signing)
/* local prototypes */
static int map_parameter(const char *pszParmName);
}
}
- lp_do_global_parameter(lp_ctx, "config file", dyn_CONFIGFILE);
-
lp_do_global_parameter(lp_ctx, "share backend", "classic");
lp_do_global_parameter(lp_ctx, "server role", "standalone");
False on failure.
***************************************************************************/
-bool lp_load(void)
+bool lp_load(const char *filename)
{
char *n2;
bool bRetval;
struct param_opt *data;
struct loadparm_context *lp_ctx = &loadparm;
- global_loadparm = lp_ctx;
+ filename = talloc_strdup(talloc_autofree_context(), filename);
- bRetval = false;
+ global_loadparm = lp_ctx;
if (lp_ctx->Globals.param_opt != NULL) {
struct param_opt *next;
if (!loadparm_init(lp_ctx))
return false;
+
+ lp_ctx->Globals.szConfigFile = filename;
lp_ctx->bInGlobalSection = true;
- n2 = standard_sub_basic(talloc_autofree_context(), lp_configfile());
+ n2 = standard_sub_basic(talloc_autofree_context(), lp_ctx->Globals.szConfigFile);
DEBUG(2, ("lp_load: refreshing parameters from %s\n", n2));
- add_to_file_list(lp_ctx, lp_configfile(), n2);
+ add_to_file_list(lp_ctx, lp_ctx->Globals.szConfigFile, n2);
/* We get sections first, so have to start 'behind' to make up */
lp_ctx->currentService = NULL;
if (lp_ctx->currentService != NULL)
bRetval = service_ok(lp_ctx->currentService);
- lp_add_auto_services(lp_ctx, lp_auto_services());
+ lp_add_auto_services(lp_ctx, lp_auto_services(lp_ctx));
lp_add_hidden(lp_ctx, "IPC$", "IPC");
lp_add_hidden(lp_ctx, "ADMIN$", "DISK");
If we are PDC then prefer us as DMB
************************************************************/
-bool lp_domain_logons(void)
+bool lp_domain_logons(struct loadparm_context *lp_ctx)
{
- return (lp_server_role() == ROLE_DOMAIN_CONTROLLER);
+ return (lp_server_role(lp_ctx) == ROLE_DOMAIN_CONTROLLER);
}
const char *lp_printername(struct loadparm_service *service)
}
/* open up the secrets database */
-BOOL secrets_init(void)
+bool secrets_init(void)
{
char *fname;
uint8_t dummy;
if (tdb)
- return True;
+ return true;
- asprintf(&fname, "%s/secrets.tdb", lp_private_dir());
+ asprintf(&fname, "%s/secrets.tdb", lp_private_dir(global_loadparm));
tdb = tdb_wrap_open(talloc_autofree_context(), fname, 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
if (!tdb) {
DEBUG(0,("Failed to open %s\n", fname));
SAFE_FREE(fname);
- return False;
+ return false;
}
SAFE_FREE(fname);
"computerName: CASE_INSENSITIVE\n" \
"flatname: CASE_INSENSITIVE\n";
- url = lp_secrets_url();
+ url = lp_secrets_url(global_loadparm);
if (!url || !url[0]) {
return NULL;
}
ops = share_backend_by_name(backend_name);
if (!ops) {
- DEBUG(0, ("share_init_connection: share backend [%s] not found!\n", lp_share_backend()));
+ DEBUG(0, ("share_init_connection: share backend [%s] not found!\n", lp_share_backend(global_loadparm)));
return NT_STATUS_INTERNAL_ERROR;
}
NTSTATUS share_get_context(TALLOC_CTX *mem_ctx, struct share_context **ctx)
{
- return share_get_context_by_name(mem_ctx, lp_share_backend(), ctx);
+ return share_get_context_by_name(mem_ctx, lp_share_backend(global_loadparm), ctx);
}
/*
const char **aliases;
int i;
- if (strcasecmp(name, lp_netbios_name()) == 0) {
+ if (strcasecmp(name, lp_netbios_name(global_loadparm)) == 0) {
return True;
}
- aliases = lp_netbios_aliases();
+ aliases = lp_netbios_aliases(global_loadparm);
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());
+ dname = talloc_strdup(mem_ctx, lp_lockdir(global_loadparm));
trim_string(dname,"","/");
if (!directory_exist(dname)) {
{
char *fname, *dname;
- dname = talloc_strdup(mem_ctx, lp_piddir());
+ dname = talloc_strdup(mem_ctx, lp_piddir(global_loadparm));
trim_string(dname,"","/");
if (!directory_exist(dname)) {
_PUBLIC_ char *config_path(TALLOC_CTX* mem_ctx, const char *name)
{
char *fname, *config_dir, *p;
- config_dir = talloc_strdup(mem_ctx, lp_configfile());
+ config_dir = talloc_strdup(mem_ctx, lp_configfile(global_loadparm));
p = strrchr(config_dir, '/');
if (!p) {
return NULL;
if (name[0] == 0 || name[0] == '/' || strstr(name, ":/")) {
return talloc_strdup(mem_ctx, name);
}
- fname = talloc_asprintf(mem_ctx, "%s/%s", lp_private_dir(), name);
+ fname = talloc_asprintf(mem_ctx, "%s/%s", lp_private_dir(global_loadparm), name);
return fname;
}
{
const char *env_moduledir = getenv("LD_SAMBA_MODULE_PATH");
return talloc_asprintf(mem_ctx, "%s/%s",
- env_moduledir?env_moduledir:lp_modulesdir(),
+ env_moduledir?env_moduledir:lp_modulesdir(global_loadparm),
name);
}
/* if there's no string return our NETBIOS name */
if (!p) {
- return talloc_strdup(mem_ctx, lp_netbios_name());
+ return talloc_strdup(mem_ctx, lp_netbios_name(global_loadparm));
}
/* if there're '\\\\' in front remove them otherwise just pass the string */
const char *dcesrv_common_get_domain_name(TALLOC_CTX *mem_ctx, struct dcesrv_context *dce_ctx)
{
- return talloc_strdup(mem_ctx, lp_workgroup());
+ return talloc_strdup(mem_ctx, lp_workgroup(global_loadparm));
}
/* This hardcoded value should go into a ldb database! */
default_server_announce |= SV_TYPE_SERVER;
default_server_announce |= SV_TYPE_SERVER_UNIX;
- switch (lp_announce_as()) {
+ switch (lp_announce_as(global_loadparm)) {
case ANNOUNCE_AS_NT_SERVER:
default_server_announce |= SV_TYPE_SERVER_NT;
/* fall through... */
break;
}
- switch (lp_server_role()) {
+ switch (lp_server_role(global_loadparm)) {
case ROLE_DOMAIN_MEMBER:
default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
break;
default:
break;
}
- if (lp_time_server())
+ if (lp_time_server(global_loadparm))
default_server_announce |= SV_TYPE_TIME_SOURCE;
- if (lp_host_msdfs())
+ if (lp_host_msdfs(global_loadparm))
default_server_announce |= SV_TYPE_DFS_SERVER;
{
pkt->rpc_vers = 5;
pkt->rpc_vers_minor = 0;
- if (lp_rpc_big_endian()) {
+ if (lp_rpc_big_endian(global_loadparm)) {
pkt->drep[0] = 0;
} else {
pkt->drep[0] = DCERPC_DREP_LE;
pointers */
push->ptr_count = call->ndr_pull->ptr_count;
- if (lp_rpc_big_endian()) {
+ if (lp_rpc_big_endian(global_loadparm)) {
push->flags |= LIBNDR_FLAG_BIGENDIAN;
}
NTSTATUS status;
struct dcesrv_context *dce_ctx;
- status = dcesrv_init_context(mem_ctx, lp_dcerpc_endpoint_servers(), &dce_ctx);
+ status = dcesrv_init_context(mem_ctx, lp_dcerpc_endpoint_servers(global_loadparm), &dce_ctx);
NT_STATUS_NOT_OK_RETURN(status);
*_dce_ctx = dce_ctx;
#include "librpc/gen_ndr/ndr_dcerpc.h"
#include "auth/credentials/credentials.h"
#include "auth/gensec/gensec.h"
+#include "param/param.h"
/*
parse any auth information from a dcerpc bind request
return False;
}
- cli_credentials_set_conf(server_credentials);
+ cli_credentials_set_conf(server_credentials, global_loadparm);
status = cli_credentials_set_machine_account(server_credentials);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(10, ("Failed to obtain server credentials, perhaps a standalone server?: %s\n", nt_errstr(status)));
ZERO_STRUCT(domain_guid);
- switch (lp_server_role()) {
+ switch (lp_server_role(global_loadparm)) {
case ROLE_STANDALONE:
role = DS_ROLE_STANDALONE_SERVER;
break;
break;
}
- switch (lp_server_role()) {
+ switch (lp_server_role(global_loadparm)) {
case ROLE_STANDALONE:
- domain = talloc_strdup(mem_ctx, lp_workgroup());
+ domain = talloc_strdup(mem_ctx, lp_workgroup(global_loadparm));
W_ERROR_HAVE_NO_MEMORY(domain);
break;
case ROLE_DOMAIN_MEMBER:
- domain = talloc_strdup(mem_ctx, lp_workgroup());
+ domain = talloc_strdup(mem_ctx, lp_workgroup(global_loadparm));
W_ERROR_HAVE_NO_MEMORY(domain);
/* TODO: what is with dns_domain and forest and guid? */
break;
creds->account_name = talloc_steal(creds, r->in.account_name);
creds->computer_name = talloc_steal(creds, r->in.computer_name);
- creds->domain = talloc_strdup(creds, lp_workgroup());
+ creds->domain = talloc_strdup(creds, lp_workgroup(global_loadparm));
creds->secure_channel_type = r->in.secure_channel_type;
* disconnects) we must update the database every time we
* update the structure */
- nt_status = schannel_fetch_session_key_ldb(ldb, ldb, computer_name, lp_workgroup(),
+ nt_status = schannel_fetch_session_key_ldb(ldb, ldb, computer_name,
+ lp_workgroup(global_loadparm),
&creds);
if (NT_STATUS_IS_OK(nt_status)) {
nt_status = creds_server_step_check(creds,
sam6 = talloc_zero(mem_ctx, struct netr_SamInfo6);
NT_STATUS_HAVE_NO_MEMORY(sam6);
sam6->base = *sam;
- sam6->forest.string = lp_realm();
+ sam6->forest.string = lp_realm(global_loadparm);
sam6->principle.string = talloc_asprintf(mem_ctx, "%s@%s",
sam->account_name.string, sam6->forest.string);
NT_STATUS_HAVE_NO_MEMORY(sam6->principle.string);
{
NTSTATUS nt_status;
struct creds_CredentialState *creds;
- nt_status = schannel_fetch_session_key(mem_ctx, r->in.computer_name, lp_workgroup(), &creds);
+ nt_status = schannel_fetch_session_key(mem_ctx, r->in.computer_name, lp_workgroup(global_loadparm), &creds);
if (!NT_STATUS_IS_OK(nt_status)) {
return nt_status;
}
/* TODO: - return real IP address
* - check all r->in.* parameters (server_unc is ignored by w2k3!)
*/
- r->out.info->dc_unc = talloc_asprintf(mem_ctx, "\\\\%s.%s", lp_netbios_name(),lp_realm());
+ r->out.info->dc_unc = talloc_asprintf(mem_ctx, "\\\\%s.%s",
+ lp_netbios_name(global_loadparm),
+ lp_realm(global_loadparm));
W_ERROR_HAVE_NO_MEMORY(r->out.info->dc_unc);
r->out.info->dc_address = talloc_strdup(mem_ctx, "\\\\0.0.0.0");
W_ERROR_HAVE_NO_MEMORY(r->out.info->dc_address);
if (!credentials) {
return NT_STATUS_NO_MEMORY;
}
- cli_credentials_set_conf(credentials);
+ cli_credentials_set_conf(credentials, global_loadparm);
cli_credentials_set_username(credentials, user, CRED_SPECIFIED);
if (domain) {
cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
} else if (machine_account) {
DEBUG(5, ("dcerpc_remote: RPC Proxy: Using machine account\n"));
credentials = cli_credentials_init(private);
- cli_credentials_set_conf(credentials);
+ cli_credentials_set_conf(credentials, global_loadparm);
if (domain) {
cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
}
struct ldb_message **dom_msgs,
struct samr_DomInfo2 *info)
{
- enum server_role role = lp_server_role();
+ enum server_role role = lp_server_role(global_loadparm);
/* This pulls the NetBIOS name from the
cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
struct samr_DomInfo7 *info)
{
- enum server_role role = lp_server_role();
+ enum server_role role = lp_server_role(global_loadparm);
switch (role) {
case ROLE_DOMAIN_CONTROLLER:
e->ep_description->endpoint = talloc_strdup(dce_ctx, "DEFAULT");
}
- full_path = talloc_asprintf(dce_ctx, "%s/%s", lp_ncalrpc_dir(), e->ep_description->endpoint);
+ full_path = talloc_asprintf(dce_ctx, "%s/%s", lp_ncalrpc_dir(global_loadparm),
+ e->ep_description->endpoint);
dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
NTSTATUS status;
/* Add TCP/IP sockets */
- if (lp_interfaces() && lp_bind_interfaces_only()) {
+ if (lp_interfaces(global_loadparm) && lp_bind_interfaces_only(global_loadparm)) {
int num_interfaces = iface_count();
int i;
for(i = 0; i < num_interfaces; i++) {
NT_STATUS_NOT_OK_RETURN(status);
}
} else {
- status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops, lp_socket_address());
+ status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops,
+ lp_socket_address(global_loadparm));
NT_STATUS_NOT_OK_RETURN(status);
}
task_server_set_title(task, "task[dcesrv]");
status = dcesrv_init_context(task->event_ctx,
- lp_dcerpc_endpoint_servers(),
+ lp_dcerpc_endpoint_servers(global_loadparm),
&dce_ctx);
if (!NT_STATUS_IS_OK(status)) goto failed;
/* Make sure the directory for NCALRPC exists */
- if (!directory_exist(lp_ncalrpc_dir())) {
- mkdir(lp_ncalrpc_dir(), 0755);
+ if (!directory_exist(lp_ncalrpc_dir(global_loadparm))) {
+ mkdir(lp_ncalrpc_dir(global_loadparm), 0755);
}
for (e=dce_ctx->endpoint_list;e;e=e->next) {
server_name += 2;
/* NETBIOS NAME is ok */
- ret = strequal(lp_netbios_name(), server_name);
+ ret = strequal(lp_netbios_name(global_loadparm), server_name);
if (ret) return WERR_OK;
- aliases = lp_netbios_aliases();
+ aliases = lp_netbios_aliases(global_loadparm);
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
*/
- if (lp_realm()) {
+ if (lp_realm(global_loadparm)) {
char *str;
str = talloc_asprintf(mem_ctx, "%s.%s",
- lp_netbios_name(),
- lp_realm());
+ lp_netbios_name(global_loadparm),
+ lp_realm(global_loadparm));
W_ERROR_HAVE_NO_MEMORY(str);
ret = strequal(str, server_name);
NTSTATUS status;
struct ntptr_context *ntptr;
- status = ntptr_init_context(dce_call->context, lp_ntptr_providor(), &ntptr);
+ status = ntptr_init_context(dce_call->context, lp_ntptr_providor(global_loadparm), &ntptr);
NT_STATUS_NOT_OK_RETURN(status);
dce_call->context->private = ntptr;
}
ZERO_STRUCT(rop);
- rop.in.server_name = lp_netbios_name();
+ rop.in.server_name = lp_netbios_name(global_loadparm);
W_ERROR_HAVE_NO_MEMORY(rop.in.server_name);
rop.in.printer_local = 0;
rop.in.type = REG_NONE;
info101->version_major = dcesrv_common_get_version_major(mem_ctx, dce_ctx);
info101->version_minor = dcesrv_common_get_version_minor(mem_ctx, dce_ctx);
info101->server_type = dcesrv_common_get_server_type(mem_ctx, dce_ctx);
- info101->comment = talloc_strdup(mem_ctx, lp_serverstring());
+ info101->comment = talloc_strdup(mem_ctx, lp_serverstring(global_loadparm));
W_ERROR_HAVE_NO_MEMORY(info101->comment);
r->out.info.info101 = info101;
info102->version_major = dcesrv_common_get_version_major(mem_ctx, dce_ctx);
info102->version_minor = dcesrv_common_get_version_minor(mem_ctx, dce_ctx);
info102->server_type = dcesrv_common_get_server_type(mem_ctx, dce_ctx);
- info102->comment = talloc_strdup(mem_ctx, lp_serverstring());
+ info102->comment = talloc_strdup(mem_ctx, lp_serverstring(global_loadparm));
W_ERROR_HAVE_NO_MEMORY(info102->comment);
info102->users = dcesrv_common_get_users(mem_ctx, dce_ctx);
);
my %smap = (
- "GLOBAL" => "void",
+ "GLOBAL" => "struct loadparm_context *",
"LOCAL" => "struct loadparm_service *"
);
talloc_free(ctx);
return -1;
}
- cli_credentials_set_conf(creds);
+ cli_credentials_set_conf(creds, global_loadparm);
cli_credentials_set_anonymous(creds);
mprCreds = mprCredentials(creds);
static int ejs_libinclude(int eid, int argc, char **argv)
{
int i, j;
- const char **js_include = lp_js_include();
+ const char **js_include = lp_js_include(global_loadparm);
if (js_include == NULL || js_include[0] == NULL) {
ejsSetErrorMsg(eid, "js include path not set");
/* Set up credentials */
creds = cli_credentials_init(NULL);
- cli_credentials_set_conf(creds);
+ cli_credentials_set_conf(creds, global_loadparm);
cli_credentials_parse_string(creds, argv[1], CRED_SPECIFIED);
/* Do connect */
io.in.service_type = "?????";
io.in.credentials = creds;
io.in.fallback_to_anonymous = False;
- io.in.workgroup = lp_workgroup();
+ io.in.workgroup = lp_workgroup(global_loadparm);
result = smb_composite_connect(&io, mem_ctx, NULL);
tree = io.out.tree;
*/
static int ejs_lpReload(MprVarHandle eid, int argc, char **argv)
{
- BOOL ret = lp_load();
+ BOOL ret = lp_load(lp_configfile(global_loadparm));
if (ret) {
unload_interfaces();
}
return -1;
}
- cli_credentials_set_conf(creds);
+ cli_credentials_set_conf(creds, global_loadparm);
return ejs_credentials_obj(obj, creds);
}
#include "scripting/ejs/smbcalls.h"
#include "auth/gensec/gensec.h"
#include "ldb/include/ldb.h"
+#include "dynconfig.h"
static EjsId eid;
fault_setup(argv[0]);
if (getenv("SMB_CONF_PATH")) {
- lp_set_cmdline(global_loadparm, "config file", getenv("SMB_CONF_PATH"));
+ lp_load(getenv("SMB_CONF_PATH"));
+ } else {
+ lp_load(dyn_CONFIGFILE);
}
ldb_global_init();
gensec_init();
mprSetCtx(mem_ctx);
- lp_load();
if (argc < 2) {
fprintf(stderr, "You must supply a script name\n");
****************************************************************************/
static void reply_coreplus(struct smbsrv_request *req, uint16_t choice)
{
- uint16_t raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
+ uint16_t raw = (lp_readraw(global_loadparm)?1:0) | (lp_writeraw(global_loadparm)?2:0);
smbsrv_setup_reply(req, 13, 0);
****************************************************************************/
static void reply_lanman1(struct smbsrv_request *req, uint16_t choice)
{
- int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
+ int raw = (lp_readraw(global_loadparm)?1:0) | (lp_writeraw(global_loadparm)?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->negotiate.encrypted_passwords = lp_encrypted_passwords(global_loadparm);
- if (lp_security() != SEC_SHARE)
+ if (lp_security(global_loadparm) != 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());
+ SSVAL(req->out.vwv, VWV(3), lp_maxmux(global_loadparm));
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()?1:0) | (lp_writeraw()?2:0);
+ int raw = (lp_readraw(global_loadparm)?1:0) | (lp_writeraw(global_loadparm)?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->negotiate.encrypted_passwords = lp_encrypted_passwords(global_loadparm);
- if (lp_security() != SEC_SHARE)
+ if (lp_security(global_loadparm) != 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());
+ SSVAL(req->out.vwv, VWV(3), lp_maxmux(global_loadparm));
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(), -1, STR_TERMINATE);
+ req_push_str(req, NULL, lp_workgroup(global_loadparm), -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(), -1, STR_UNICODE|STR_TERMINATE|STR_NOALIGN);
- req_push_str(req, NULL, lp_netbios_name(), -1, STR_UNICODE|STR_TERMINATE|STR_NOALIGN);
+ req_push_str(req, NULL, lp_workgroup(global_loadparm), -1, STR_UNICODE|STR_TERMINATE|STR_NOALIGN);
+ req_push_str(req, NULL, lp_netbios_name(global_loadparm), -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->negotiate.encrypted_passwords = lp_encrypted_passwords(global_loadparm);
/* 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() != SEC_SHARE) &&
- lp_use_spnego() &&
+ (lp_security(global_loadparm) != SEC_SHARE) &&
+ lp_use_spnego(global_loadparm) &&
(req->flags2 & FLAGS2_EXTENDED_SECURITY)) {
negotiate_spnego = True;
capabilities |= CAP_EXTENDED_SECURITY;
}
- if (lp_unix_extensions()) {
+ if (lp_unix_extensions(global_loadparm)) {
capabilities |= CAP_UNIX;
}
- if (lp_large_readwrite()) {
+ if (lp_large_readwrite(global_loadparm)) {
capabilities |= CAP_LARGE_READX | CAP_LARGE_WRITEX | CAP_W2K_SMBS;
}
capabilities |= CAP_LARGE_FILES;
}
- if (lp_readraw() && lp_writeraw()) {
+ if (lp_readraw(global_loadparm) && lp_writeraw(global_loadparm)) {
capabilities |= CAP_RAW_MODE;
}
/* allow for disabling unicode */
- if (lp_unicode()) {
+ if (lp_unicode(global_loadparm)) {
capabilities |= CAP_UNICODE;
}
- if (lp_nt_status_support()) {
+ if (lp_nt_status_support(global_loadparm)) {
capabilities |= CAP_STATUS32;
}
- if (lp_host_msdfs()) {
+ if (lp_host_msdfs(global_loadparm)) {
capabilities |= CAP_DFS;
}
- if (lp_security() != SEC_SHARE) {
+ if (lp_security(global_loadparm) != 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());
+ SSVAL(req->out.vwv+1, VWV(1), lp_maxmux(global_loadparm));
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 */
return;
}
- cli_credentials_set_conf(server_credentials);
+ cli_credentials_set_conf(server_credentials, global_loadparm);
nt_status = cli_credentials_set_machine_account(server_credentials);
if (!NT_STATUS_IS_OK(nt_status)) {
DEBUG(10, ("Failed to obtain server credentials, perhaps a standalone server?: %s\n", nt_errstr(nt_status)));
for (protocol = 0; supported_protocols[protocol].proto_name; protocol++) {
int i;
- if (supported_protocols[protocol].protocol_level > lp_srv_maxprotocol()) continue;
- if (supported_protocols[protocol].protocol_level < lp_srv_minprotocol()) continue;
+ if (supported_protocols[protocol].protocol_level > lp_srv_maxprotocol(global_loadparm))
+ continue;
+ if (supported_protocols[protocol].protocol_level < lp_srv_minprotocol(global_loadparm))
+ continue;
for (i = 0; i < protos_count; i++) {
if (strcmp(supported_protocols[protocol].proto_name, protos[i]) != 0) continue;
/* 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->negotiate.max_recv = lp_max_xmit(global_loadparm);
smb_conn->negotiate.zone_offset = get_time_zone(time(NULL));
- smb_conn->config.security = lp_security();
- smb_conn->config.nt_status_support = lp_nt_status_support();
+ smb_conn->config.security = lp_security(global_loadparm);
+ smb_conn->config.nt_status_support = lp_nt_status_support(global_loadparm);
status = smbsrv_init_sessions(smb_conn, UINT16_MAX);
NT_STATUS_NOT_OK_RETURN(status);
con->tconx.out.dev_type = talloc_strdup(req, req->tcon->ntvfs->dev_type);
con->tconx.out.fs_type = talloc_strdup(req, req->tcon->ntvfs->fs_type);
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()) {
+ if (share_bool_option(req->tcon->ntvfs->config, SHARE_MSDFS_ROOT, SHARE_MSDFS_ROOT_DEFAULT) && lp_host_msdfs(global_loadparm)) {
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());
+ (*domain) = talloc_asprintf(req, "%s", lp_workgroup(global_loadparm));
}
static void smbsrv_sesssetup_backend_send(struct smbsrv_request *req,
return False;
}
- switch (lp_server_signing()) {
+ switch (lp_server_signing(global_loadparm)) {
case SMB_SIGNING_OFF:
smb_conn->signing.allow_smb_signing = False;
break;
smb_conn->signing.mandatory_signing = True;
break;
case SMB_SIGNING_AUTO:
- if (lp_domain_logons()) {
+ if (lp_domain_logons(global_loadparm)) {
smb_conn->signing.allow_smb_signing = True;
} else {
smb_conn->signing.allow_smb_signing = False;
#include "smb_server/service_smb_proto.h"
#include "smb_server/smb2/smb2_server.h"
#include "smbd/service_stream.h"
+#include "param/param.h"
static NTSTATUS smb2srv_negprot_secblob(struct smb2srv_request *req, DATA_BLOB *_blob)
{
return NT_STATUS_NO_MEMORY;
}
- cli_credentials_set_conf(server_credentials);
+ cli_credentials_set_conf(server_credentials, global_loadparm);
nt_status = cli_credentials_set_machine_account(server_credentials);
if (!NT_STATUS_IS_OK(nt_status)) {
DEBUG(10, ("Failed to obtain server credentials, perhaps a standalone server?: %s\n", nt_errstr(nt_status)));
/* 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->negotiate.max_recv = lp_max_xmit(global_loadparm);
smb_conn->negotiate.zone_offset = get_time_zone(time(NULL));
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() < PROTOCOL_SMB2) break;
+ if (lp_srv_maxprotocol(global_loadparm) < 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);
const struct model_ops *model_ops,
const char *address)
{
- const char **ports = lp_smb_ports();
+ const char **ports = lp_smb_ports(global_loadparm);
int i;
NTSTATUS status;
task_server_set_title(task, "task[smbsrv]");
- if (lp_interfaces() && lp_bind_interfaces_only()) {
+ if (lp_interfaces(global_loadparm) && lp_bind_interfaces_only(global_loadparm)) {
int num_interfaces = iface_count();
int i;
}
} else {
/* Just bind to lp_socket_address() (usually 0.0.0.0) */
- status = smbsrv_add_socket(task->event_ctx, task->model_ops, lp_socket_address());
+ status = smbsrv_add_socket(task->event_ctx, task->model_ops,
+ lp_socket_address(global_loadparm));
if (!NT_STATUS_IS_OK(status)) goto failed;
}
pid_t ret;
char *pidFile;
- asprintf(&pidFile, "%s/%s.pid", lp_piddir(), name);
+ asprintf(&pidFile, "%s/%s.pid", lp_piddir(global_loadparm), name);
fd = open(pidFile, O_NONBLOCK | O_RDONLY, 0644);
char *pidFile;
pid_t pid;
- asprintf(&pidFile, "%s/%s.pid", lp_piddir(), name);
+ asprintf(&pidFile, "%s/%s.pid", lp_piddir(global_loadparm), name);
pid = pidfile_pid(name);
if (pid != 0) {
cleanup_tmp_files();
- if (!directory_exist(lp_lockdir())) {
- mkdir(lp_lockdir(), 0755);
+ if (!directory_exist(lp_lockdir(global_loadparm))) {
+ mkdir(lp_lockdir(global_loadparm), 0755);
}
pidfile_create(binary_name);
}
DEBUG(0,("%s: using '%s' process model\n", binary_name, model));
- status = server_service_startup(event_ctx, model, lp_server_services());
+ status = server_service_startup(event_ctx, model, lp_server_services(global_loadparm));
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Starting Services failed - %s\n", nt_errstr(status)));
return 1;
status = socket_set_option(stream_socket->sock, "SO_KEEPALIVE", NULL);
NT_STATUS_NOT_OK_RETURN(status);
- status = socket_set_option(stream_socket->sock, lp_socket_options(), NULL);
+ status = socket_set_option(stream_socket->sock, lp_socket_options(global_loadparm),
+ NULL);
NT_STATUS_NOT_OK_RETURN(status);
/* TODO: set socket ACL's here when they're implemented */
struct smbcli_state *cli;
const char *host = torture_setting_string(tctx, "host", NULL);
- make_nbt_name_client(&calling, lp_netbios_name());
+ make_nbt_name_client(&calling, lp_netbios_name(global_loadparm));
nbt_choose_called_name(NULL, &called, host, NBT_NAME_SERVER);
return False;
}
- nt_status_support = lp_nt_status_support();
+ nt_status_support = lp_nt_status_support(global_loadparm);
if (!lp_set_cmdline(global_loadparm, "nt status support", "yes")) {
torture_comment(tctx, "Could not set 'nt status support = yes'\n");
lpar->writeratio = torture_setting_int(tctx, "writeratio",5);
lpar->num_parallel_requests = torture_setting_int(
tctx, "parallel_requests", 5);
- lpar->workgroup = lp_workgroup();
+ lpar->workgroup = lp_workgroup(global_loadparm);
p = torture_setting_string(tctx, "unclist", NULL);
if (p) {
session = smbcli_session_init(cli->transport, cli, False);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
- setup.in.workgroup = lp_workgroup();
+ setup.in.workgroup = lp_workgroup(global_loadparm);
setup.in.credentials = cli_credentials_init(session);
- cli_credentials_set_conf(setup.in.credentials);
+ cli_credentials_set_conf(setup.in.credentials, global_loadparm);
cli_credentials_set_domain(setup.in.credentials, "INVALID-DOMAIN", CRED_SPECIFIED);
cli_credentials_set_username(setup.in.credentials, "INVALID-USERNAME", CRED_SPECIFIED);
cli_credentials_set_password(setup.in.credentials, "INVALID-PASSWORD", CRED_SPECIFIED);
#include "auth/credentials/credentials.h"
#include "auth/gensec/gensec.h"
#include "param/param.h"
+#include "dynconfig.h"
#define NSERVERS 2
#define NINSTANCES 2
argc -= NSERVERS;
argv += NSERVERS;
- lp_load();
+ lp_load(dyn_CONFIGFILE);
servers[0].credentials = cli_credentials_init(talloc_autofree_context());
servers[1].credentials = cli_credentials_init(talloc_autofree_context());
return False;
}
- name.string = lp_workgroup();
+ name.string = lp_workgroup(global_loadparm);
/*
* Testing synchronous version
return False;
}
- name.string = lp_workgroup();
+ name.string = lp_workgroup(global_loadparm);
/*
* Testing synchronous version
return False;
}
- domain_name.string = lp_workgroup();
+ domain_name.string = lp_workgroup(global_loadparm);
if (!test_opendomain(p, mem_ctx, &h, &domain_name, &sid)) {
ret = False;
goto done;
DEBUG(0,("Pathes under PRIVATEDIR[%s]\n"
"SAMDB[%s] SECRETS[%s] KEYTAB[%s]\n",
- lp_private_dir(),
+ lp_private_dir(global_loadparm),
s->path.samdb_ldb,
s->path.secrets_ldb,
s->path.secrets_keytab));
/* 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();
+ domain_name = lp_workgroup(global_loadparm);
ctx = libnet_context_init(NULL);
if (ctx == NULL) {
goto done;
}
- domain_name.string = lp_workgroup();
+ domain_name.string = lp_workgroup(global_loadparm);
if (!test_opendomain_lsa(p, torture, &h, &domain_name, &access_mask)) {
d_printf("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();
+ domain_name = lp_workgroup(global_loadparm);
/*
* Testing synchronous version
goto done;
}
- domain_name.string = talloc_strdup(mem_ctx, lp_workgroup());
+ domain_name.string = talloc_strdup(mem_ctx, lp_workgroup(global_loadparm));
if (!test_opendomain_samr(p, torture, &h, &domain_name, &access_mask, &sid)) {
d_printf("failed to open domain on samr service\n");
return False;
}
- domain_name.string = lp_workgroup();
+ domain_name.string = lp_workgroup(global_loadparm);
if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
ret = False;
goto done;
goto done;
}
- lookup->in.domain_name = lp_workgroup();
+ lookup->in.domain_name = lp_workgroup(global_loadparm);
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();
+ r.in.domain_name = lp_workgroup(global_loadparm);
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();
+ domain_name = lp_workgroup(global_loadparm);
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();
+ domain_name = lp_workgroup(global_loadparm);
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();
+ domain_name = lp_workgroup(global_loadparm);
return torture_rpc_connect(torture, level, NULL, domain_name);
}
ctx->cred = cmdline_credentials;
req.in.user_name = TEST_USERNAME;
- req.in.domain_name = lp_workgroup();
+ req.in.domain_name = lp_workgroup(global_loadparm);
req.out.error_string = NULL;
status = libnet_CreateUser(ctx, mem_ctx, &req);
ctx->cred = cmdline_credentials;
req.in.user_name = TEST_USERNAME;
- req.in.domain_name = lp_workgroup();
+ req.in.domain_name = lp_workgroup(global_loadparm);
status = torture_rpc_connection(torture,
&p,
goto done;
}
- domain_name.string = lp_workgroup();
+ domain_name.string = lp_workgroup(global_loadparm);
if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
ret = False;
goto done;
name = talloc_strdup(prep_mem_ctx, TEST_USERNAME);
- domain_name.string = lp_workgroup();
+ domain_name.string = lp_workgroup(global_loadparm);
if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
ret = False;
goto done;
for (fld = 1; fld < FIELDS_NUM - 1; fld++) {
ZERO_STRUCT(req);
- req.in.domain_name = lp_workgroup();
+ req.in.domain_name = lp_workgroup(global_loadparm);
req.in.user_name = name;
set_test_changes(mem_ctx, &req, 1, &name, fld);
}
ZERO_STRUCT(user_req);
- user_req.in.domain_name = lp_workgroup();
+ user_req.in.domain_name = lp_workgroup(global_loadparm);
user_req.in.user_name = name;
status = libnet_UserInfo(ctx, mem_ctx, &user_req);
/* restore original testing username - it's useful when test fails
because it prevents from problems with recreating account */
ZERO_STRUCT(req);
- req.in.domain_name = lp_workgroup();
+ req.in.domain_name = lp_workgroup(global_loadparm);
req.in.user_name = name;
req.in.account_name = TEST_USERNAME;
return False;
}
- domain_name.string = lp_workgroup();
+ domain_name.string = lp_workgroup(global_loadparm);
if (!test_opendomain(p, prep_mem_ctx, &h, &domain_name)) {
ret = False;
goto done;
ctx = libnet_context_init(NULL);
ctx->cred = cmdline_credentials;
- domain_name.string = lp_workgroup();
+ domain_name.string = lp_workgroup(global_loadparm);
mem_ctx = talloc_init("torture user list");
ZERO_STRUCT(req);
return False;
}
- name.string = lp_workgroup();
+ name.string = lp_workgroup(global_loadparm);
/*
* Testing synchronous version
return False;
}
- domain_name.string = lp_workgroup();
+ domain_name.string = lp_workgroup(global_loadparm);
if (!test_opendomain(p, mem_ctx, &h, &domain_name, &sid)) {
ret = False;
goto done;
return False;
}
- domain_name.string = lp_workgroup();
+ domain_name.string = lp_workgroup(global_loadparm);
if (!test_opendomain(p, mem_ctx, &h, &domain_name, &sid)) {
ret = False;
goto done;
goto done;
}
- domain_name.string = lp_workgroup();
+ domain_name.string = lp_workgroup(global_loadparm);
name = talloc_strdup(mem_ctx, TEST_USERNAME);
if (!test_opendomain(p, mem_ctx, &h, &domain_name, &sid)) {
#include "auth/gensec/gensec.h"
#include "libcli/libcli.h"
#include "param/param.h"
+#include "dynconfig.h"
static int numops = 1000;
static BOOL showall;
argc -= NSERVERS;
argv += NSERVERS;
- lp_load();
+ lp_load(dyn_CONFIGFILE);
servers[0] = cli_credentials_init(talloc_autofree_context());
servers[1] = cli_credentials_init(talloc_autofree_context());
argc -= 4;
argv += 4;
- lp_load();
+ lp_load(dyn_CONFIGFILE);
if (getenv("USER")) {
fstrcpy(username,getenv("USER"));
#include "auth/credentials/credentials.h"
#include "auth/gensec/gensec.h"
#include "param/param.h"
+#include "dynconfig.h"
static struct cli_credentials *credentials;
static BOOL showall = False;
argc -= 1;
argv += 1;
- lp_load();
+ lp_load(dyn_CONFIGFILE);
credentials = cli_credentials_init(talloc_autofree_context());
cli_credentials_guess(credentials);
const char *address;
struct nbt_name name;
- name.name = lp_workgroup();
+ name.name = lp_workgroup(global_loadparm);
name.type = NBT_NAME_LOGON;
name.scope = NULL;
socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- myaddress, lp_dgram_port());
+ myaddress, lp_dgram_port(global_loadparm));
torture_assert(tctx, socket_address != NULL, "Error getting address");
/* try receiving replies on port 138 first, which will only
const char *address;
struct nbt_name name;
- name.name = lp_workgroup();
+ name.name = lp_workgroup(global_loadparm);
name.type = NBT_NAME_LOGON;
name.scope = NULL;
myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- myaddress, lp_dgram_port());
+ myaddress, lp_dgram_port(global_loadparm));
torture_assert(tctx, socket_address != NULL, "Error getting address");
/* try receiving replies on port 138 first, which will only
const char *address;
struct nbt_name name;
- name.name = lp_workgroup();
+ name.name = lp_workgroup(global_loadparm);
name.type = NBT_NAME_LOGON;
name.scope = NULL;
myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
- myaddress, lp_dgram_port());
+ myaddress, lp_dgram_port(global_loadparm));
torture_assert(tctx, socket_address != NULL, "Error getting address");
/* try receiving replies on port 138 first, which will only
ACB_WSTRUST, &machine_credentials);
torture_assert(tctx, join_ctx != NULL,
talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
- lp_workgroup(), TEST_NAME));
+ lp_workgroup(global_loadparm), TEST_NAME));
dom_sid = torture_join_sid(join_ctx);
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());
+ nbt_srv_addr = socket_address_from_strings(tctx, ctx->nbtsock_srv->sock->backend_name, ctx->myaddr->addr, lp_nbt_port(global_loadparm));
if (!nbt_srv_addr) return NULL;
/* And if possible, bind to it. This won't work unless we are root or in sockewrapper */
/* Make a port 137 version of ctx->myaddr2 */
nbt_srv_addr = socket_address_from_strings(tctx,
ctx->nbtsock_srv->sock->backend_name,
- ctx->myaddr2->addr, lp_nbt_port());
+ ctx->myaddr2->addr,
+ lp_nbt_port(global_loadparm));
if (!nbt_srv_addr) return NULL;
/* And if possible, bind to it. This won't work unless we are root or in sockewrapper */
if (!ctx->nbtsock_srv) {
torture_comment(tctx, "SKIP: Test Replica records vs. owned active records: not bound to port[%d]\n",
- lp_nbt_port());
+ lp_nbt_port(global_loadparm));
return true;
}
io2.in.service_type = "A:";
io2.in.credentials = cmdline_credentials;
- io2.in.workgroup = lp_workgroup();
+ io2.in.workgroup = lp_workgroup(global_loadparm);
io2.in.filename = fname;
printf("testing parallel fetchfile with %d ops\n", torture_numops);
io1.in.service = lp_parm_string(NULL, "torture", "share");
io1.in.service_type = "A:";
io1.in.credentials = cmdline_credentials;
- io1.in.workgroup = lp_workgroup();
+ io1.in.workgroup = lp_workgroup(global_loadparm);
io1.in.level = RAW_QFS_OBJECTID_INFORMATION;
printf("testing parallel queryfsinfo [Object ID] with %d ops\n", torture_numops);
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();
+ setup.in.workgroup = lp_workgroup(global_loadparm);
setup.in.credentials = cmdline_credentials;
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();
+ setup.in.workgroup = lp_workgroup(global_loadparm);
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();
+ setup.in.workgroup = lp_workgroup(global_loadparm);
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();
+ setup.in.workgroup = lp_workgroup(global_loadparm);
anon_creds = cli_credentials_init(mem_ctx);
- cli_credentials_set_conf(anon_creds);
+ cli_credentials_set_conf(anon_creds, global_loadparm);
cli_credentials_set_anonymous(anon_creds);
setup.in.credentials = anon_creds;
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();
+ setups[i].in.workgroup = lp_workgroup(global_loadparm);
setups[i].in.credentials = cmdline_credentials;
session1 = smbcli_session_init(cli->transport, mem_ctx, False);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
- setup.in.workgroup = lp_workgroup();
+ setup.in.workgroup = lp_workgroup(global_loadparm);
setup.in.credentials = cmdline_credentials;
status = smb_composite_sesssetup(session1, &setup);
CHECK_STATUS(status, NT_STATUS_OK);
session2 = smbcli_session_init(cli->transport, mem_ctx, False);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
- setup.in.workgroup = lp_workgroup();
+ setup.in.workgroup = lp_workgroup(global_loadparm);
setup.in.credentials = cmdline_credentials;
status = smb_composite_sesssetup(session2, &setup);
CHECK_STATUS(status, NT_STATUS_OK);
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();
+ setup.in.workgroup = lp_workgroup(global_loadparm);
setup.in.credentials = cmdline_credentials;
struct smbcli_state *cli)
{
bool ret = true;
- if (lp_use_spnego()) {
+ if (lp_use_spnego(global_loadparm)) {
ret &= torture_raw_context_int(torture, cli);
lp_set_cmdline(global_loadparm, "use spnego", "False");
}
session = smbcli_session_init(cli->transport, tctx, False);
setup.in.sesskey = cli->transport->negotiate.sesskey;
setup.in.capabilities = cli->transport->negotiate.capabilities;
- setup.in.workgroup = lp_workgroup();
+ setup.in.workgroup = lp_workgroup(global_loadparm);
setup.in.credentials = cmdline_credentials;
status = smb_composite_sesssetup(session, &setup);
CHECK_STATUS(status, NT_STATUS_OK);
io->in.service_type = state->service_type;
io->in.credentials = cmdline_credentials;
io->in.fallback_to_anonymous = False;
- io->in.workgroup = lp_workgroup();
+ io->in.workgroup = lp_workgroup(global_loadparm);
/* kill off the remnants of the old connection */
talloc_free(state->tree);
io->in.service_type = state->service_type;
io->in.credentials = cmdline_credentials;
io->in.fallback_to_anonymous = False;
- io->in.workgroup = lp_workgroup();
+ io->in.workgroup = lp_workgroup(global_loadparm);
/* kill off the remnants of the old connection */
talloc_free(state->tree);
return False;
}
- nt_status_support = lp_nt_status_support();
+ nt_status_support = lp_nt_status_support(global_loadparm);
if (!lp_set_cmdline(global_loadparm, "nt status support", "yes")) {
printf("Could not set 'nt status support = yes'\n");
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());
+ names[0].str = talloc_asprintf(ctx, "%s\\", lp_workgroup(global_loadparm));
status = dcerpc_drsuapi_DsCrackNames(ctx->admin.drsuapi.pipe, ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
DATA_BLOB names_blob, chal, lm_resp, nt_resp;
int i;
int flags = CLI_CRED_NTLM_AUTH;
- if (lp_client_lanman_auth()) {
+ if (lp_client_lanman_auth(global_loadparm)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth()) {
+ if (lp_client_ntlmv2_auth(global_loadparm)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
struct netr_GetDcName r;
r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.domainname = lp_workgroup();
+ r.in.domainname = lp_workgroup(global_loadparm);
status = dcerpc_netr_GetDcName(p, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "GetDcName");
struct netr_GetAnyDCName r;
r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.domainname = lp_workgroup();
+ r.in.domainname = lp_workgroup(global_loadparm);
status = dcerpc_netr_GetAnyDCName(p, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "GetAnyDCName");
r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
r.in.function_code = NETLOGON_CONTROL_REDISCOVER;
- r.in.data.domain = lp_workgroup();
+ r.in.data.domain = lp_workgroup(global_loadparm);
for (i=1;i<4;i++) {
r.in.level = i;
}
r.in.function_code = NETLOGON_CONTROL_TC_QUERY;
- r.in.data.domain = lp_workgroup();
+ r.in.data.domain = lp_workgroup(global_loadparm);
for (i=1;i<4;i++) {
r.in.level = i;
}
r.in.function_code = NETLOGON_CONTROL_TRANSPORT_NOTIFY;
- r.in.data.domain = lp_workgroup();
+ r.in.data.domain = lp_workgroup(global_loadparm);
for (i=1;i<4;i++) {
r.in.level = i;
r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
r.in.function_code = NETLOGON_CONTROL_REDISCOVER;
- r.in.data.domain = lp_workgroup();
+ r.in.data.domain = lp_workgroup(global_loadparm);
for (i=1;i<4;i++) {
r.in.level = i;
}
r.in.function_code = NETLOGON_CONTROL_TC_QUERY;
- r.in.data.domain = lp_workgroup();
+ r.in.data.domain = lp_workgroup(global_loadparm);
for (i=1;i<4;i++) {
r.in.level = i;
}
r.in.function_code = NETLOGON_CONTROL_TRANSPORT_NOTIFY;
- r.in.data.domain = lp_workgroup();
+ r.in.data.domain = lp_workgroup(global_loadparm);
for (i=1;i<4;i++) {
r.in.level = i;
struct netr_DsRGetDCName r;
r.in.server_unc = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.domain_name = talloc_asprintf(tctx, "%s", lp_realm());
+ r.in.domain_name = talloc_asprintf(tctx, "%s", lp_realm(global_loadparm));
r.in.domain_guid = NULL;
r.in.site_guid = NULL;
r.in.flags = DS_RETURN_DNS_NAME;
struct netr_DsRGetDCNameEx r;
r.in.server_unc = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.domain_name = talloc_asprintf(tctx, "%s", lp_realm());
+ r.in.domain_name = talloc_asprintf(tctx, "%s", lp_realm(global_loadparm));
r.in.domain_guid = NULL;
r.in.site_name = NULL;
r.in.flags = DS_RETURN_DNS_NAME;
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 = talloc_asprintf(tctx, "%s", lp_realm());
+ r.in.domain_name = talloc_asprintf(tctx, "%s", lp_realm(global_loadparm));
r.in.domain_guid = NULL;
r.in.site_name = NULL;
r.in.flags = DS_RETURN_DNS_NAME;
return NULL;
}
- cli_credentials_set_conf(result);
+ cli_credentials_set_conf(result, global_loadparm);
cli_credentials_set_anonymous(result);
return result;
goto done;
}
- cli_credentials_set_conf(wks_creds);
+ cli_credentials_set_conf(wks_creds, global_loadparm);
cli_credentials_set_secure_channel_type(wks_creds, SEC_CHAN_WKSTA);
cli_credentials_set_username(wks_creds, wks_name, CRED_SPECIFIED);
cli_credentials_set_workstation(wks_creds, wks_name, CRED_SPECIFIED);
goto done;
}
- cli_credentials_set_conf(wks_creds);
+ cli_credentials_set_conf(wks_creds, global_loadparm);
cli_credentials_set_secure_channel_type(wks_creds, SEC_CHAN_WKSTA);
cli_credentials_set_username(wks_creds, wks_name, CRED_SPECIFIED);
cli_credentials_set_workstation(wks_creds, wks_name, CRED_SPECIFIED);
goto done;
}
- cli_credentials_set_conf(user_creds);
+ cli_credentials_set_conf(user_creds, global_loadparm);
cli_credentials_set_username(user_creds, "torture_username",
CRED_SPECIFIED);
cli_credentials_set_password(user_creds,
ZERO_STRUCT(userlevel1);
userlevel1.client = talloc_asprintf(
- mem_ctx, "\\\\%s", lp_netbios_name());
+ mem_ctx, "\\\\%s", lp_netbios_name(global_loadparm));
userlevel1.user = cli_credentials_get_username(cmdline_credentials);
userlevel1.build = 2600;
userlevel1.major = 3;
DATA_BLOB lmv2_response = data_blob(NULL, 0);
DATA_BLOB lmv2_session_key = data_blob(NULL, 0);
DATA_BLOB ntlmv2_session_key = data_blob(NULL, 0);
- DATA_BLOB names_blob = NTLMv2_generate_names_blob(samlogon_state->mem_ctx, TEST_MACHINE_NAME, lp_workgroup());
+ DATA_BLOB names_blob = NTLMv2_generate_names_blob(samlogon_state->mem_ctx, TEST_MACHINE_NAME, lp_workgroup(global_loadparm));
uint8_t lm_session_key[8];
uint8_t user_session_key[16];
DATA_BLOB lmv2_response = data_blob(NULL, 0);
DATA_BLOB lmv2_session_key = data_blob(NULL, 0);
DATA_BLOB ntlmv2_session_key = data_blob(NULL, 0);
- DATA_BLOB names_blob = NTLMv2_generate_names_blob(samlogon_state->mem_ctx, lp_netbios_name(), lp_workgroup());
+ DATA_BLOB names_blob = NTLMv2_generate_names_blob(samlogon_state->mem_ctx, lp_netbios_name(global_loadparm), lp_workgroup(global_loadparm));
DATA_BLOB ntlm_response = data_blob_talloc(samlogon_state->mem_ctx, NULL, 24);
DATA_BLOB ntlm_session_key = data_blob_talloc(samlogon_state->mem_ctx, NULL, 16);
return False;
}
- userdomain = torture_setting_string(torture, "userdomain", lp_workgroup());
+ userdomain = torture_setting_string(torture, "userdomain", lp_workgroup(global_loadparm));
user_ctx = torture_create_testuser(torture,
TEST_USER_NAME,
.username = talloc_asprintf(mem_ctx,
"%s@%s",
TEST_USER_NAME,
- lp_realm()),
+ lp_realm(global_loadparm)),
.password = user_password,
.network_login = True,
.expected_interactive_error = NT_STATUS_OK,
ld.in.connect_handle = &ch;
ld.in.domain_name = &dn;
- dn.string = lp_workgroup();
+ dn.string = lp_workgroup(global_loadparm);
status = dcerpc_samr_LookupDomain(p, tctx, &ld);
if (!NT_STATUS_IS_OK(status)) {
ld.in.connect_handle = &ch;
ld.in.domain_name = &dn;
- dn.string = lp_workgroup();
+ dn.string = lp_workgroup(global_loadparm);
status = dcerpc_samr_LookupDomain(p, tctx, &ld);
if(!NT_STATUS_EQUAL(NT_STATUS_ACCESS_DENIED, status)) {
ld.in.connect_handle = &ch;
ld.in.domain_name = &dn;
- dn.string = lp_workgroup();
+ dn.string = lp_workgroup(global_loadparm);
status = dcerpc_samr_LookupDomain(p, tctx, &ld);
if (!NT_STATUS_IS_OK(status)) {
printf("LookupDomain failed - %s\n", nt_errstr(status));
const struct dom_sid *test_sid;
/* create a test user */
- testuser = torture_create_testuser(tctx, TEST_USER_NAME, lp_workgroup(), ACB_NORMAL, &testuser_passwd);
+ testuser = torture_create_testuser(tctx, TEST_USER_NAME, lp_workgroup(global_loadparm),
+ ACB_NORMAL, &testuser_passwd);
if (!testuser) {
printf("Failed to create test user\n");
return False;
}
test_credentials = cli_credentials_init(tctx);
cli_credentials_set_workstation(test_credentials, "localhost", CRED_SPECIFIED);
- cli_credentials_set_domain(test_credentials, lp_workgroup(), CRED_SPECIFIED);
+ cli_credentials_set_domain(test_credentials, lp_workgroup(global_loadparm),
+ CRED_SPECIFIED);
cli_credentials_set_username(test_credentials, TEST_USER_NAME, CRED_SPECIFIED);
cli_credentials_set_password(test_credentials, testuser_passwd, CRED_SPECIFIED);
test_sid = torture_join_user_sid(testuser);
mem_ctx = talloc_init("torture_rpc_netlogon");
test_machine_account = talloc_asprintf(mem_ctx, "%s$", TEST_MACHINE_NAME);
- join_ctx = torture_create_testuser(torture, test_machine_account, lp_workgroup(), ACB_SVRTRUST,
+ join_ctx = torture_create_testuser(torture, test_machine_account,
+ lp_workgroup(global_loadparm), 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(), ACB_WSTRUST,
- &wksta_machine_password);
+ join_ctx2 = torture_create_testuser(torture, test_wksta_machine_account, lp_workgroup(global_loadparm), ACB_WSTRUST, &wksta_machine_password);
if (!join_ctx2) {
talloc_free(mem_ctx);
printf("Failed to join as member\n");
}
user_ctx = torture_create_testuser(torture, TEST_USER_NAME,
- lp_workgroup(),
+ lp_workgroup(global_loadparm),
ACB_NORMAL, NULL);
if (!user_ctx) {
talloc_free(mem_ctx);
goto failed;
}
- domain_policy = samsync_open_domain(mem_ctx, samsync_state, lp_workgroup(), NULL);
+ domain_policy = samsync_open_domain(mem_ctx, samsync_state, lp_workgroup(global_loadparm), NULL);
if (!domain_policy) {
printf("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(), CRED_SPECIFIED);
+ cli_credentials_set_domain(credentials, lp_workgroup(global_loadparm), 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(), CRED_SPECIFIED);
+ cli_credentials_set_domain(credentials_wksta, lp_workgroup(global_loadparm), 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,
DATA_BLOB names_blob, chal, lm_resp, nt_resp;
int i;
int flags = CLI_CRED_NTLM_AUTH;
- if (lp_client_lanman_auth()) {
+ if (lp_client_lanman_auth(global_loadparm)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth()) {
+ if (lp_client_ntlmv2_auth(global_loadparm)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
struct policy_handle handle;
struct policy_handle domain_handle;
- name.string = lp_workgroup();
+ name.string = lp_workgroup(global_loadparm);
r.in.domain_name = &name;
connect.in.system_name = 0;
u.info21.description.string = talloc_asprintf(join,
"Samba4 torture account created by host %s: %s",
- lp_netbios_name(), timestring(join, time(NULL)));
+ lp_netbios_name(global_loadparm),
+ timestring(join, time(NULL)));
printf("Resetting ACB flags, force pw change time\n");
u.info21.description.string = talloc_asprintf(tj,
"Samba4 torture account created by host %s: %s",
- lp_netbios_name(), timestring(tj, time(NULL)));
+ lp_netbios_name(global_loadparm), timestring(tj, time(NULL)));
status = dcerpc_samr_SetUserInfo(tj->p, tj, &s);
if (!NT_STATUS_IS_OK(status)) {
}
*machine_credentials = cli_credentials_init(tj);
- cli_credentials_set_conf(*machine_credentials);
+ cli_credentials_set_conf(*machine_credentials, global_loadparm);
cli_credentials_set_workstation(*machine_credentials, machine_name, CRED_SPECIFIED);
cli_credentials_set_domain(*machine_credentials, libnet_r->out.domain_name, CRED_SPECIFIED);
if (libnet_r->out.realm) {
if (flags & STR_TERMINATE) len++;
server_unicode = (transport->negotiate.capabilities&CAP_UNICODE)?True:False;
- if (getenv("CLI_FORCE_ASCII") || !lp_unicode()) {
+ if (getenv("CLI_FORCE_ASCII") || !lp_unicode(global_loadparm)) {
server_unicode = False;
}
separator = torture_setting_string(torture,
"winbindd separator",
- lp_winbind_separator());
+ lp_winbind_separator(global_loadparm));
torture_assert_int_equal(torture,
rep.data.info.winbind_separator,
*separator,
expected = torture_setting_string(torture,
"winbindd netbios name",
- lp_netbios_name());
+ lp_netbios_name(global_loadparm));
torture_assert_str_equal(torture,
rep.data.netbios_name, expected,
expected = torture_setting_string(torture,
"winbindd netbios domain",
- lp_workgroup());
+ lp_workgroup(global_loadparm));
torture_assert_str_equal(torture,
rep.data.domain_name, expected,
return -1;
}
/* prepare parameters for the join */
- r->in.netbios_name = lp_netbios_name();
+ r->in.netbios_name = lp_netbios_name(global_loadparm);
r->in.domain_name = domain_name;
r->in.join_type = secure_channel_type;
r->in.level = LIBNET_JOIN_AUTOMATIC;
fstring user)
{
- char *p = strchr(domuser,*lp_winbind_separator());
+ char *p = strchr(domuser,*lp_winbind_separator(global_loadparm));
if (!p) {
return False;
if (unix_name) {
asprintf(unix_name,
"%s%c%s", domain,
- *lp_winbind_separator(),
+ *lp_winbind_separator(global_loadparm),
username);
}
} else {
}
creds = cli_credentials_init(state->gensec_state);
- cli_credentials_set_conf(creds);
+ cli_credentials_set_conf(creds, global_loadparm);
if (opt_username) {
cli_credentials_set_username(creds, opt_username, CRED_SPECIFIED);
}
reply_code = "AF";
reply_arg = talloc_asprintf(state->gensec_state,
"%s%s%s", session_info->server_info->domain_name,
- lp_winbind_separator(), session_info->server_info->account_name);
+ lp_winbind_separator(global_loadparm), 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(), username) == -1) {
+ if (asprintf(&full_username, "%s%c%s", domain, *lp_winbind_separator(global_loadparm), username) == -1) {
mux_printf(mux_id, "Error: Out of memory in asprintf!\n.\n");
return;
}
}
if (!domain) {
- domain = smb_xstrdup(lp_workgroup());
+ domain = smb_xstrdup(lp_workgroup(global_loadparm));
}
if (ntlm_server_1_lm_session_key)
if (!NT_STATUS_IS_OK(
local_pw_check_specified(username,
domain,
- lp_netbios_name(),
+ lp_netbios_name(global_loadparm),
&challenge,
&lm_response,
&nt_response,
gensec_init();
if (opt_domain == NULL) {
- opt_domain = lp_workgroup();
+ opt_domain = lp_workgroup(global_loadparm);
}
if (helper_protocol) {
}
if (opt_workstation == NULL) {
- opt_workstation = lp_netbios_name();
+ opt_workstation = lp_netbios_name(global_loadparm);
}
if (!opt_password) {
{
char *user;
- asprintf(&user, "%s%c%s", opt_domain, *lp_winbind_separator(), opt_username);
+ asprintf(&user, "%s%c%s", opt_domain, *lp_winbind_separator(global_loadparm), opt_username);
if (!check_plaintext_auth(user, opt_password, True)) {
return 1;
}
configuration settings.
************************************************/
-static int do_global_checks(void)
+static int do_global_checks(struct loadparm_context *lp_ctx)
{
int ret = 0;
- if (!directory_exist(lp_lockdir())) {
+ if (!directory_exist(lp_lockdir(lp_ctx))) {
fprintf(stderr, "ERROR: lock directory %s does not exist\n",
- lp_lockdir());
+ lp_lockdir(lp_ctx));
ret = 1;
}
- if (!directory_exist(lp_piddir())) {
+ if (!directory_exist(lp_piddir(lp_ctx))) {
fprintf(stderr, "ERROR: pid directory %s does not exist\n",
- lp_piddir());
+ lp_piddir(lp_ctx));
ret = 1;
}
- if (strlen(lp_winbind_separator()) != 1) {
+ if (strlen(lp_winbind_separator(lp_ctx)) != 1) {
fprintf(stderr,"ERROR: the 'winbind separator' parameter must be a single character.\n");
ret = 1;
}
- if (*lp_winbind_separator() == '+') {
+ if (*lp_winbind_separator(lp_ctx) == '+') {
fprintf(stderr,"'winbind separator = +' might cause problems with group membership.\n");
}
/* We need this to force the output */
lp_set_cmdline(global_loadparm, "log level", "2");
- fprintf(stderr,"Load smb config files from %s\n",lp_configfile());
+ fprintf(stderr, "Loaded smb config files from %s\n", lp_configfile(global_loadparm));
- if (!lp_load()) {
+ if (!lp_load(lp_configfile(global_loadparm))) {
fprintf(stderr,"Error loading services.\n");
return(1);
}
fprintf(stderr,"Loaded services file OK.\n");
- ret = do_global_checks();
+ ret = do_global_checks(global_loadparm);
for (s=0;s<lp_numservices(global_loadparm);s++) {
struct loadparm_service *service = lp_servicebynum(global_loadparm, s);
int *len,
const char *path)
{
- return http_readFile(handle, buf, len, path, lp_swat_directory());
+ return http_readFile(handle, buf, len, path, lp_swat_directory(global_loadparm));
}
const char *path;
struct stat st;
- path = http_local_path(web, url, lp_swat_directory());
+ path = http_local_path(web, url, lp_swat_directory(global_loadparm));
if (path == NULL) goto invalid;
/* looks ok */
talloc_asprintf(esp, "%u", socket_address->port));
}
- SETVAR(ESP_SERVER_OBJ, "DOCUMENT_ROOT", lp_swat_directory());
+ SETVAR(ESP_SERVER_OBJ, "DOCUMENT_ROOT", lp_swat_directory(global_loadparm));
SETVAR(ESP_SERVER_OBJ, "SERVER_PROTOCOL", tls_enabled(web->conn->socket)?"https":"http");
SETVAR(ESP_SERVER_OBJ, "SERVER_SOFTWARE", "SAMBA");
SETVAR(ESP_SERVER_OBJ, "GATEWAY_INTERFACE", "CGI/1.1");
int res;
char *emsg = NULL, *buf;
- if (http_readFile(web, &buf, &size, url, lp_swat_directory()) != 0) {
+ if (http_readFile(web, &buf, &size, url, lp_swat_directory(global_loadparm)) != 0) {
http_error_unix(web, url);
return;
}
{
const char *path = http_local_path(esp->web,
HTTP_PREAUTH_URI,
- lp_swat_directory());
+ lp_swat_directory(global_loadparm));
int i;
if (path == NULL) {
http_error(esp->web, 500, "Internal server error");
static void websrv_task_init(struct task_server *task)
{
NTSTATUS status;
- uint16_t port = lp_web_port();
+ uint16_t port = lp_web_port(global_loadparm);
const struct model_ops *model_ops;
task_server_set_title(task, "task[websrv]");
model_ops = process_model_byname("single");
if (!model_ops) goto failed;
- if (lp_interfaces() && lp_bind_interfaces_only()) {
+ if (lp_interfaces(global_loadparm) && lp_bind_interfaces_only(global_loadparm)) {
int num_interfaces = iface_count();
int i;
for(i = 0; i < num_interfaces; i++) {
} else {
status = stream_setup_socket(task->event_ctx, model_ops,
&web_stream_ops,
- "ipv4", lp_socket_address(),
+ "ipv4", lp_socket_address(global_loadparm),
&port, task);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
WBSRV_SAMBA3_SET_STRING(pw->pw_name, user_info->out.account_name);
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());
+ WBSRV_SAMBA3_SET_STRING(pw->pw_dir, lp_template_homedir(global_loadparm));
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());
+ WBSRV_SAMBA3_SET_STRING(pw->pw_shell, lp_template_shell(global_loadparm));
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_name, user_info->out.account_name);
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());
+ WBSRV_SAMBA3_SET_STRING(pw->pw_dir, lp_template_homedir(global_loadparm));
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());
+ WBSRV_SAMBA3_SET_STRING(pw->pw_shell, lp_template_shell(global_loadparm));
pw->pw_uid = state->uid;
if (dom_sid == NULL) goto failed;
ctx = finddcs_send(mem_ctx, domain_name, NBT_NAME_LOGON,
- dom_sid, lp_name_resolve_order(), service->task->event_ctx,
+ dom_sid, lp_name_resolve_order(global_loadparm),
+ service->task->event_ctx,
service->task->msg_ctx);
if (ctx == NULL) goto failed;
make_nbt_name(&name, state->info->dcs[0].name, 0x20);
ctx = resolve_name_send(&name, state->service->task->event_ctx,
- lp_name_resolve_order());
+ lp_name_resolve_order(global_loadparm));
composite_continue(state->ctx, ctx, trusted_dom_info_recv_dcaddr,
state);
cli_credentials_set_event_context(state->domain->libnet_ctx->cred, service->task->event_ctx);
- cli_credentials_set_conf(state->domain->libnet_ctx->cred);
+ cli_credentials_set_conf(state->domain->libnet_ctx->cred, global_loadparm);
/* Connect the machine account to the credentials */
state->ctx->status =
state->domain->netlogon_pipe = NULL;
if ((!cli_credentials_is_anonymous(state->domain->libnet_ctx->cred)) &&
- ((lp_server_role() == ROLE_DOMAIN_MEMBER) ||
- (lp_server_role() == ROLE_DOMAIN_CONTROLLER)) &&
+ ((lp_server_role(global_loadparm) == ROLE_DOMAIN_MEMBER) ||
+ (lp_server_role(global_loadparm) == 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()) {
+ if (lp_winbind_sealed_pipes(global_loadparm)) {
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()) {
+ if (lp_winbind_sealed_pipes(global_loadparm)) {
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(),
+ lp_winbind_separator(global_loadparm),
state->user_name);
if (composite_nomem(state->unix_username, state->ctx)) return;
DATA_BLOB chal, nt_resp, lm_resp, names_blob;
int flags = CLI_CRED_NTLM_AUTH;
- if (lp_client_lanman_auth()) {
+ if (lp_client_lanman_auth(global_loadparm)) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth()) {
+ if (lp_client_ntlmv2_auth(global_loadparm)) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
if (!credentials) {
return NULL;
}
- cli_credentials_set_conf(credentials);
+ cli_credentials_set_conf(credentials, global_loadparm);
cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
cli_credentials_set_username(credentials, user, CRED_SPECIFIED);
NTSTATUS wbsrv_samba3_info(struct wbsrv_samba3_call *s3call)
{
s3call->response.result = WINBINDD_OK;
- s3call->response.data.info.winbind_separator = *lp_winbind_separator();
+ s3call->response.data.info.winbind_separator = *lp_winbind_separator(global_loadparm);
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());
+ lp_workgroup(global_loadparm));
return NT_STATUS_OK;
}
{
s3call->response.result = WINBINDD_OK;
WBSRV_SAMBA3_SET_STRING(s3call->response.data.netbios_name,
- lp_netbios_name());
+ lp_netbios_name(global_loadparm));
return NT_STATUS_OK;
}
}
/* Make sure the directory for the Samba3 socket exists, and is of the correct permissions */
- if (!directory_create_or_exist(lp_winbindd_socket_directory(), geteuid(), 0755)) {
+ if (!directory_create_or_exist(lp_winbindd_socket_directory(global_loadparm), geteuid(), 0755)) {
task_server_terminate(task,
"Cannot create winbindd pipe directory");
return;
service->task = task;
service->primary_sid = secrets_get_domain_sid(service,
- lp_workgroup());
+ lp_workgroup(global_loadparm));
if (service->primary_sid == NULL) {
task_server_terminate(
task, nt_errstr(NT_STATUS_CANT_ACCESS_DOMAIN_INFO));
listen_socket = talloc(service, struct wbsrv_listen_socket);
if (!listen_socket) goto nomem;
listen_socket->socket_path = talloc_asprintf(listen_socket, "%s/%s",
- lp_winbindd_socket_directory(),
+ lp_winbindd_socket_directory(global_loadparm),
WINBINDD_SAMBA3_SOCKET);
if (!listen_socket->socket_path) goto nomem;
listen_socket->service = service;
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(),
+ ctx = wb_get_dom_info_send(state, service, lp_workgroup(global_loadparm),
service->primary_sid);
if (ctx == NULL) goto failed;
ctx->async.fn = sid2domain_recv_dom_info;
BOOL wb_samba3_split_username(TALLOC_CTX *mem_ctx, const char *domuser,
char **domain, char **user)
{
- char *p = strchr(domuser, *lp_winbind_separator());
+ char *p = strchr(domuser, *lp_winbind_separator(global_loadparm));
if (p == NULL) {
- *domain = talloc_strdup(mem_ctx, lp_workgroup());
+ *domain = talloc_strdup(mem_ctx, lp_workgroup(global_loadparm));
} else {
*domain = talloc_strndup(mem_ctx, domuser,
PTR_DIFF(p, domuser));
return NT_STATUS_INTERNAL_ERROR;
}
- if (lp_interfaces() && lp_bind_interfaces_only()) {
+ if (lp_interfaces(global_loadparm) && lp_bind_interfaces_only(global_loadparm)) {
int num_interfaces = iface_count();
int i;
}
}
} else {
- address = lp_socket_address();
+ address = lp_socket_address(global_loadparm);
status = stream_setup_socket(task->event_ctx, model_ops, &wreplsrv_stream_ops,
"ipv4", address, &port, service);
if (!NT_STATUS_IS_OK(status)) {
static struct ldb_context *wins_config_db_connect(TALLOC_CTX *mem_ctx)
{
- return ldb_wrap_connect(mem_ctx, private_path(mem_ctx, lp_wins_config_url()),
+ return ldb_wrap_connect(mem_ctx, private_path(mem_ctx,
+ lp_wins_config_url(global_loadparm)),
system_session(mem_ctx), NULL, 0, NULL);
}
*/
static NTSTATUS wreplsrv_init(struct event_context *event_ctx, const struct model_ops *model_ops)
{
- if (!lp_wins_support()) {
+ if (!lp_wins_support(global_loadparm)) {
return NT_STATUS_OK;
}
git.samba.org / amitay / samba.git / commitdiff