NTSTATUS status;
/* listen for unicasts on the CLDAP port (389) */
- cldapsock = cldap_socket_init(cldapd, cldapd->task->event_ctx);
+ cldapsock = cldap_socket_init(cldapd, cldapd->task->event_ctx, lp_iconv_convenience(cldapd->task->lp_ctx));
NT_STATUS_HAVE_NO_MEMORY(cldapsock);
socket_address = socket_address_from_strings(cldapsock, cldapsock->sock->backend_name,
krb5_error_code hdb_ldb_create(krb5_context context, struct HDB **db, const char *arg)
{
NTSTATUS nt_status;
- /* The global kdc_mem_ctx, Disgusting, ugly hack, but it means one less private hook */
- nt_status = kdc_hdb_ldb_create(kdc_mem_ctx, global_loadparm,
+ /* The global kdc_mem_ctx and kdc_lp_ctx, Disgusting, ugly hack, but it means one less private hook */
+ nt_status = kdc_hdb_ldb_create(kdc_mem_ctx, kdc_lp_ctx,
context, db, arg);
if (NT_STATUS_IS_OK(nt_status)) {
#include "param/param.h"
-/* Disgusting hack to get a mem_ctx into the hdb plugin, when used as a keytab */
+/* Disgusting hack to get a mem_ctx and lp_ctx into the hdb plugin, when
+ * used as a keytab */
TALLOC_CTX *kdc_mem_ctx;
+struct loadparm_context *kdc_lp_ctx;
/* hold all the info needed to send a reply */
struct kdc_reply {
krb5_kdc_windc_init(kdc->smb_krb5_context->krb5_context);
kdc_mem_ctx = kdc->smb_krb5_context;
+ kdc_lp_ctx = task->lp_ctx;
/* start listening on the configured network interfaces */
status = kdc_startup_interfaces(kdc, task->lp_ctx, ifaces);
struct socket_address;
extern TALLOC_CTX *kdc_mem_ctx;
+extern struct loadparm_context *kdc_lp_ctx;
bool kpasswdd_process(struct kdc_server *kdc,
TALLOC_CTX *mem_ctx,
*/
#include "miniMpr.h"
+#include "param/param.h"
/************************************ Code ************************************/
#if !BLD_APPWEB
return mpr_ctx;
}
+/* return the loadparm context being used for all ejs variables */
+struct loadparm_context *mprLpCtx(void)
+{
+ return global_loadparm;
+}
+
void mprFree(void *ptr)
{
talloc_free(ptr);
extern void mprSetCtx(void *ctx);
extern void *mprMemCtx(void);
+struct loadparm_context;
+extern struct loadparm_context *mprLpCtx(void);
/* This function needs to be provided by anyone using ejs */
void ejs_exception(const char *reason);
#include "includes.h"
#include "hive.h"
#include "system/filesys.h"
+#include "param/param.h"
/** Open a registry file/host/etc */
_PUBLIC_ WERROR reg_open_hive(TALLOC_CTX *parent_ctx, const char *location,
if (!strncmp(peek, "regf", 4)) {
close(fd);
- return reg_open_regf_file(parent_ctx, location, lp_ctx, root);
+ return reg_open_regf_file(parent_ctx, location, lp_iconv_convenience(lp_ctx), root);
} else if (!strncmp(peek, "TDB file", 8)) {
close(fd);
return reg_open_ldb_file(parent_ctx, location, session_info,
WERROR reg_open_directory(TALLOC_CTX *parent_ctx,
const char *location, struct hive_key **key);
WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx,
- const char *location, struct loadparm_context *lp_ctx,
+ const char *location, struct smb_iconv_convenience *iconv_convenience,
struct hive_key **key);
WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location,
struct auth_session_info *session_info,
WERROR reg_create_directory(TALLOC_CTX *parent_ctx,
const char *location, struct hive_key **key);
WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
const char *location,
int major_version,
struct hive_key **key);
int subkey_count, value_count;
};
-static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx, struct ldb_message *msg,
+static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ struct ldb_message *msg,
const char **name, uint32_t *type,
DATA_BLOB *data)
{
{
case REG_SZ:
case REG_EXPAND_SZ:
- data->length = convert_string_talloc(mem_ctx, lp_iconv_convenience(global_loadparm), CH_UTF8, CH_UTF16,
+ data->length = convert_string_talloc(mem_ctx, iconv_convenience, CH_UTF8, CH_UTF16,
val->data, val->length,
(void **)&data->data);
break;
if (idx >= kd->value_count)
return WERR_NO_MORE_ITEMS;
- reg_ldb_unpack_value(mem_ctx, kd->values[idx],
+ reg_ldb_unpack_value(mem_ctx, lp_iconv_convenience(global_loadparm), kd->values[idx],
name, data_type, data);
return WERR_OK;
if (res->count == 0)
return WERR_BADFILE;
- reg_ldb_unpack_value(mem_ctx, res->msgs[0], NULL, data_type, data);
+ reg_ldb_unpack_value(mem_ctx, lp_iconv_convenience(global_loadparm), res->msgs[0], NULL, data_type, data);
return WERR_OK;
}
if (max_valbufsize != NULL) {
DATA_BLOB data;
- reg_ldb_unpack_value(mem_ctx, kd->values[i], NULL,
+ reg_ldb_unpack_value(mem_ctx,
+ lp_iconv_convenience(global_loadparm),
+ kd->values[i], NULL,
NULL, &data);
*max_valbufsize = MAX(*max_valbufsize, data.length);
talloc_free(data.data);
_PUBLIC_ WERROR reg_preg_diff_load(int fd,
+ struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data);
* Load diff file
*/
_PUBLIC_ WERROR reg_diff_load(const char *filename,
+ struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data)
{
#endif
if (strncmp(hdr, "PReg", 4) == 0) {
/* Must be a GPO Registry.pol file */
- return reg_preg_diff_load(fd, callbacks, callback_data);
+ return reg_preg_diff_load(fd, iconv_convenience, callbacks, callback_data);
} else {
/* Must be a normal .REG file */
- return reg_dotreg_diff_load(fd, lp_iconv_convenience(global_loadparm), callbacks, callback_data);
+ return reg_dotreg_diff_load(fd, iconv_convenience, callbacks, callback_data);
}
}
callbacks.del_all_values = reg_diff_apply_del_all_values;
callbacks.done = NULL;
- return reg_diff_load(filename, &callbacks, ctx);
+ return reg_diff_load(filename, lp_iconv_convenience(global_loadparm),
+ &callbacks, ctx);
}
const struct reg_diff_callbacks *callbacks,
void *callback_data);
WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
+ struct smb_iconv_convenience *iconv_convenience,
struct reg_diff_callbacks **callbacks,
void **callback_data);
WERROR reg_generate_diff_key(struct registry_key *oldkey,
* Save registry diff
*/
_PUBLIC_ WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
+ struct smb_iconv_convenience *iconv_convenience,
struct reg_diff_callbacks **callbacks,
void **callback_data)
{
data = talloc_zero(ctx, struct dotreg_data);
*callback_data = data;
- data->iconv_convenience = lp_iconv_convenience(global_loadparm);
+ data->iconv_convenience = iconv_convenience;
if (filename) {
data->fd = open(filename, O_CREAT, 0755);
int fd;
};
-static WERROR preg_read_utf16(int fd, char *c)
+static WERROR preg_read_utf16(struct smb_iconv_convenience *ic, int fd, char *c)
{
uint16_t v;
if (read(fd, &v, 2) < 2) {
return WERR_GENERAL_FAILURE;
}
- push_codepoint(lp_iconv_convenience(global_loadparm), c, v);
+ push_codepoint(ic, c, v);
return WERR_OK;
}
* Load diff file
*/
_PUBLIC_ WERROR reg_preg_diff_load(int fd,
+ struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data)
{
while(1) {
uint32_t value_type, length;
- if (!W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr))) {
+ if (!W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr))) {
break;
}
if (*buf_ptr != '[') {
/* Get the path */
buf_ptr = buf;
- while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+ while (W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr)) &&
*buf_ptr != ';' && buf_ptr-buf < buf_size) {
buf_ptr++;
}
/* Get the name */
buf_ptr = buf;
- while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+ while (W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr)) &&
*buf_ptr != ';' && buf_ptr-buf < buf_size) {
buf_ptr++;
}
}
/* Read past delimiter */
buf_ptr = buf;
- if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+ if (!(W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr)) &&
*buf_ptr == ';') && buf_ptr-buf < buf_size) {
DEBUG(0, ("Error in PReg file.\n"));
ret = WERR_GENERAL_FAILURE;
}
/* Read past delimiter */
buf_ptr = buf;
- if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+ if (!(W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr)) &&
*buf_ptr == ';') && buf_ptr-buf < buf_size) {
DEBUG(0, ("Error in PReg file.\n"));
ret = WERR_GENERAL_FAILURE;
/* Check if delimiter is in place (whine if it isn't) */
buf_ptr = buf;
- if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+ if (!(W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr)) &&
*buf_ptr == ']') && buf_ptr-buf < buf_size) {
DEBUG(0, ("Warning: Missing ']' in PReg file, expected ']', got '%c' 0x%x.\n",
*buf_ptr, *buf_ptr));
return WERR_OK;
}
-WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx, const char *location,
+WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ const char *location,
int minor_version, struct hive_key **key)
{
struct regf_data *regf;
regf = (struct regf_data *)talloc_zero(NULL, struct regf_data);
- regf->iconv_convenience = lp_iconv_convenience(global_loadparm);
+ regf->iconv_convenience = iconv_convenience;
W_ERROR_HAVE_NO_MEMORY(regf);
}
WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx, const char *location,
- struct loadparm_context *lp_ctx, struct hive_key **key)
+ struct smb_iconv_convenience *iconv_convenience, struct hive_key **key)
{
struct regf_data *regf;
struct regf_hdr *regf_hdr;
regf = (struct regf_data *)talloc_zero(NULL, struct regf_data);
- regf->iconv_convenience = lp_iconv_convenience(lp_ctx);
+ regf->iconv_convenience = iconv_convenience;
W_ERROR_HAVE_NO_MEMORY(regf);
#include "torture/torture.h"
#include "librpc/gen_ndr/winreg.h"
#include "system/filesys.h"
+#include "param/param.h"
static bool test_del_nonexistant_key(struct torture_context *tctx,
const void *test_data)
rmdir(dirname);
- error = reg_create_regf_file(tctx, dirname, 5, &key);
+ error = reg_create_regf_file(tctx, lp_iconv_convenience(tctx->lp_ctx),
+ dirname, 5, &key);
if (!W_ERROR_IS_OK(error)) {
fprintf(stderr, "Unable to create new regf file\n");
return false;
poptFreeContext(pc);
- error = reg_dotreg_diff_save(ctx, outputfile, &callbacks,
+ error = reg_dotreg_diff_save(ctx, outputfile, lp_iconv_convenience(cmdline_lp_ctx), &callbacks,
&callback_data);
if (!W_ERROR_IS_OK(error)) {
fprintf(stderr, "Problem saving registry diff to '%s': %s\n",
then operations will use that event context
*/
struct cldap_socket *cldap_socket_init(TALLOC_CTX *mem_ctx,
- struct event_context *event_ctx)
+ struct event_context *event_ctx,
+ struct smb_iconv_convenience *iconv_convenience)
{
struct cldap_socket *cldap;
NTSTATUS status;
cldap->send_queue = NULL;
cldap->incoming.handler = NULL;
+ cldap->iconv_convenience = iconv_convenience;
return cldap;
data = search.out.response->attributes[0].values;
ndr_err = ndr_pull_union_blob_all(data, mem_ctx,
- lp_iconv_convenience(global_loadparm),
+ req->cldap->iconv_convenience,
&io->out.netlogon,
io->in.version & 0xF,
(ndr_pull_flags_fn_t)ndr_pull_nbt_cldap_netlogon);
DATA_BLOB blob;
ndr_err = ndr_push_union_blob(&blob, tmp_ctx,
- lp_iconv_convenience(global_loadparm),
+ cldap->iconv_convenience,
netlogon, version & 0xF,
(ndr_push_flags_fn_t)ndr_push_nbt_cldap_netlogon);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
struct cldap_socket {
struct socket_context *sock;
struct event_context *event_ctx;
+ struct smb_iconv_convenience *iconv_convenience;
/* the fd event */
struct fd_event *fde;
};
struct cldap_socket *cldap_socket_init(TALLOC_CTX *mem_ctx,
- struct event_context *event_ctx);
+ struct event_context *event_ctx,
+ struct smb_iconv_convenience *iconv_convenience);
NTSTATUS cldap_set_incoming_handler(struct cldap_socket *cldap,
void (*handler)(struct cldap_socket *, struct ldap_message *,
struct socket_address *),
#include "libcli/libcli.h"
#include "libcli/resolve/resolve.h"
#include "libcli/finddcs.h"
+#include "param/param.h"
struct finddcs_state {
struct composite_context *ctx;
state->node_status.in.timeout = 1;
state->node_status.in.retries = 2;
- nbtsock = nbt_name_socket_init(state, state->ctx->event_ctx);
+ nbtsock = nbt_name_socket_init(state, state->ctx->event_ctx,
+ lp_iconv_convenience(global_loadparm));
if (composite_nomem(nbtsock, state->ctx)) return;
name_req = nbt_name_status_send(nbtsock, &state->node_status);
struct nbt_name_socket {
struct socket_context *sock;
struct event_context *event_ctx;
+ struct smb_iconv_convenience *iconv_convenience;
/* a queue of requests pending to be sent */
struct nbt_name_request *send_queue;
}
/* parse the request */
- ndr_err = ndr_pull_struct_blob(&blob, packet, lp_iconv_convenience(global_loadparm), packet,
+ ndr_err = ndr_pull_struct_blob(&blob, packet, nbtsock->iconv_convenience, packet,
(ndr_pull_flags_fn_t)ndr_pull_nbt_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
then operations will use that event context
*/
_PUBLIC_ struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
- struct event_context *event_ctx)
+ struct event_context *event_ctx,
+ struct smb_iconv_convenience *iconv_convenience)
{
struct nbt_name_socket *nbtsock;
NTSTATUS status;
nbtsock->num_pending = 0;
nbtsock->incoming.handler = NULL;
nbtsock->unexpected.handler = NULL;
+ nbtsock->iconv_convenience = iconv_convenience;
nbtsock->fde = event_add_fd(nbtsock->event_ctx, nbtsock,
socket_get_fd(nbtsock->sock), 0,
talloc_set_destructor(req, nbt_name_request_destructor);
ndr_err = ndr_push_struct_blob(&req->encoded, req,
- lp_iconv_convenience(global_loadparm),
+ req->nbtsock->iconv_convenience,
request,
(ndr_push_flags_fn_t)ndr_push_nbt_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) goto failed;
}
ndr_err = ndr_push_struct_blob(&req->encoded, req,
- lp_iconv_convenience(global_loadparm),
+ req->nbtsock->iconv_convenience,
request,
(ndr_push_flags_fn_t)ndr_push_nbt_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "system/filesys.h"
+#include "param/param.h"
#define SETUP_REQUEST_SESSION(cmd, wct, buflen) do { \
req = smbcli_request_setup_session(session, cmd, wct, buflen); \
}
session->pid = (uint16_t)getpid();
session->vuid = UID_FIELD_INVALID;
+ session->options.lanman_auth = lp_client_lanman_auth(global_loadparm);
+ session->options.ntlmv2_auth = lp_client_ntlmv2_auth(global_loadparm);
+ session->options.plaintext_auth = lp_client_plaintext_auth(global_loadparm);
capabilities = transport->negotiate.capabilities;
const char *host_name;
int num_ports;
uint16_t *ports;
+ const char *socket_options;
struct smbcli_socket *result;
};
for (i=0;ports[i];i++) {
state->ports[i] = atoi(ports[i]);
}
+ state->socket_options = lp_socket_options(global_loadparm);
ctx = socket_connect_multi_send(state, host_addr,
state->num_ports, state->ports,
if (!composite_is_ok(state->ctx)) return;
state->ctx->status =
- socket_set_option(sock, lp_socket_options(global_loadparm), NULL);
+ socket_set_option(sock, state->socket_options, NULL);
if (!composite_is_ok(state->ctx)) return;
/* the spnego context if we use extented security */
struct gensec_security *gensec;
+
+ struct smbcli_session_options {
+ uint_t lanman_auth:1;
+ uint_t ntlmv2_auth:1;
+ uint_t plaintext_auth:1;
+ } options;
};
/*
struct resolve_bcast_data {
struct interface *ifaces;
uint16_t nbt_port;
+ int nbt_timeout;
};
/**
}
address_list[count] = NULL;
- c = resolve_name_nbtlist_send(mem_ctx, event_ctx, name, address_list, data->ifaces, data->nbt_port, true, false);
+ c = resolve_name_nbtlist_send(mem_ctx, event_ctx, name, address_list, data->ifaces, data->nbt_port, data->nbt_timeout, true, false);
talloc_free(address_list);
return c;
TALLOC_CTX *mem_ctx,
struct interface *ifaces,
uint16_t nbt_port,
+ int nbt_timeout,
const char **reply_addr)
{
struct resolve_bcast_data *data = talloc(mem_ctx, struct resolve_bcast_data);
struct composite_context *c;
data->ifaces = talloc_reference(data, ifaces);
data->nbt_port = nbt_port;
+ data->nbt_timeout = nbt_timeout;
c = resolve_name_bcast_send(mem_ctx, NULL, data, name);
return resolve_name_bcast_recv(c, mem_ctx, reply_addr);
}
-bool resolve_context_add_bcast_method(struct resolve_context *ctx, struct interface *ifaces, uint16_t nbt_port)
+bool resolve_context_add_bcast_method(struct resolve_context *ctx, struct interface *ifaces, uint16_t nbt_port, int nbt_timeout)
{
struct resolve_bcast_data *data = talloc(ctx, struct resolve_bcast_data);
data->ifaces = ifaces;
data->nbt_port = nbt_port;
+ data->nbt_timeout = nbt_timeout;
return resolve_context_add_method(ctx, resolve_name_bcast_send, resolve_name_bcast_recv, data);
}
{
struct interface *ifaces;
load_interfaces(ctx, lp_interfaces(lp_ctx), &ifaces);
- return resolve_context_add_bcast_method(ctx, ifaces, lp_nbt_port(lp_ctx));
+ return resolve_context_add_bcast_method(ctx, ifaces, lp_nbt_port(lp_ctx), lp_parm_int(lp_ctx, NULL, "nbt", "timeout", 1));
}
const char **address_list,
struct interface *ifaces,
uint16_t nbt_port,
+ int nbt_timeout,
bool broadcast,
bool wins_lookup)
{
return c;
}
- state->nbtsock = nbt_name_socket_init(state, event_ctx);
+ state->nbtsock = nbt_name_socket_init(state, event_ctx,
+ lp_iconv_convenience(global_loadparm));
if (composite_nomem(state->nbtsock, c)) return c;
/* count the address_list size */
state->io_queries[i].in.broadcast = broadcast;
state->io_queries[i].in.wins_lookup = wins_lookup;
- state->io_queries[i].in.timeout = lp_parm_int(global_loadparm, NULL, "nbt", "timeout", 1);
+ state->io_queries[i].in.timeout = nbt_timeout;
state->io_queries[i].in.retries = 2;
state->queries[i] = nbt_name_query_send(state->nbtsock, &state->io_queries[i]);
const char **address_list,
struct interface *ifaces,
uint16_t nbt_port,
+ int nbt_timeout,
bool broadcast, bool wins_lookup,
const char **reply_addr)
{
struct composite_context *c = resolve_name_nbtlist_send(mem_ctx, NULL,
name, address_list,
ifaces, nbt_port,
+ nbt_timeout,
broadcast, wins_lookup);
return resolve_name_nbtlist_recv(c, mem_ctx, reply_addr);
}
const char **address_list;
struct interface *ifaces;
uint16_t nbt_port;
+ int nbt_timeout;
};
/**
{
struct resolve_wins_data *wins_data = talloc_get_type(userdata, struct resolve_wins_data);
if (wins_data->address_list == NULL) return NULL;
- return resolve_name_nbtlist_send(mem_ctx, event_ctx, name, wins_data->address_list, wins_data->ifaces, wins_data->nbt_port, false, true);
+ return resolve_name_nbtlist_send(mem_ctx, event_ctx, name, wins_data->address_list, wins_data->ifaces, wins_data->nbt_port, wins_data->nbt_timeout, false, true);
}
/*
const char **address_list,
struct interface *ifaces,
uint16_t nbt_port,
+ int nbt_timeout,
const char **reply_addr)
{
struct composite_context *c;
wins_data->address_list = address_list;
wins_data->ifaces = ifaces;
wins_data->nbt_port = nbt_port;
+ wins_data->nbt_timeout = nbt_timeout;
c = resolve_name_wins_send(mem_ctx, NULL, wins_data, name);
return resolve_name_wins_recv(c, mem_ctx, reply_addr);
}
-bool resolve_context_add_wins_method(struct resolve_context *ctx, const char **address_list, struct interface *ifaces, uint16_t nbt_port)
+bool resolve_context_add_wins_method(struct resolve_context *ctx, const char **address_list, struct interface *ifaces, uint16_t nbt_port, int nbt_timeout)
{
struct resolve_wins_data *wins_data = talloc(ctx, struct resolve_wins_data);
wins_data->address_list = str_list_copy(wins_data, address_list);
wins_data->ifaces = talloc_reference(wins_data, ifaces);
wins_data->nbt_port = nbt_port;
+ wins_data->nbt_timeout = nbt_timeout;
return resolve_context_add_method(ctx, resolve_name_wins_send, resolve_name_wins_recv,
wins_data);
}
{
struct interface *ifaces;
load_interfaces(ctx, lp_interfaces(lp_ctx), &ifaces);
- return resolve_context_add_wins_method(ctx, lp_wins_server_list(lp_ctx), ifaces, lp_nbt_port(lp_ctx));
+ return resolve_context_add_wins_method(ctx, lp_wins_server_list(lp_ctx), ifaces, lp_nbt_port(lp_ctx), lp_parm_int(lp_ctx, NULL, "nbt", "timeout", 1));
}
DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, lp_iconv_convenience(global_loadparm), session->transport->socket->hostname, lp_workgroup(global_loadparm));
DATA_BLOB session_key;
int flags = CLI_CRED_NTLM_AUTH;
- if (lp_client_lanman_auth(global_loadparm)) {
+ if (session->options.lanman_auth) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth(global_loadparm)) {
+ if (session->options.ntlmv2_auth) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
set_user_session_key(session, &session_key);
data_blob_free(&session_key);
- } else if (lp_client_plaintext_auth(global_loadparm)) {
+ } else if (session->options.plaintext_auth) {
state->setup.nt1.in.password1 = data_blob_talloc(state, password, strlen(password));
state->setup.nt1.in.password2 = data_blob(NULL, 0);
} else {
DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, lp_iconv_convenience(global_loadparm), session->transport->socket->hostname, lp_workgroup(global_loadparm));
DATA_BLOB session_key;
int flags = 0;
- if (lp_client_lanman_auth(global_loadparm)) {
+ if (session->options.lanman_auth) {
flags |= CLI_CRED_LANMAN_AUTH;
}
- if (lp_client_ntlmv2_auth(global_loadparm)) {
+ if (session->options.ntlmv2_auth) {
flags |= CLI_CRED_NTLMv2_AUTH;
}
set_user_session_key(session, &session_key);
data_blob_free(&session_key);
- } else if (lp_client_plaintext_auth(global_loadparm)) {
+ } else if (session->options.plaintext_auth) {
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 */
/* Function prototypes */
struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
- struct event_context *event_ctx);
+ struct event_context *event_ctx,
+ struct smb_iconv_convenience *iconv_convenience);
enum nbt_name_type {
NBT_NAME_CLIENT=0x00,
#define SWIGTYPE_p_p_char swig_types[10]
#define SWIGTYPE_p_short swig_types[11]
#define SWIGTYPE_p_signed_char swig_types[12]
-#define SWIGTYPE_p_unsigned_char swig_types[13]
-#define SWIGTYPE_p_unsigned_int swig_types[14]
-#define SWIGTYPE_p_unsigned_long_long swig_types[15]
-#define SWIGTYPE_p_unsigned_short swig_types[16]
-static swig_type_info *swig_types[18];
-static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0};
+#define SWIGTYPE_p_smb_iconv_convenience swig_types[13]
+#define SWIGTYPE_p_unsigned_char swig_types[14]
+#define SWIGTYPE_p_unsigned_int swig_types[15]
+#define SWIGTYPE_p_unsigned_long_long swig_types[16]
+#define SWIGTYPE_p_unsigned_short swig_types[17]
+static swig_type_info *swig_types[19];
+static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
PyObject *resultobj = 0;
TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
struct event_context *arg2 = (struct event_context *) 0 ;
+ struct smb_iconv_convenience *arg3 = (struct smb_iconv_convenience *) 0 ;
struct nbt_name_socket *result = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
char * kwnames[] = {
- (char *) "event_ctx", NULL
+ (char *) "event_ctx",(char *) "iconv_convenience", NULL
};
arg2 = event_context_init(NULL);
arg1 = NULL;
- if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:nbt_name_socket_init",kwnames,&obj0)) SWIG_fail;
+ if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:nbt_name_socket_init",kwnames,&obj0,&obj1)) SWIG_fail;
if (obj0) {
res2 = SWIG_ConvertPtr(obj0, &argp2,SWIGTYPE_p_event_context, 0 | 0 );
if (!SWIG_IsOK(res2)) {
}
arg2 = (struct event_context *)(argp2);
}
- result = (struct nbt_name_socket *)nbt_name_socket_init(arg1,arg2);
+ if (obj1) {
+ res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p_smb_iconv_convenience, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "nbt_name_socket_init" "', argument " "3"" of type '" "struct smb_iconv_convenience *""'");
+ }
+ arg3 = (struct smb_iconv_convenience *)(argp3);
+ }
+ result = (struct nbt_name_socket *)nbt_name_socket_init(arg1,arg2,arg3);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_nbt_name_socket, 0 | 0 );
return resultobj;
fail:
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_smb_iconv_convenience = {"_p_smb_iconv_convenience", "struct smb_iconv_convenience *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
&_swigt__p_p_char,
&_swigt__p_short,
&_swigt__p_signed_char,
+ &_swigt__p_smb_iconv_convenience,
&_swigt__p_unsigned_char,
&_swigt__p_unsigned_int,
&_swigt__p_unsigned_long_long,
static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_smb_iconv_convenience[] = { {&_swigt__p_smb_iconv_convenience, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
_swigc__p_p_char,
_swigc__p_short,
_swigc__p_signed_char,
+ _swigc__p_smb_iconv_convenience,
_swigc__p_unsigned_char,
_swigc__p_unsigned_int,
_swigc__p_unsigned_long_long,
blob.length = packet_blob_in.length - 4;
/* we have a full request - parse it */
- ndr_err = ndr_pull_struct_blob(&blob, req->packet, lp_iconv_convenience(global_loadparm), req->packet,
+ ndr_err = ndr_pull_struct_blob(&blob, req->packet, wrepl_socket->iconv_convenience, req->packet,
(ndr_pull_flags_fn_t)ndr_pull_wrepl_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
operations will use that event context
*/
struct wrepl_socket *wrepl_socket_init(TALLOC_CTX *mem_ctx,
- struct event_context *event_ctx)
+ struct event_context *event_ctx,
+ struct smb_iconv_convenience *iconv_convenience)
{
struct wrepl_socket *wrepl_socket;
NTSTATUS status;
}
if (!wrepl_socket->event.ctx) goto failed;
+ wrepl_socket->iconv_convenience = iconv_convenience;
+
status = socket_create("ip", SOCKET_TYPE_STREAM, &wrepl_socket->sock, 0);
if (!NT_STATUS_IS_OK(status)) goto failed;
composite_done(result);
}
+const char *wrepl_best_ip(struct loadparm_context *lp_ctx, const char *peer_ip)
+{
+ struct interface *ifaces;
+ load_interfaces(lp_ctx, lp_interfaces(lp_ctx), &ifaces);
+ return iface_best_ip(ifaces, peer_ip);
+}
+
+
/*
connect a wrepl_socket to a WINS server
*/
state->result = result;
state->wrepl_socket = wrepl_socket;
- if (!our_ip) {
- struct interface *ifaces;
- load_interfaces(state, lp_interfaces(global_loadparm), &ifaces);
- our_ip = iface_best_ip(ifaces, peer_ip);
- }
-
us = socket_address_from_strings(state, wrepl_socket->sock->backend_name,
our_ip, 0);
if (composite_nomem(us, result)) return result;
}
wrap.packet = *packet;
- ndr_err = ndr_push_struct_blob(&blob, req, lp_iconv_convenience(global_loadparm), &wrap,
+ ndr_err = ndr_push_struct_blob(&blob, req, wrepl_socket->iconv_convenience, &wrap,
(ndr_push_flags_fn_t)ndr_push_wrepl_wrap);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
/* remember if we need to free the wrepl_socket at the end of wrepl_socket_dead() */
bool free_skipped;
+
+ struct smb_iconv_convenience *iconv_convenience;
};
struct wrepl_send_ctrl {
s->cldap.io.in.acct_control = -1;
s->cldap.io.in.version = 6;
- s->cldap.sock = cldap_socket_init(s, s->libnet->event_ctx);
+ s->cldap.sock = cldap_socket_init(s, s->libnet->event_ctx,
+ lp_iconv_convenience(s->libnet->lp_ctx));
if (composite_nomem(s->cldap.sock, c)) return;
req = cldap_netlogon_send(s->cldap.sock, &s->cldap.io);
search.in.acct_control = -1;
search.in.version = 6;
- cldap = cldap_socket_init(tmp_ctx, NULL);
+ cldap = cldap_socket_init(tmp_ctx, NULL, lp_iconv_convenience(global_loadparm));
status = cldap_netlogon(cldap, tmp_ctx, &search);
if (!NT_STATUS_IS_OK(status)) {
/*
s->cldap.io.in.acct_control = -1;
s->cldap.io.in.version = 6;
- s->cldap.sock = cldap_socket_init(s, s->libnet->event_ctx);
+ s->cldap.sock = cldap_socket_init(s, s->libnet->event_ctx,
+ lp_iconv_convenience(s->libnet->lp_ctx));
if (composite_nomem(s->cldap.sock, c)) return;
req = cldap_netlogon_send(s->cldap.sock, &s->cldap.io);
/* non-signed packets are simpler */
if (!c->security_state.auth_info ||
!c->security_state.generic_state) {
- return ncacn_push_auth(blob, mem_ctx, pkt, c->security_state.auth_info);
+ return ncacn_push_auth(blob, mem_ctx, c->iconv_convenience, pkt, c->security_state.auth_info);
}
ndr = ndr_push_init_ctx(mem_ctx, c->iconv_convenience);
pkt.u.bind.auth_info = data_blob(NULL, 0);
/* construct the NDR form of the packet */
- c->status = ncacn_push_auth(&blob, c, &pkt,
+ c->status = ncacn_push_auth(&blob, c, p->conn->iconv_convenience, &pkt,
p->conn->security_state.auth_info);
if (!composite_is_ok(c)) return c;
pkt.u.auth3.auth_info = data_blob(NULL, 0);
/* construct the NDR form of the packet */
- status = ncacn_push_auth(&blob, mem_ctx, &pkt, c->security_state.auth_info);
+ status = ncacn_push_auth(&blob, mem_ctx, c->iconv_convenience, &pkt, c->security_state.auth_info);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
pkt.u.alter.auth_info = data_blob(NULL, 0);
/* construct the NDR form of the packet */
- c->status = ncacn_push_auth(&blob, mem_ctx, &pkt,
+ c->status = ncacn_push_auth(&blob, mem_ctx, p->conn->iconv_convenience, &pkt,
p->conn->security_state.auth_info);
if (!composite_is_ok(c)) return c;
push a ncacn_packet into a blob, potentially with auth info
*/
NTSTATUS ncacn_push_auth(DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
struct ncacn_packet *pkt,
struct dcerpc_auth *auth_info)
{
struct ndr_push *ndr;
enum ndr_err_code ndr_err;
- ndr = ndr_push_init_ctx(mem_ctx, lp_iconv_convenience(global_loadparm));
+ ndr = ndr_push_init_ctx(mem_ctx, iconv_convenience);
if (!ndr) {
return NT_STATUS_NO_MEMORY;
}
struct nbt_name_socket *bcast_nbtsock;
/* listen for broadcasts on port 137 */
- bcast_nbtsock = nbt_name_socket_init(iface, nbtsrv->task->event_ctx);
+ bcast_nbtsock = nbt_name_socket_init(iface, nbtsrv->task->event_ctx, lp_iconv_convenience(nbtsrv->task->lp_ctx));
if (!bcast_nbtsock) {
talloc_free(iface);
return NT_STATUS_NO_MEMORY;
}
/* listen for unicasts on port 137 */
- iface->nbtsock = nbt_name_socket_init(iface, nbtsrv->task->event_ctx);
+ iface->nbtsock = nbt_name_socket_init(iface, nbtsrv->task->event_ctx,
+ lp_iconv_convenience(nbtsrv->task->lp_ctx));
if (!iface->nbtsock) {
talloc_free(iface);
return NT_STATUS_NO_MEMORY;
struct notify_array *array;
int seqnum;
struct sys_notify_context *sys_notify_ctx;
+ struct smb_iconv_convenience *iconv_convenience;
};
notify->messaging_ctx = messaging_ctx;
notify->list = NULL;
notify->array = NULL;
+ notify->iconv_convenience = lp_iconv_convenience(lp_ctx);
notify->seqnum = tdb_get_seqnum(notify->w->tdb);
talloc_set_destructor(notify, notify_destructor);
blob.data = dbuf.dptr;
blob.length = dbuf.dsize;
- ndr_err = ndr_pull_struct_blob(&blob, notify->array, lp_iconv_convenience(global_loadparm),
+ ndr_err = ndr_pull_struct_blob(&blob, notify->array, notify->iconv_convenience,
notify->array,
(ndr_pull_flags_fn_t)ndr_pull_notify_array);
free(dbuf.dptr);
tmp_ctx = talloc_new(notify);
NT_STATUS_HAVE_NO_MEMORY(tmp_ctx);
- ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, lp_iconv_convenience(global_loadparm), notify->array,
+ ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, notify->iconv_convenience, notify->array,
(ndr_push_flags_fn_t)ndr_push_notify_array);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
return;
}
- ndr_err = ndr_pull_struct_blob(data, tmp_ctx, lp_iconv_convenience(global_loadparm), &ev,
+ ndr_err = ndr_pull_struct_blob(data, tmp_ctx, notify->iconv_convenience, &ev,
(ndr_pull_flags_fn_t)ndr_pull_notify_event);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
tmp_ctx = talloc_new(notify);
- ndr_err = ndr_push_struct_blob(&data, tmp_ctx, lp_iconv_convenience(global_loadparm), &ev, (ndr_push_flags_fn_t)ndr_push_notify_event);
+ ndr_err = ndr_push_struct_blob(&data, tmp_ctx, notify->iconv_convenience, &ev, (ndr_push_flags_fn_t)ndr_push_notify_event);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(tmp_ctx);
return;
resolve a wildcard rename pattern.
*/
static const char *pvfs_resolve_wildcard(TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
const char *fname,
const char *pattern)
{
const char *base1, *base2;
const char *ext1, *ext2;
- struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(global_loadparm);
char *p;
/* break into base part plus extension */
NTSTATUS status;
/* resolve the wildcard pattern for this name */
- fname2 = pvfs_resolve_wildcard(mem_ctx, fname1, fname2);
+ fname2 = pvfs_resolve_wildcard(mem_ctx, lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx), fname1, fname2);
if (fname2 == NULL) {
return NT_STATUS_NO_MEMORY;
}
reduce a name that contains .. components or repeated \ separators
return NULL if it can't be reduced
*/
-static NTSTATUS pvfs_reduce_name(TALLOC_CTX *mem_ctx, const char **fname, uint_t flags)
+static NTSTATUS pvfs_reduce_name(TALLOC_CTX *mem_ctx,
+ struct smb_iconv_convenience *iconv_convenience,
+ const char **fname, uint_t flags)
{
codepoint_t c;
size_t c_size, len;
int i, num_components, err_count;
char **components;
char *p, *s, *ret;
- struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(global_loadparm);
s = talloc_strdup(mem_ctx, *fname);
if (s == NULL) return NT_STATUS_NO_MEMORY;
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) {
/* it might contain .. components which need to be reduced */
- status = pvfs_reduce_name(*name, &cifs_name, flags);
+ status = pvfs_reduce_name(*name, lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx), &cifs_name, flags);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
NTSTATUS status;
enum ndr_err_code ndr_err;
- ndr_err = ndr_push_struct_blob(&blob, mem_ctx, lp_iconv_convenience(global_loadparm), p, (ndr_push_flags_fn_t)push_fn);
+ ndr_err = ndr_push_struct_blob(&blob, mem_ctx, lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx), p, (ndr_push_flags_fn_t)push_fn);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(mem_ctx);
return ndr_map_error2ntstatus(ndr_err);
static NTSTATUS inotify_setup(struct sys_notify_context *ctx)
{
struct inotify_private *in;
-
- if (!lp_parm_bool(global_loadparm, NULL, "notify", "inotify", true)) {
- return NT_STATUS_INVALID_SYSTEM_SERVICE;
- }
-
in = talloc(ctx, struct inotify_private);
NT_STATUS_HAVE_NO_MEMORY(in);
in->fd = inotify_init();
/* maybe setup the inotify fd */
if (ctx->private_data == NULL) {
NTSTATUS status;
+ if (!lp_parm_bool(global_loadparm, NULL, "notify", "inotify", true)) {
+ return NT_STATUS_INVALID_SYSTEM_SERVICE;
+ }
+
status = inotify_setup(ctx);
NT_STATUS_NOT_OK_RETURN(status);
}
return NT_STATUS_NO_MEMORY;
}
- status = ncacn_push_auth(&rep->blob, call, &pkt, NULL);
+ status = ncacn_push_auth(&rep->blob, call, lp_iconv_convenience(call->conn->dce_ctx->lp_ctx), &pkt, NULL);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NT_STATUS_NO_MEMORY;
}
- status = ncacn_push_auth(&rep->blob, call, &pkt, NULL);
+ status = ncacn_push_auth(&rep->blob, call, lp_iconv_convenience(call->conn->dce_ctx->lp_ctx), &pkt, NULL);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NT_STATUS_NO_MEMORY;
}
- status = ncacn_push_auth(&rep->blob, call, &pkt,
- call->conn->auth_state.auth_info);
+ status = ncacn_push_auth(&rep->blob, call, lp_iconv_convenience(call->conn->dce_ctx->lp_ctx), &pkt, call->conn->auth_state.auth_info);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NT_STATUS_NO_MEMORY;
}
- status = ncacn_push_auth(&rep->blob, call, &pkt,
- call->conn->auth_state.auth_info);
+ status = ncacn_push_auth(&rep->blob, call, lp_iconv_convenience(call->conn->dce_ctx->lp_ctx), &pkt, call->conn->auth_state.auth_info);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
/* non-signed packets are simple */
if (!dce_conn->auth_state.auth_info || !dce_conn->auth_state.gensec_security) {
- status = ncacn_push_auth(blob, call, pkt, NULL);
+ status = ncacn_push_auth(blob, call, lp_iconv_convenience(dce_conn->dce_ctx->lp_ctx), pkt, NULL);
return NT_STATUS_IS_OK(status);
}
}
ev = event_context_find(event_mem_ctx);
- ctx = libnet_context_init(ev, global_loadparm);
+ ctx = libnet_context_init(ev, mprLpCtx());
/* IF we generated a new event context, it will be under here,
* and we need it to last as long as the libnet context, so
* make it a child */
talloc_free(ctx);
return -1;
}
- cli_credentials_set_conf(creds, global_loadparm);
+ cli_credentials_set_conf(creds, mprLpCtx());
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(global_loadparm);
+ const char **js_include = lp_js_include(mprLpCtx());
if (js_include == NULL || js_include[0] == NULL) {
ejsSetErrorMsg(eid, "js include path not set");
smb_setup_ejs_param();
smb_setup_ejs_literal();
- shared_init = load_samba_modules(NULL, global_loadparm, "smbcalls");
+ shared_init = load_samba_modules(NULL, mprLpCtx(), "smbcalls");
run_init_functions(static_init);
run_init_functions(shared_init);
} else {
/* Hope we can find the event context somewhere up there... */
ev = event_context_find(tmp_ctx);
- msg = messaging_client_init(tmp_ctx, lp_messaging_path(tmp_ctx, global_loadparm),
- lp_iconv_convenience(global_loadparm), ev);
+ msg = messaging_client_init(tmp_ctx, lp_messaging_path(tmp_ctx, mprLpCtx()),
+ lp_iconv_convenience(mprLpCtx()), ev);
}
if (auth_types) {
- nt_status = auth_context_create_methods(tmp_ctx, auth_types, ev, msg, global_loadparm, &auth_context);
+ nt_status = auth_context_create_methods(tmp_ctx, auth_types, ev, msg, mprLpCtx(), &auth_context);
} else {
- nt_status = auth_context_create(tmp_ctx, ev, msg, global_loadparm, &auth_context);
+ nt_status = auth_context_create(tmp_ctx, ev, msg, mprLpCtx(), &auth_context);
}
if (!NT_STATUS_IS_OK(nt_status)) {
mprSetPropertyValue(auth, "result", mprCreateBoolVar(false));
goto done;
}
- nt_status = auth_generate_session_info(tmp_ctx, global_loadparm, server_info, &session_info);
+ nt_status = auth_generate_session_info(tmp_ctx, mprLpCtx(), server_info, &session_info);
if (!NT_STATUS_IS_OK(nt_status)) {
mprSetPropertyValue(auth, "report", mprString("Session Info generation failed"));
mprSetPropertyValue(auth, "result", mprCreateBoolVar(false));
static int ejs_system_session(MprVarHandle eid, int argc, struct MprVar **argv)
{
struct MprVar *obj = mprInitObject(eid, "session_info", argc, argv);
- struct auth_session_info *session_info = system_session(mprMemCtx(), global_loadparm);
+ struct auth_session_info *session_info = system_session(mprMemCtx(), mprLpCtx());
if (session_info == NULL) {
return -1;
/* Set up credentials */
creds = cli_credentials_init(NULL);
- cli_credentials_set_conf(creds, global_loadparm);
+ cli_credentials_set_conf(creds, mprLpCtx());
cli_credentials_parse_string(creds, argv[1], CRED_SPECIFIED);
/* Do connect */
io.in.dest_host = hostname;
- io.in.dest_ports = lp_smb_ports(global_loadparm);
+ io.in.dest_ports = lp_smb_ports(mprLpCtx());
io.in.called_name = strupper_talloc(mem_ctx, hostname);
io.in.service = sharename;
io.in.service_type = "?????";
io.in.credentials = creds;
io.in.fallback_to_anonymous = false;
- io.in.workgroup = lp_workgroup(global_loadparm);
- lp_smbcli_options(global_loadparm, &io.in.options);
+ io.in.workgroup = lp_workgroup(mprLpCtx());
+ lp_smbcli_options(mprLpCtx(), &io.in.options);
result = smb_composite_connect(&io, mem_ctx,
- lp_resolve_context(global_loadparm),
+ lp_resolve_context(mprLpCtx()),
NULL);
tree = io.out.tree;
const char **list = NULL;
if (argc != 0) return -1;
- for (i=0;i<lp_numservices(global_loadparm);i++) {
- list = str_list_add(list, lp_servicename(lp_servicebynum(global_loadparm, i)));
+ for (i=0;i<lp_numservices(mprLpCtx());i++) {
+ list = str_list_add(list, lp_servicename(lp_servicebynum(mprLpCtx(), i)));
}
talloc_steal(mprMemCtx(), list);
mpr_Return(eid, mprList("services", list));
if (argc == 2) {
struct loadparm_service *service;
/* its a share parameter */
- service = lp_service(global_loadparm, argv[0]);
+ service = lp_service(mprLpCtx(), argv[0]);
if (service == NULL) {
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
}
- value = lp_get_parametric(global_loadparm, service, type, option);
+ value = lp_get_parametric(mprLpCtx(), service, type, option);
if (value == NULL) {
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
}
- parm_ptr = lp_parm_ptr(global_loadparm, service, parm);
+ parm_ptr = lp_parm_ptr(mprLpCtx(), service, parm);
} else if (strchr(argv[0], ':')) {
/* its a global parametric option */
const char *type = talloc_strndup(mprMemCtx(),
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
}
- value = lp_get_parametric(global_loadparm, NULL, type, option);
+ value = lp_get_parametric(mprLpCtx(), NULL, type, option);
if (value == NULL) {
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
}
- parm_ptr = lp_parm_ptr(global_loadparm, NULL, parm);
+ parm_ptr = lp_parm_ptr(mprLpCtx(), NULL, parm);
}
if (parm == NULL || parm_ptr == NULL) {
*/
static int ejs_lpFilename(MprVarHandle eid, int argc, char **argv)
{
- mpr_ReturnString(eid, lp_configfile(global_loadparm));
+ mpr_ReturnString(eid, lp_configfile(mprLpCtx()));
return 0;
}
return -1;
}
- mpr_Return(eid, mprCreateBoolVar(lp_set_cmdline(global_loadparm, argv[0], argv[1])));
+ mpr_Return(eid, mprCreateBoolVar(lp_set_cmdline(mprLpCtx(), argv[0], argv[1])));
return 0;
}
static int ejs_lpReload(MprVarHandle eid, int argc, char **argv)
{
bool ret;
- const char *filename = lp_configfile(global_loadparm);
+ const char *filename = lp_configfile(mprLpCtx());
- ret = lp_load(global_loadparm, filename);
+ ret = lp_load(mprLpCtx(), filename);
mpr_Return(eid, mprCreateBoolVar(ret));
return 0;
}
return -1;
}
- if (NT_STATUS_IS_OK(cli_credentials_set_machine_account(creds, global_loadparm))) {
+ if (NT_STATUS_IS_OK(cli_credentials_set_machine_account(creds, mprLpCtx()))) {
mpr_Return(eid, mprCreateBoolVar(true));
} else {
mpr_Return(eid, mprCreateBoolVar(false));
return -1;
}
- cli_credentials_set_conf(creds, global_loadparm);
+ cli_credentials_set_conf(creds, mprLpCtx());
return ejs_credentials_obj(obj, creds);
}
case REG_EXPAND_SZ: {
char *s;
ssize_t len;
- len = convert_string_talloc(mprMemCtx(), lp_iconv_convenience(global_loadparm), CH_UTF16, CH_UNIX,
+ len = convert_string_talloc(mprMemCtx(), lp_iconv_convenience(mprLpCtx()), CH_UTF16, CH_UNIX,
blob->data, blob->length, (void **)&s);
if (len == -1) {
ejsSetErrorMsg(eid, "regToVar invalid REG_SZ string");
if (slen == 2 && b.length == 2 && SVAL(b.data, 0) == 0) {
break;
}
- len = convert_string_talloc(mprMemCtx(), lp_iconv_convenience(global_loadparm), CH_UTF16, CH_UNIX,
+ len = convert_string_talloc(mprMemCtx(), lp_iconv_convenience(mprLpCtx()), CH_UTF16, CH_UNIX,
b.data, slen, (void **)&s);
if (len == -1) {
ejsSetErrorMsg(eid, "regToVar invalid REG_MULTI_SZ string");
dbfile = argv[0];
- ldb = ldb_wrap_connect(mprMemCtx(), global_loadparm, dbfile,
+ ldb = ldb_wrap_connect(mprMemCtx(), mprLpCtx(), dbfile,
session_info, creds,
0, (const char **)(argv+1));
if (ldb == NULL) {
result = 0;
- nt_status = resolve_name(lp_resolve_context(global_loadparm), &name, tmp_ctx, &reply_addr, event_context_find(tmp_ctx));
+ nt_status = resolve_name(lp_resolve_context(mprLpCtx()), &name, tmp_ctx, &reply_addr, event_context_find(tmp_ctx));
if (NT_STATUS_IS_OK(nt_status)) {
mprSetPropertyValue(argv[0], "value", mprString(reply_addr));
struct registry_context *rctx;
WERROR error;
- error = reg_open_samba(mprMemCtx(), &rctx, global_loadparm, NULL, NULL);
+ error = reg_open_samba(mprMemCtx(), &rctx, mprLpCtx(), NULL, NULL);
SMB_ASSERT(W_ERROR_IS_OK(error));
mprSetPtrChild(reg, "registry", rctx);
allocate temporary server ids automatically */
for (i=0;i<10000;i++) {
p->msg_ctx = messaging_init(p,
- lp_messaging_path(p, global_loadparm),
+ lp_messaging_path(p, mprLpCtx()),
cluster_id(EJS_ID_BASE, i),
- lp_iconv_convenience(global_loadparm),
+ lp_iconv_convenience(mprLpCtx()),
ev);
if (p->msg_ctx) break;
}
ev = event_context_find(mprMemCtx());
status = dcerpc_pipe_connect(this, &p, binding, iface, creds, ev,
- global_loadparm);
+ mprLpCtx());
if (!NT_STATUS_IS_OK(status)) goto done;
/* callers don't allocate ref vars in the ejs interface */
struct MprVar ret = mprArray("interfaces");
struct interface *ifaces;
- load_interfaces(NULL, lp_interfaces(global_loadparm), &ifaces);
+ load_interfaces(NULL, lp_interfaces(mprLpCtx()), &ifaces);
count = iface_count(ifaces);
for (i=0;i<count;i++) {
dest = req->out.buffer + PTR_DIFF(dest, buf0);
}
- len = push_string(lp_iconv_convenience(global_loadparm), dest, str, len, flags);
+ len = push_string(lp_iconv_convenience(req->smb_conn->lp_ctx), dest, str, len, flags);
grow_size = len + PTR_DIFF(dest, req->out.data);
packet_set_fde(smb_conn->packet, conn->event.fde);
packet_set_serialise(smb_conn->packet);
- smb_conn->lp_ctx = global_loadparm;
+ smb_conn->lp_ctx = conn->lp_ctx;
smb_conn->connection = conn;
conn->private = smb_conn;
*/
static bool test_cldap_netlogon(struct torture_context *tctx, const char *dest)
{
- struct cldap_socket *cldap = cldap_socket_init(tctx, NULL);
+ struct cldap_socket *cldap = cldap_socket_init(tctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
NTSTATUS status;
struct cldap_netlogon search, empty_search;
union nbt_cldap_netlogon n1;
*/
static bool test_cldap_generic(struct torture_context *tctx, const char *dest)
{
- struct cldap_socket *cldap = cldap_socket_init(tctx, NULL);
+ struct cldap_socket *cldap = cldap_socket_init(tctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
NTSTATUS status;
struct cldap_search search;
const char *attrs1[] = { "currentTime", "highestCommittedUSN", NULL };
*/
static bool bench_cldap(struct torture_context *tctx, const char *address)
{
- struct cldap_socket *cldap = cldap_socket_init(tctx, NULL);
+ struct cldap_socket *cldap = cldap_socket_init(tctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
int num_sent=0;
struct timeval tv = timeval_current();
bool ret = true;
*/
static bool bench_namequery(struct torture_context *tctx)
{
- struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL);
+ struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL,
+ lp_iconv_convenience(tctx->lp_ctx));
int num_sent=0;
struct result_struct *result;
struct nbt_name_query io;
{
struct nbt_name_register io;
NTSTATUS status;
- struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL);
+ struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL,
+ lp_iconv_convenience(tctx->lp_ctx));
struct socket_address *socket_address;
struct nbt_name name;
const char *address;
{
struct nbt_name_refresh io;
NTSTATUS status;
- struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL);
+ struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL,
+ lp_iconv_convenience(tctx->lp_ctx));
const char *myaddress;
struct socket_address *socket_address;
struct nbt_name name;
struct nbt_name_refresh_wins refresh;
struct nbt_name_release release;
NTSTATUS status;
- struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL);
+ struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
const char *myaddress;
struct socket_address *socket_address;
struct interface *ifaces;
*/
static bool bench_wins(struct torture_context *tctx)
{
- struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL);
+ struct nbt_name_socket *nbtsock = nbt_name_socket_init(tctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
int num_sent=0;
struct timeval tv = timeval_current();
bool ret = true;
torture_comment(tctx, "Test if assoc_ctx is only valid on the conection it was created on\n");
- wrepl_socket1 = wrepl_socket_init(tctx, NULL);
- wrepl_socket2 = wrepl_socket_init(tctx, NULL);
+ wrepl_socket1 = wrepl_socket_init(tctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
+ wrepl_socket2 = wrepl_socket_init(tctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
torture_comment(tctx, "Setup 2 wrepl connections\n");
- status = wrepl_connect(wrepl_socket1, lp_resolve_context(tctx->lp_ctx), NULL, address);
+ status = wrepl_connect(wrepl_socket1, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, address), address);
CHECK_STATUS(tctx, status, NT_STATUS_OK);
- status = wrepl_connect(wrepl_socket2, lp_resolve_context(tctx->lp_ctx), NULL, address);
+ status = wrepl_connect(wrepl_socket2, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, address), address);
CHECK_STATUS(tctx, status, NT_STATUS_OK);
torture_comment(tctx, "Send a start association request (conn1)\n");
torture_comment(tctx, "Test if we always get back the same assoc_ctx\n");
- wrepl_socket = wrepl_socket_init(tctx, NULL);
+ wrepl_socket = wrepl_socket_init(tctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
torture_comment(tctx, "Setup wrepl connections\n");
- status = wrepl_connect(wrepl_socket, lp_resolve_context(tctx->lp_ctx), NULL, address);
+ status = wrepl_connect(wrepl_socket, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, address), address);
CHECK_STATUS(tctx, status, NT_STATUS_OK);
torture_comment(tctx, "Send 1st start association request\n");
torture_comment(tctx, "Test one pull replication cycle\n");
- wrepl_socket = wrepl_socket_init(tctx, NULL);
+ wrepl_socket = wrepl_socket_init(tctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
torture_comment(tctx, "Setup wrepl connections\n");
- status = wrepl_connect(wrepl_socket, lp_resolve_context(tctx->lp_ctx), NULL, address);
+ status = wrepl_connect(wrepl_socket, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, address), address);
CHECK_STATUS(tctx, status, NT_STATUS_OK);
torture_comment(tctx, "Send a start association request\n");
if (!ctx) return NULL;
ctx->address = address;
- ctx->pull = wrepl_socket_init(ctx, NULL);
+ ctx->pull = wrepl_socket_init(ctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
if (!ctx->pull) return NULL;
torture_comment(tctx, "Setup wrepl conflict pull connection\n");
- status = wrepl_connect(ctx->pull, lp_resolve_context(tctx->lp_ctx), NULL, ctx->address);
+ status = wrepl_connect(ctx->pull, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, ctx->address), ctx->address);
if (!NT_STATUS_IS_OK(status)) return NULL;
status = wrepl_associate(ctx->pull, &associate);
talloc_free(pull_table.out.partners);
- ctx->nbtsock = nbt_name_socket_init(ctx, NULL);
+ ctx->nbtsock = nbt_name_socket_init(ctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
if (!ctx->nbtsock) return NULL;
load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
status = socket_listen(ctx->nbtsock->sock, ctx->myaddr, 0, 0);
if (!NT_STATUS_IS_OK(status)) return NULL;
- ctx->nbtsock_srv = nbt_name_socket_init(ctx, NULL);
+ ctx->nbtsock_srv = nbt_name_socket_init(ctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
if (!ctx->nbtsock_srv) return NULL;
/* Make a port 137 version of ctx->myaddr */
}
if (ctx->myaddr2 && ctx->nbtsock_srv) {
- ctx->nbtsock2 = nbt_name_socket_init(ctx, NULL);
+ ctx->nbtsock2 = nbt_name_socket_init(ctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
if (!ctx->nbtsock2) return NULL;
status = socket_listen(ctx->nbtsock2->sock, ctx->myaddr2, 0, 0);
if (!NT_STATUS_IS_OK(status)) return NULL;
- ctx->nbtsock_srv2 = nbt_name_socket_init(ctx, ctx->nbtsock_srv->event_ctx);
+ ctx->nbtsock_srv2 = nbt_name_socket_init(ctx, ctx->nbtsock_srv->event_ctx, lp_iconv_convenience(tctx->lp_ctx));
if (!ctx->nbtsock_srv2) return NULL;
/* Make a port 137 version of ctx->myaddr2 */
uint32_t assoc_ctx;
NTSTATUS status;
- wrepl_socket = wrepl_socket_init(ctx, NULL);
+ wrepl_socket = wrepl_socket_init(ctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
- status = wrepl_connect(wrepl_socket, lp_resolve_context(tctx->lp_ctx), NULL, ctx->address);
+ status = wrepl_connect(wrepl_socket, lp_resolve_context(tctx->lp_ctx), wrepl_best_ip(tctx->lp_ctx, ctx->address), ctx->address);
CHECK_STATUS(tctx, status, NT_STATUS_OK);
status = wrepl_associate(wrepl_socket, &associate);
struct drsuapi_DsNameString names[1];
bool ret = true;
- struct cldap_socket *cldap = cldap_socket_init(ctx, NULL);
+ struct cldap_socket *cldap = cldap_socket_init(ctx, NULL, lp_iconv_convenience(tctx->lp_ctx));
struct cldap_netlogon search;
r.in.bind_handle = &ctx->admin.drsuapi.bind_handle;
node_name = talloc_strdup(tmp_ctx, name);
}
- nbtsock = nbt_name_socket_init(tmp_ctx, NULL);
+ nbtsock = nbt_name_socket_init(tmp_ctx, NULL, lp_iconv_convenience(lp_ctx));
if (options.root_port) {
all_zero_addr = socket_address_from_strings(tmp_ctx, nbtsock->sock->backend_name,
if (!composite_is_ok(state->ctx)) return;
ndr_err = ndr_push_struct_blob(
- &tmp_blob, state, lp_iconv_convenience(global_loadparm),
+ &tmp_blob, state, lp_iconv_convenience(state->lp_ctx),
state->req->out.validation.sam3,
(ndr_push_flags_fn_t)ndr_push_netr_SamInfo3);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
#include "libcli/composite/composite.h"
#include "libcli/wrepl/winsrepl.h"
#include "libcli/resolve/resolve.h"
+#include "param/param.h"
enum wreplsrv_out_connect_stage {
WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET,
wreplconn->service = service;
wreplconn->partner = partner;
- wreplconn->sock = wrepl_socket_init(wreplconn, service->task->event_ctx);
+ wreplconn->sock = wrepl_socket_init(wreplconn, service->task->event_ctx, lp_iconv_convenience(service->task->lp_ctx));
if (!wreplconn->sock) goto failed;
state->stage = WREPLSRV_OUT_CONNECT_STAGE_WAIT_SOCKET;
state->wreplconn= wreplconn;
state->c_req = wrepl_connect_send(wreplconn->sock,
lp_resolve_context(service->task->lp_ctx),
- partner->our_address,
+ partner->our_address?partner->our_address:wrepl_best_ip(service->task->lp_ctx, partner->address),
partner->address);
if (!state->c_req) goto failed;