sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00
Code

Merge branch 'v4-0-trivial' into v4-0-test

Browse Source 
(This used to be commit 6cbb241c05)
This commit is contained in:
Jelmer Vernooij 2008-02-28 18:27:29 +01:00
commit fc6bc92e11
70 changed files with 266 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source4/cldap_server/cldap_server.c
View File

@ -92,7 +92,7 @@ static NTSTATUS cldapd_add_socket(struct cldapd_server *cldapd, struct loadparm_
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,

4
source4/kdc/hdb-ldb.c
View File

@ -1168,8 +1168,8 @@ NTSTATUS kdc_hdb_ldb_create(TALLOC_CTX *mem_ctx,
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)) {

5
source4/kdc/kdc.c
View File

@ -41,8 +41,10 @@
#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 {
@ -648,6 +650,7 @@ static void kdc_task_init(struct task_server *task)
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);

1
source4/kdc/kdc.h
View File

@ -30,6 +30,7 @@ struct kdc_server;
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,

7
source4/lib/appweb/mpr/miniMpr.c
View File

@ -30,6 +30,7 @@
*/
#include "miniMpr.h"
#include "param/param.h"
/************************************ Code ************************************/
#if !BLD_APPWEB
@ -49,6 +50,12 @@ void *mprMemCtx(void)
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);

2
source4/lib/appweb/mpr/miniMpr.h
View File

@ -272,6 +272,8 @@ extern int mprMemcpy(char *dest, int destMax, const char *src, int nbytes);
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);

3
source4/lib/registry/hive.c
View File

@ -22,6 +22,7 @@
#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,
@ -52,7 +53,7 @@ _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,

3
source4/lib/registry/hive.h
View File

@ -188,7 +188,7 @@ WERROR hive_key_flush(struct hive_key *key);
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,
@ -200,6 +200,7 @@ WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location,
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);

14
source4/lib/registry/ldb.c
View File

@ -36,7 +36,9 @@ struct ldb_key_data
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)
{
@ -57,7 +59,7 @@ static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx, struct ldb_message *msg,
{
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;
@ -281,7 +283,7 @@ static WERROR ldb_get_value_by_id(TALLOC_CTX *mem_ctx, struct hive_key *k,
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;
@ -310,7 +312,7 @@ static WERROR ldb_get_value(TALLOC_CTX *mem_ctx, struct hive_key *k,
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;
}
@ -607,7 +609,9 @@ static WERROR ldb_get_key_info(TALLOC_CTX *mem_ctx,
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);

9
source4/lib/registry/patchfile.c
View File

@ -27,6 +27,7 @@
_PUBLIC_ WERROR reg_preg_diff_load(int fd,
struct smb_iconv_convenience *iconv_convenience,
const struct reg_diff_callbacks *callbacks,
void *callback_data);
@ -273,6 +274,7 @@ _PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1,
* 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)
{
@ -305,10 +307,10 @@ _PUBLIC_ WERROR reg_diff_load(const char *filename,
#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);
}
}
@ -442,5 +444,6 @@ _PUBLIC_ WERROR reg_diff_apply(struct registry_context *ctx, const char *filenam
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);
}

1
source4/lib/registry/patchfile.h
View File

@ -43,6 +43,7 @@ WERROR reg_generate_diff(struct registry_context *ctx1,
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,

3
source4/lib/registry/patchfile_dotreg.c
View File

@ -101,6 +101,7 @@ static WERROR reg_dotreg_diff_del_all_values(void *callback_data,
* 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)
{
@ -109,7 +110,7 @@ _PUBLIC_ WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
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);

17
source4/lib/registry/patchfile_preg.c
View File

@ -29,14 +29,14 @@ struct preg_data {
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;
}
@ -123,6 +123,7 @@ _PUBLIC_ WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
* 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)
{
@ -162,7 +163,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
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 != '[') {
@ -173,7 +174,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
/* 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++;
}
@ -181,7 +182,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
/* 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++;
}
@ -195,7 +196,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
}
/* 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;
@ -209,7 +210,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
}
/* 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;
@ -227,7 +228,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
/* 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));

10
source4/lib/registry/regf.c
View File

@ -1863,7 +1863,9 @@ static WERROR regf_save_hbin(struct regf_data *regf)
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;
@ -1874,7 +1876,7 @@ WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx, const char *location,
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);
@ -1950,7 +1952,7 @@ WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx, const char *location,
}
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;
@ -1959,7 +1961,7 @@ WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx, const char *location,
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);

4
source4/lib/registry/tests/hive.c
View File

@ -25,6 +25,7 @@
#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)
@ -349,7 +350,8 @@ static bool hive_setup_regf(struct torture_context *tctx, void **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;

2
source4/lib/registry/tools/regdiff.c
View File

@ -126,7 +126,7 @@ int main(int argc, const char **argv)
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",

8
source4/libcli/cldap/cldap.c
View File

@ -241,7 +241,8 @@ static void cldap_socket_handler(struct event_context *ev, struct fd_event *fde,
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;
@ -270,6 +271,7 @@ struct cldap_socket *cldap_socket_init(TALLOC_CTX *mem_ctx,
cldap->send_queue = NULL;
cldap->incoming.handler = NULL;
cldap->iconv_convenience = iconv_convenience;
return cldap;
@ -618,7 +620,7 @@ NTSTATUS cldap_netlogon_recv(struct cldap_request *req,
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);
@ -714,7 +716,7 @@ NTSTATUS cldap_netlogon_reply(struct cldap_socket *cldap,
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)) {

4
source4/libcli/cldap/cldap.h
View File

@ -73,6 +73,7 @@ struct cldap_request {
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;
@ -111,7 +112,8 @@ struct cldap_search {
};
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 *),

4
source4/libcli/finddcs.c
View File

@ -28,6 +28,7 @@
#include "libcli/libcli.h"
#include "libcli/resolve/resolve.h"
#include "libcli/finddcs.h"
#include "param/param.h"
struct finddcs_state {
struct composite_context *ctx;
@ -195,7 +196,8 @@ static void fallback_node_status(struct finddcs_state *state)
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);

1
source4/libcli/nbt/libnbt.h
View File

@ -94,6 +94,7 @@ struct nbt_name_request {
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;

10
source4/libcli/nbt/nbtsocket.c
View File

@ -190,7 +190,7 @@ static void nbt_name_socket_recv(struct nbt_name_socket *nbtsock)
}
/* 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);
@ -309,7 +309,8 @@ static void nbt_name_socket_handler(struct event_context *ev, struct fd_event *f
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;
@ -338,6 +339,7 @@ _PUBLIC_ struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
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,
@ -395,7 +397,7 @@ struct nbt_name_request *nbt_name_request_send(struct nbt_name_socket *nbtsock,
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;
@ -444,7 +446,7 @@ NTSTATUS nbt_name_reply_send(struct nbt_name_socket *nbtsock,
}
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)) {

4
source4/libcli/raw/clisession.c
View File

@ -22,6 +22,7 @@
#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); \
@ -51,6 +52,9 @@ struct smbcli_session *smbcli_session_init(struct smbcli_transport *transport,
}
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;

4
source4/libcli/raw/clisocket.c
View File

@ -33,6 +33,7 @@ struct sock_connect_state {
const char *host_name;
int num_ports;
uint16_t *ports;
const char *socket_options;
struct smbcli_socket *result;
};
@ -80,6 +81,7 @@ struct composite_context *smbcli_sock_connect_send(TALLOC_CTX *mem_ctx,
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,
@ -108,7 +110,7 @@ static void smbcli_sock_connect_recv_conn(struct composite_context *ctx)
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;

6
source4/libcli/raw/libcliraw.h
View File

@ -186,6 +186,12 @@ struct smbcli_session {
/* 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;
};
/*

10
source4/libcli/resolve/bcast.c
View File

@ -29,6 +29,7 @@
struct resolve_bcast_data {
struct interface *ifaces;
uint16_t nbt_port;
int nbt_timeout;
};
/**
@ -62,7 +63,7 @@ struct composite_context *resolve_name_bcast_send(TALLOC_CTX *mem_ctx,
}
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;
@ -84,22 +85,25 @@ NTSTATUS resolve_name_bcast(struct nbt_name *name,
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);
}
@ -107,5 +111,5 @@ bool resolve_context_add_bcast_method_lp(struct resolve_context *ctx, struct loa
{
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));
}

8
source4/libcli/resolve/nbtlist.c
View File

@ -102,6 +102,7 @@ struct composite_context *resolve_name_nbtlist_send(TALLOC_CTX *mem_ctx,
const char **address_list,
struct interface *ifaces,
uint16_t nbt_port,
int nbt_timeout,
bool broadcast,
bool wins_lookup)
{
@ -140,7 +141,8 @@ struct composite_context *resolve_name_nbtlist_send(TALLOC_CTX *mem_ctx,
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 */
@ -161,7 +163,7 @@ struct composite_context *resolve_name_nbtlist_send(TALLOC_CTX *mem_ctx,
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]);
@ -201,12 +203,14 @@ NTSTATUS resolve_name_nbtlist(struct nbt_name *name,
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);
}

10
source4/libcli/resolve/wins.c
View File

@ -29,6 +29,7 @@ struct resolve_wins_data {
const char **address_list;
struct interface *ifaces;
uint16_t nbt_port;
int nbt_timeout;
};
/**
@ -42,7 +43,7 @@ struct composite_context *resolve_name_wins_send(
{
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);
}
/*
@ -62,6 +63,7 @@ NTSTATUS resolve_name_wins(struct nbt_name *name,
const char **address_list,
struct interface *ifaces,
uint16_t nbt_port,
int nbt_timeout,
const char **reply_addr)
{
struct composite_context *c;
@ -69,16 +71,18 @@ NTSTATUS resolve_name_wins(struct nbt_name *name,
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);
}
@ -87,5 +91,5 @@ bool resolve_context_add_wins_method_lp(struct resolve_context *ctx, struct load
{
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));
}

12
source4/libcli/smb_composite/sesssetup.c
View File

@ -226,11 +226,11 @@ static NTSTATUS session_setup_nt1(struct composite_context *c,
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;
}
@ -263,7 +263,7 @@ static NTSTATUS session_setup_nt1(struct composite_context *c,
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 {
@ -293,11 +293,11 @@ static NTSTATUS session_setup_old(struct composite_context *c,
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;
}
@ -324,7 +324,7 @@ static NTSTATUS session_setup_old(struct composite_context *c,
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 */

3
source4/libcli/swig/libcli_nbt.i
View File

@ -46,7 +46,8 @@
/* 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,

34
source4/libcli/swig/libcli_nbt_wrap.c
View File

@ -2469,12 +2469,13 @@ SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags)
#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)
@ -2918,17 +2919,21 @@ SWIGINTERN PyObject *_wrap_nbt_name_socket_init(PyObject *SWIGUNUSEDPARM(self),
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)) {
@ -2936,7 +2941,14 @@ SWIGINTERN PyObject *_wrap_nbt_name_socket_init(PyObject *SWIGUNUSEDPARM(self),
}
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:
@ -4135,6 +4147,7 @@ static swig_type_info _swigt__p_nbt_name_socket = {"_p_nbt_name_socket", "struct
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};
@ -4154,6 +4167,7 @@ static swig_type_info *swig_type_initial[] = {
&_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,
@ -4173,6 +4187,7 @@ static swig_cast_info _swigc__p_nbt_name_socket[] = { {&_swigt__p_nbt_name_sock
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}};
@ -4192,6 +4207,7 @@ static swig_cast_info *swig_cast_initial[] = {
_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,

23
source4/libcli/wrepl/winsrepl.c
View File

@ -102,7 +102,7 @@ static NTSTATUS wrepl_finish_recv(void *private, DATA_BLOB packet_blob_in)
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);
@ -163,7 +163,8 @@ static int wrepl_socket_destructor(struct wrepl_socket *sock)
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;
@ -178,6 +179,8 @@ struct wrepl_socket *wrepl_socket_init(TALLOC_CTX *mem_ctx,
}
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;
@ -308,6 +311,14 @@ static void wrepl_connect_handler(struct composite_context *creq)
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
*/
@ -331,12 +342,6 @@ struct composite_context *wrepl_connect_send(struct wrepl_socket *wrepl_socket,
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;
@ -493,7 +498,7 @@ struct wrepl_request *wrepl_request_send(struct wrepl_socket *wrepl_socket,
}
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);

2
source4/libcli/wrepl/winsrepl.h
View File

@ -49,6 +49,8 @@ struct wrepl_socket {
/* 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 {

3
source4/libnet/libnet_become_dc.c
View File

@ -747,7 +747,8 @@ static void becomeDC_send_cldap(struct libnet_BecomeDC_state *s)
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);

2
source4/libnet/libnet_site.c
View File

@ -55,7 +55,7 @@ NTSTATUS libnet_FindSite(TALLOC_CTX *ctx, struct libnet_JoinSite *r)
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)) {
/*

3
source4/libnet/libnet_unbecome_dc.c
View File

@ -267,7 +267,8 @@ static void unbecomeDC_send_cldap(struct libnet_UnbecomeDC_state *s)
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);

8
source4/librpc/rpc/dcerpc.c
View File

@ -351,7 +351,7 @@ static NTSTATUS ncacn_push_request_sign(struct dcerpc_connection *c,
/* 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);
@ -750,7 +750,7 @@ struct composite_context *dcerpc_bind_send(struct dcerpc_pipe *p,
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;
@ -813,7 +813,7 @@ NTSTATUS dcerpc_auth3(struct dcerpc_connection *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;
}
@ -1646,7 +1646,7 @@ struct composite_context *dcerpc_alter_context_send(struct dcerpc_pipe *p,
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;

3
source4/librpc/rpc/dcerpc_util.c
View File

@ -50,13 +50,14 @@ const struct ndr_interface_call *dcerpc_iface_find_call(const struct ndr_interfa
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;
}

5
source4/nbt_server/interfaces.c
View File

@ -130,7 +130,7 @@ static NTSTATUS nbtd_add_socket(struct nbtd_server *nbtsrv,
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;
@ -156,7 +156,8 @@ static NTSTATUS nbtd_add_socket(struct nbtd_server *nbtsrv,
}
/* 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;

10
source4/ntvfs/common/notify.c
View File

@ -45,6 +45,7 @@ struct notify_context {
struct notify_array *array;
int seqnum;
struct sys_notify_context *sys_notify_ctx;
struct smb_iconv_convenience *iconv_convenience;
};
@ -107,6 +108,7 @@ struct notify_context *notify_init(TALLOC_CTX *mem_ctx, struct server_id server,
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);
@ -171,7 +173,7 @@ static NTSTATUS notify_load(struct notify_context *notify)
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);
@ -220,7 +222,7 @@ static NTSTATUS notify_save(struct notify_context *notify)
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);
@ -256,7 +258,7 @@ static void notify_handler(struct messaging_context *msg_ctx, void *private_data
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);
@ -555,7 +557,7 @@ static void notify_send(struct notify_context *notify, struct notify_entry *e,
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;

4
source4/ntvfs/posix/pvfs_rename.c
View File

@ -134,12 +134,12 @@ static const char *pvfs_resolve_wildcard_component(TALLOC_CTX *mem_ctx,
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 */
@ -274,7 +274,7 @@ static NTSTATUS pvfs_rename_one(struct pvfs_state *pvfs,
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;
}

7
source4/ntvfs/posix/pvfs_resolve.c
View File

@ -329,14 +329,15 @@ static NTSTATUS pvfs_unix_path(struct pvfs_state *pvfs, const char *cifs_name,
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;
@ -471,7 +472,7 @@ NTSTATUS pvfs_resolve_name(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
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;
}

2
source4/ntvfs/posix/pvfs_xattr.c
View File

@ -140,7 +140,7 @@ _PUBLIC_ NTSTATUS pvfs_xattr_ndr_save(struct pvfs_state *pvfs,
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);

9
source4/ntvfs/sysdep/inotify.c
View File

@ -244,11 +244,6 @@ static void inotify_handler(struct event_context *ev, struct fd_event *fde,
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();
@ -339,6 +334,10 @@ static NTSTATUS inotify_watch(struct sys_notify_context *ctx,
/* 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);
}

10
source4/rpc_server/dcerpc_server.c
View File

@ -462,7 +462,7 @@ static NTSTATUS dcesrv_fault(struct dcesrv_call_state *call, uint32_t fault_code
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;
}
@ -501,7 +501,7 @@ static NTSTATUS dcesrv_bind_nak(struct dcesrv_call_state *call, uint32_t reason)
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;
}
@ -642,8 +642,7 @@ static NTSTATUS dcesrv_bind(struct dcesrv_call_state *call)
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;
}
@ -787,8 +786,7 @@ static NTSTATUS dcesrv_alter(struct dcesrv_call_state *call)
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;
}

2
source4/rpc_server/dcesrv_auth.c
View File

@ -402,7 +402,7 @@ bool dcesrv_auth_response(struct dcesrv_call_state *call,
/* 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);
}

4
source4/scripting/ejs/ejsnet/net_ctx.c
View File

@ -52,7 +52,7 @@ static int ejs_net_context(MprVarHandle eid, int argc, struct MprVar **argv)
}
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 */
@ -68,7 +68,7 @@ static int ejs_net_context(MprVarHandle eid, int argc, struct MprVar **argv)
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);

4
source4/scripting/ejs/smbcalls.c
View File

@ -111,7 +111,7 @@ static int ejs_typeof_native(MprVarHandle eid, int argc, struct MprVar **argv)
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");
@ -184,7 +184,7 @@ void smb_setup_ejs_functions(void (*exception_handler)(const char *))
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);

12
source4/scripting/ejs/smbcalls_auth.c
View File

@ -56,14 +56,14 @@ static int ejs_doauth(MprVarHandle eid,
} 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));
@ -109,7 +109,7 @@ static int ejs_doauth(MprVarHandle eid,
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));
@ -222,7 +222,7 @@ static int ejs_userAuth(MprVarHandle eid, int argc, struct MprVar **argv)
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;

10
source4/scripting/ejs/smbcalls_cli.c
View File

@ -432,23 +432,23 @@ static int ejs_tree_connect(MprVarHandle eid, int argc, char **argv)
/* 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;

22
source4/scripting/ejs/smbcalls_config.c
View File

@ -36,8 +36,8 @@ static int ejs_lpServices(MprVarHandle eid, int argc, char **argv)
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));
@ -68,7 +68,7 @@ static int ejs_lpGet(MprVarHandle eid, int argc, char **argv)
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;
@ -84,7 +84,7 @@ static int ejs_lpGet(MprVarHandle eid, int argc, char **argv)
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;
@ -98,7 +98,7 @@ static int ejs_lpGet(MprVarHandle eid, int argc, char **argv)
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(),
@ -109,7 +109,7 @@ static int ejs_lpGet(MprVarHandle eid, int argc, char **argv)
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;
@ -123,7 +123,7 @@ static int ejs_lpGet(MprVarHandle eid, int argc, char **argv)
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) {
@ -166,7 +166,7 @@ static int ejs_lpGet(MprVarHandle eid, int argc, char **argv)
*/
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;
}
@ -184,7 +184,7 @@ static int ejs_lpSet(MprVarHandle eid, int argc, char **argv)
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;
}
@ -196,9 +196,9 @@ static int ejs_lpSet(MprVarHandle eid, int argc, char **argv)
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;
}

4
source4/scripting/ejs/smbcalls_creds.c
View File

@ -192,7 +192,7 @@ static int ejs_creds_set_machine_account(MprVarHandle eid, int argc, struct MprV
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));
@ -248,7 +248,7 @@ static int ejs_credentials_init(MprVarHandle eid, int argc, struct MprVar **argv
return -1;
}
cli_credentials_set_conf(creds, global_loadparm);
cli_credentials_set_conf(creds, mprLpCtx());
return ejs_credentials_obj(obj, creds);
}

4
source4/scripting/ejs/smbcalls_data.c
View File

@ -177,7 +177,7 @@ static int ejs_regToVar(MprVarHandle eid, int argc, struct MprVar **argv)
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");
@ -225,7 +225,7 @@ static int ejs_regToVar(MprVarHandle eid, int argc, struct MprVar **argv)
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");

2
source4/scripting/ejs/smbcalls_ldb.c
View File

@ -453,7 +453,7 @@ static int ejs_ldbConnect(MprVarHandle eid, int argc, char **argv)
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) {

2
source4/scripting/ejs/smbcalls_nbt.c
View File

@ -70,7 +70,7 @@ static int ejs_resolve_name(MprVarHandle eid, int argc, struct MprVar **argv)
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));

2
source4/scripting/ejs/smbcalls_reg.c
View File

@ -70,7 +70,7 @@ static int ejs_reg_open(MprVarHandle eid, int argc, struct MprVar **argv)
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);

6
source4/scripting/ejs/smbcalls_rpc.c
View File

@ -79,9 +79,9 @@ static int ejs_irpc_connect(MprVarHandle eid, int argc, char **argv)
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;
}
@ -161,7 +161,7 @@ static int ejs_rpc_connect(MprVarHandle eid, int argc, char **argv)
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 */

2
source4/scripting/ejs/smbcalls_sys.c
View File

@ -36,7 +36,7 @@ static int ejs_sys_interfaces(MprVarHandle eid, int argc, struct MprVar **argv)
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++) {

2
source4/smb_server/smb/request.c
View File

@ -423,7 +423,7 @@ size_t req_push_str(struct smbsrv_request *req, uint8_t *dest, const char *str,
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);

2
source4/smb_server/smb_server.c
View File

@ -146,7 +146,7 @@ static void smbsrv_accept(struct stream_connection *conn)
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;

4
source4/torture/ldap/cldap.c
View File

@ -38,7 +38,7 @@
*/
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;
@ -244,7 +244,7 @@ static void cldap_dump_results(struct cldap_search *search)
*/
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 };

2
source4/torture/ldap/cldapbench.c
View File

@ -51,7 +51,7 @@ static void request_handler(struct cldap_request *req)
*/
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;

3
source4/torture/nbt/query.c
View File

@ -47,7 +47,8 @@ static void increment_handler(struct nbt_name_request *req)
*/
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;

6
source4/torture/nbt/register.c
View File

@ -44,7 +44,8 @@ static bool nbt_register_own(struct torture_context *tctx)
{
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;
@ -113,7 +114,8 @@ static bool nbt_refresh_own(struct torture_context *tctx)
{
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;

2
source4/torture/nbt/wins.c
View File

@ -53,7 +53,7 @@ static bool nbt_test_wins_name(struct torture_context *tctx, const char *address
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;

2
source4/torture/nbt/winsbench.c
View File

@ -225,7 +225,7 @@ static void generate_request(struct nbt_name_socket *nbtsock, struct wins_state
*/
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;

32
source4/torture/nbt/winsreplication.c
View File

@ -103,14 +103,14 @@ static bool test_assoc_ctx1(struct torture_context *tctx)
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");
@ -186,10 +186,10 @@ static bool test_assoc_ctx2(struct torture_context *tctx)
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");
@ -255,10 +255,10 @@ static bool test_wins_replication(struct torture_context *tctx)
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");
@ -553,11 +553,11 @@ static struct test_wrepl_conflict_conn *test_create_conflict_ctx(
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);
@ -610,7 +610,7 @@ static struct test_wrepl_conflict_conn *test_create_conflict_ctx(
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);
@ -628,7 +628,7 @@ static struct test_wrepl_conflict_conn *test_create_conflict_ctx(
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 */
@ -645,13 +645,13 @@ static struct test_wrepl_conflict_conn *test_create_conflict_ctx(
}
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 */
@ -722,9 +722,9 @@ static bool test_wrepl_update_one(struct torture_context *tctx,
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);

2
source4/torture/rpc/dssync.c
View File

@ -255,7 +255,7 @@ static bool test_GetInfo(struct torture_context *tctx, struct DsSyncTest *ctx)
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;

2
source4/utils/nmblookup.c
View File

@ -211,7 +211,7 @@ static bool process_one(struct loadparm_context *lp_ctx,
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,

2
source4/winbind/wb_pam_auth.c
View File

@ -143,7 +143,7 @@ static void pam_auth_crap_recv_logon(struct composite_context *ctx)
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)) {

5
source4/wrepl_server/wrepl_out_helpers.c
View File

@ -30,6 +30,7 @@
#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,
@ -186,14 +187,14 @@ static struct composite_context *wreplsrv_out_connect_send(struct wreplsrv_partn
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;