static NTSTATUS mapiproxy_op_connect(struct dcesrv_call_state *dce_call,
const struct ndr_interface_table *table,
const char *binding)
{
NTSTATUS status;
struct dcesrv_mapiproxy_private *private;
const char *user;
const char *pass;
const char *domain;
struct cli_credentials *credentials;
bool acquired_creds = false;
bool machine_account;
OC_DEBUG(5, "mapiproxy::mapiproxy_op_connect");
/* Retrieve the binding string from parametric options if undefined */
if (!binding) {
binding = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_mapiproxy", "binding");
if (!binding) {
OC_DEBUG(0, "You must specify a DCE/RPC binding string");
return NT_STATUS_INVALID_PARAMETER;
}
}
/* Retrieve parametric options */
machine_account = lpcfg_parm_bool(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_mapiproxy", "use_machine_account", false);
user = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_mapiproxy", "username");
pass = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_mapiproxy", "password");
domain = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_mapiproxy", "domain");
/* Retrieve private mapiproxy data */
private = dce_call->context->private_data;
static NTSTATUS remote_op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
{
unsigned int i;
char **ifaces = str_list_make(dce_ctx, lpcfg_parm_string(dce_ctx->lp_ctx, NULL, "dcerpc_remote", "interfaces"),NULL);
if (!ifaces) {
DEBUG(3,("remote_op_init_server: no interfaces configured\n"));
return NT_STATUS_OK;
}
for (i=0;ifaces[i];i++) {
NTSTATUS ret;
struct dcesrv_interface iface;
if (!ep_server->interface_by_name(&iface, ifaces[i])) {
DEBUG(0,("remote_op_init_server: failed to find interface = '%s'\n", ifaces[i]));
talloc_free(ifaces);
return NT_STATUS_UNSUCCESSFUL;
}
ret = remote_register_one_iface(dce_ctx, &iface);
if (!NT_STATUS_IS_OK(ret)) {
DEBUG(0,("remote_op_init_server: failed to register interface = '%s'\n", ifaces[i]));
talloc_free(ifaces);
return ret;
}
}
talloc_free(ifaces);
return NT_STATUS_OK;
}
/**
\details Initialize ldb_context to samdb, creates one for all emsmdbp
contexts
\param lp_ctx pointer to the loadparm context
*/
static struct ldb_context *samdb_init(struct loadparm_context *lp_ctx)
{
TALLOC_CTX *mem_ctx;
struct tevent_context *ev;
const char *samdb_url;
if (samdb_ctx) return samdb_ctx;
mem_ctx = talloc_autofree_context();
ev = tevent_context_init(mem_ctx);
if (!ev) {
OC_PANIC(false, ("Fail to initialize tevent_context\n"));
return NULL;
}
tevent_loop_allow_nesting(ev);
/* Retrieve samdb url (local or external) */
samdb_url = lpcfg_parm_string(lp_ctx, NULL, "dcerpc_mapiproxy", "samdb_url");
if (!samdb_url) {
samdb_ctx = samdb_connect(mem_ctx, ev, lp_ctx, system_session(lp_ctx), 0);
} else {
samdb_ctx = samdb_connect_url(mem_ctx, ev, lp_ctx, system_session(lp_ctx),
LDB_FLG_RECONNECT, samdb_url);
}
return samdb_ctx;
}
/**
\details Initialize the EMSABP context and open connections to
Samba databases.
\param lp_ctx pointer to the loadparm context
\param tdb_ctx pointer to the EMSABP TDB context
\return Allocated emsabp_context on success, otherwise NULL
*/
_PUBLIC_ struct emsabp_context *emsabp_init(struct loadparm_context *lp_ctx,
TDB_CONTEXT *tdb_ctx)
{
TALLOC_CTX *mem_ctx;
struct emsabp_context *emsabp_ctx;
struct tevent_context *ev;
const char *samdb_url;
/* Sanity checks */
if (!lp_ctx) return NULL;
mem_ctx = talloc_named(NULL, 0, "emsabp_init");
emsabp_ctx = talloc_zero(mem_ctx, struct emsabp_context);
if (!emsabp_ctx) {
talloc_free(mem_ctx);
return NULL;
}
emsabp_ctx->mem_ctx = mem_ctx;
ev = tevent_context_init(mem_ctx);
if (!ev) {
talloc_free(mem_ctx);
return NULL;
}
tevent_loop_allow_nesting(ev);
/* Save a pointer to the loadparm context */
emsabp_ctx->lp_ctx = lp_ctx;
/* Retrieve samdb url (local or external) */
samdb_url = lpcfg_parm_string(lp_ctx, NULL, "dcerpc_mapiproxy", "samdb_url");
/* return an opaque context pointer on samDB database */
if (!samdb_url) {
emsabp_ctx->samdb_ctx = samdb_connect(mem_ctx, ev, lp_ctx, system_session(lp_ctx), 0);
} else {
emsabp_ctx->samdb_ctx = samdb_connect_url(mem_ctx, ev, lp_ctx, system_session(lp_ctx), 0, samdb_url);
}
if (!emsabp_ctx->samdb_ctx) {
talloc_free(mem_ctx);
DEBUG(0, ("[%s:%d]: Connection to \"sam.ldb\" failed\n", __FUNCTION__, __LINE__));
return NULL;
}
/* Reference the global TDB context to the current emsabp context */
emsabp_ctx->tdb_ctx = tdb_ctx;
/* Initialize a temporary (on-memory) TDB database to store
* temporary MId used within EMSABP */
emsabp_ctx->ttdb_ctx = emsabp_tdb_init_tmp(emsabp_ctx->mem_ctx);
if (!emsabp_ctx->ttdb_ctx) {
smb_panic("unable to create on-memory TDB database");
}
return emsabp_ctx;
}
static int wins_ldb_init(struct ldb_module *module)
{
struct ldb_context *ldb = ldb_module_get_ctx(module);
struct winsdb_handle *h;
const char *owner;
struct loadparm_context *lp_ctx = ldb_get_opaque(ldb, "loadparm");
ldb_module_set_private(module, NULL);
owner = lpcfg_parm_string(lp_ctx, NULL, "winsdb", "local_owner");
if (!owner) {
struct interface *ifaces;
load_interface_list(module, lp_ctx, &ifaces);
owner = iface_list_first_v4(ifaces);
if (!owner) {
owner = "0.0.0.0";
}
}
h = talloc_zero(module, struct winsdb_handle);
if (!h) goto failed;
h->ldb = ldb;
h->caller = WINSDB_HANDLE_CALLER_ADMIN;
h->local_owner = talloc_strdup(h, owner);
if (!h->local_owner) goto failed;
return ldb_set_opaque(ldb, "winsdb_handle", h);
failed:
talloc_free(h);
return LDB_ERR_OTHER;
}
static void nbtd_wins_randomize1Clist(struct loadparm_context *lp_ctx,
const char **addresses, struct socket_address *src)
{
const char *mask;
const char *tmp;
uint32_t num_addrs;
uint32_t idx, sidx;
int r;
for (num_addrs=0; addresses[num_addrs]; num_addrs++) { /* noop */ }
if (num_addrs <= 1) return; /* nothing to do */
/* first sort the addresses depending on the matching to the client */
LDB_TYPESAFE_QSORT(addresses, num_addrs, src, nbtd_wins_randomize1Clist_sort);
mask = lpcfg_parm_string(lp_ctx, NULL, "nbtd", "wins_randomize1Clist_mask");
if (!mask) {
mask = "255.255.255.0";
}
/*
* choose a random address to be the first in the response to the client,
* prefer the addresses inside the nbtd:wins_randomize1Clist_mask netmask
*/
r = random();
idx = sidx = r % num_addrs;
while (1) {
bool same;
/* if the current one is in the same subnet, use it */
same = iface_list_same_net(addresses[idx], src->addr, mask);
if (same) {
sidx = idx;
break;
}
/* we need to check for idx == 0, after checking for the same net */
if (idx == 0) break;
/*
* if we haven't found an address in the same subnet, search in ones
* which match the client more
*
* some notes:
*
* it's not "idx = idx % r" but "idx = r % idx"
* because in "a % b" b is the allowed range
* and b-1 is the maximum possible result, so it must be decreasing
* and the above idx == 0 check breaks the while(1) loop.
*/
idx = r % idx;
}
/* note sidx == 0 is also valid here ... */
tmp = addresses[0];
addresses[0] = addresses[sidx];
addresses[sidx] = tmp;
}
static bool test_set_option_parametric(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
torture_assert(tctx, lpcfg_set_option(lp_ctx, "some:thing=blaat"), "lpcfg_set_option failed");
torture_assert_str_equal(tctx, lpcfg_parm_string(lp_ctx, NULL, "some", "thing"), "blaat",
"invalid parametric option");
return true;
}
static bool test_lp_do_service_parameter(struct torture_context *tctx)
{
struct loadparm_context *lp_ctx = loadparm_init(tctx);
struct loadparm_service *service = lpcfg_add_service(lp_ctx, lpcfg_default_service(lp_ctx), "foo");
torture_assert(tctx, lpcfg_do_service_parameter(lp_ctx, service,
"some:thing", "foo"), "lpcfg_set_option failed");
torture_assert_str_equal(tctx, lpcfg_parm_string(lp_ctx, service, "some", "thing"), "foo",
"invalid parametric option");
return true;
}
/*
generate a smbd config file for the file server
*/
static const char *generate_smb_conf(struct task_server *task)
{
int fd;
struct loadparm_context *lp_ctx = task->lp_ctx;
const char *path = smbd_tmp_path(task, lp_ctx, "fileserver.conf");
if (path == NULL) {
return NULL;
}
fd = open(path, O_WRONLY|O_CREAT|O_TRUNC, 0644);
if (fd == -1) {
DEBUG(0,("Failed to create %s", path));
return NULL;
}
fdprintf(fd, "# auto-generated config for fileserver\n");
fdprintf(fd, "auth methods = guest samba4\n");
fdprintf(fd, "passdb backend = samba4\n");
fdprintf(fd, "rpc_server:default = external\n");
fdprintf(fd, "rpc_server:dssetup = disabled\n");
fdprintf(fd, "rpc_server:spoolss = embedded\n");
fdprintf(fd, "rpc_daemon:spoolssd = disabled\n");
fdprintf(fd, "rpc_server:tcpip = no\n");
/* If we are using xattr_tdb:file or posix:eadb then we need to load another VFS object */
if (lpcfg_parm_string(lp_ctx, NULL, "xattr_tdb", "file")) {
fdprintf(fd, "vfs objects = acl_xattr xattr_tdb\n");
} else if (lpcfg_parm_string(lp_ctx, NULL, "posix", "eadb")) {
fdprintf(fd, "vfs objects = acl_xattr posix_eadb\n");
} else {
fdprintf(fd, "vfs objects = acl_xattr\n");
}
fdprintf(fd, "include = %s\n", lpcfg_configfile(lp_ctx));
fdprintf(fd, "[IPC$]\n");
fdprintf(fd, " vfs objects = dfs_samba4\n");
close(fd);
return path;
}
/**
\details Dummy init function which reads a parametric option from
smb.conf and display it on the log channel.
*/
static NTSTATUS dummy_init(struct dcesrv_context *dce_ctx)
{
const char *test;
test = lpcfg_parm_string(dce_ctx->lp_ctx, NULL, "mpm_dummy", "test");
if (test) {
OC_DEBUG(0, "Sample dummy string: %s", test);
}
return NT_STATUS_OK;
}
const char *torture_setting_string(struct torture_context *test,
const char *name,
const char *default_value)
{
const char *ret;
SMB_ASSERT(test != NULL);
SMB_ASSERT(test->lp_ctx != NULL);
ret = lpcfg_parm_string(test->lp_ctx, NULL, "torture", name);
if (ret == NULL)
return default_value;
return ret;
}
/*
initialise a server_context from a open socket and register a event handler
for reading from that socket
*/
static void samba3_smb_accept(struct stream_connection *conn)
{
int i;
int fd = socket_get_fd(conn->socket);
const char *prog;
char *argv[2];
char *reason;
close(0);
close(1);
dup2(fd, 0);
dup2(fd, 1);
dup2(fd, 2);
for (i=3;i<256;i++) {
close(i);
}
prog = lpcfg_parm_string(conn->lp_ctx, NULL, "samba3", "smbd");
if (prog == NULL) {
argv[0] = talloc_asprintf(conn, "%s/%s", dyn_BINDIR, "smbd3");
}
else {
argv[0] = talloc_strdup(conn, prog);
}
if (argv[0] == NULL) {
stream_terminate_connection(conn, "out of memory");
return;
}
argv[1] = NULL;
execv(argv[0], argv);
/*
* Should never get here
*/
reason = talloc_asprintf(conn, "Could not execute %s", argv[0]);
if (reason == NULL) {
stream_terminate_connection(conn, "out of memory");
return;
}
stream_terminate_connection(conn, reason);
talloc_free(reason);
}
static bool init_witness_test_state(struct torture_context *tctx,
struct dcerpc_pipe *p,
struct torture_test_witness_state *state)
{
if (state->net_name == NULL) {
state->net_name = lpcfg_parm_string(tctx->lp_ctx, NULL, "torture", "net_name");
}
if (state->list == NULL) {
torture_assert(tctx,
test_witness_GetInterfaceList(tctx, p, state),
"failed to retrieve GetInterfaceList");
}
if (state->share_name == NULL) {
find_sofs_share(tctx, &state->share_name);
}
return true;
}
/*
startup the WINS server, if configured
*/
NTSTATUS nbtd_winsserver_init(struct nbtd_server *nbtsrv)
{
uint32_t tmp;
const char *owner;
if (!lpcfg_we_are_a_wins_server(nbtsrv->task->lp_ctx)) {
nbtsrv->winssrv = NULL;
return NT_STATUS_OK;
}
nbtsrv->winssrv = talloc_zero(nbtsrv, struct wins_server);
NT_STATUS_HAVE_NO_MEMORY(nbtsrv->winssrv);
nbtsrv->winssrv->config.max_renew_interval = lpcfg_max_wins_ttl(nbtsrv->task->lp_ctx);
nbtsrv->winssrv->config.min_renew_interval = lpcfg_min_wins_ttl(nbtsrv->task->lp_ctx);
tmp = lpcfg_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv", "tombstone_interval", 6*24*60*60);
nbtsrv->winssrv->config.tombstone_interval = tmp;
tmp = lpcfg_parm_int(nbtsrv->task->lp_ctx, NULL, "wreplsrv"," tombstone_timeout", 1*24*60*60);
nbtsrv->winssrv->config.tombstone_timeout = tmp;
owner = lpcfg_parm_string(nbtsrv->task->lp_ctx, NULL, "winsdb", "local_owner");
if (owner == NULL) {
struct interface *ifaces;
load_interface_list(nbtsrv->task, nbtsrv->task->lp_ctx, &ifaces);
owner = iface_list_first_v4(ifaces);
}
nbtsrv->winssrv->wins_db = winsdb_connect(nbtsrv->winssrv, nbtsrv->task->event_ctx,
nbtsrv->task->lp_ctx,
owner, WINSDB_HANDLE_CALLER_NBTD);
if (!nbtsrv->winssrv->wins_db) {
return NT_STATUS_INTERNAL_DB_ERROR;
}
irpc_add_name(nbtsrv->task->msg_ctx, "wins_server");
return NT_STATUS_OK;
}
/**
\details Retrieve MySQL backend parametric options from
configuration file and store them into a data structure.
\param lp_ctx Pointer to the loadparm context
\param p pointer to the structure with individual
parameters to return
\return MAPISTORE_SUCCES on success, otherwise MAPISTORE error
*/
enum mapistore_error mapistore_namedprops_mysql_parameters(struct loadparm_context *lp_ctx,
struct namedprops_mysql_params *p)
{
/* Sanity checks */
MAPISTORE_RETVAL_IF(!lp_ctx, MAPISTORE_ERR_INVALID_PARAMETER, NULL);
MAPISTORE_RETVAL_IF(!p, MAPISTORE_ERR_INVALID_PARAMETER, NULL);
/* Retrieve parametric options */
p->data = lpcfg_parm_string(lp_ctx, NULL, "namedproperties", "mysql_data");
p->sock = lpcfg_parm_string(lp_ctx, NULL, "namedproperties", "mysql_sock");
p->user = lpcfg_parm_string(lp_ctx, NULL, "namedproperties", "mysql_user");
p->pass = lpcfg_parm_string(lp_ctx, NULL, "namedproperties", "mysql_pass");
p->host = lpcfg_parm_string(lp_ctx, NULL, "namedproperties", "mysql_host");
p->port = lpcfg_parm_int(lp_ctx, NULL, "namedproperties", "mysql_port", 3306);
p->db = lpcfg_parm_string(lp_ctx, NULL, "namedproperties", "mysql_db");
/* Enforce the logic */
MAPISTORE_RETVAL_IF(!p->user, MAPISTORE_ERR_BACKEND_INIT, NULL);
MAPISTORE_RETVAL_IF(!p->db, MAPISTORE_ERR_BACKEND_INIT, NULL);
MAPISTORE_RETVAL_IF(!p->host && !p->sock, MAPISTORE_ERR_BACKEND_INIT, NULL);
return MAPISTORE_SUCCESS;
}
if (server_mode == true) {
DEBUG(0, ("MAPIPROXY proxy mode disabled\n"));
for (i = 0; server_name[i]; i++) {
server = talloc_zero(dce_ctx, struct mapiproxy_module_list);
server->module = mapiproxy_server_bystatus(server_name[i], MAPIPROXY_DEFAULT);
if (server->module) {
DLIST_ADD_END(server_list, server, struct mapiproxy_module_list *);
} else {
DEBUG(0, ("MAPIPROXY ERROR: couldn't load server '%s'\n", server_name[i]));
}
}
}
/* Check for override/custom NSPI server */
nspi = lpcfg_parm_string(dce_ctx->lp_ctx, NULL, "dcerpc_mapiproxy", "nspi_server");
mapiproxy_server_overwrite(dce_ctx, nspi, NDR_EXCHANGE_NSP_NAME);
/* Check for override/custom EMSMDB server */
emsmdb = lpcfg_parm_string(dce_ctx->lp_ctx, NULL, "dcerpc_mapiproxy", "emsmdb_server");
mapiproxy_server_overwrite(dce_ctx, emsmdb, NDR_EXCHANGE_EMSMDB_NAME);
/* Check for override/custom RFR server */
rfr = lpcfg_parm_string(dce_ctx->lp_ctx, NULL, "dcerpc_mapiproxy", "rfr_server");
mapiproxy_server_overwrite(dce_ctx, rfr, NDR_EXCHANGE_DS_RFR_NAME);
for (server = server_list; server; server = server->next) {
DEBUG(3, ("mapiproxy_server_load '%s' (%s)\n",
server->module->name, server->module->description));
if (server->module->init) {
status = server->module->init(dce_ctx);
static NTSTATUS remote_op_bind(struct dcesrv_call_state *dce_call, const struct dcesrv_interface *iface, uint32_t if_version)
{
NTSTATUS status;
const struct ndr_interface_table *table;
struct dcesrv_remote_private *priv;
const char *binding = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "binding");
const char *user, *pass, *domain;
struct cli_credentials *credentials;
bool must_free_credentials = true;
bool machine_account;
struct dcerpc_binding *b;
struct composite_context *pipe_conn_req;
machine_account = lpcfg_parm_bool(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "use_machine_account", false);
priv = talloc(dce_call->conn, struct dcesrv_remote_private);
if (!priv) {
return NT_STATUS_NO_MEMORY;
}
priv->c_pipe = NULL;
dce_call->context->private_data = priv;
if (!binding) {
DEBUG(0,("You must specify a DCE/RPC binding string\n"));
return NT_STATUS_INVALID_PARAMETER;
}
user = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "user");
pass = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dcerpc_remote", "password");
domain = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dceprc_remote", "domain");
table = ndr_table_by_syntax(&iface->syntax_id);
if (!table) {
dce_call->fault_code = DCERPC_FAULT_UNK_IF;
return NT_STATUS_NET_WRITE_FAULT;
}
if (user && pass) {
DEBUG(5, ("dcerpc_remote: RPC Proxy: Using specified account\n"));
credentials = cli_credentials_init(priv);
if (!credentials) {
return NT_STATUS_NO_MEMORY;
}
cli_credentials_set_conf(credentials, dce_call->conn->dce_ctx->lp_ctx);
cli_credentials_set_username(credentials, user, CRED_SPECIFIED);
if (domain) {
cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
}
cli_credentials_set_password(credentials, pass, CRED_SPECIFIED);
} else if (machine_account) {
DEBUG(5, ("dcerpc_remote: RPC Proxy: Using machine account\n"));
credentials = cli_credentials_init(priv);
cli_credentials_set_conf(credentials, dce_call->conn->dce_ctx->lp_ctx);
if (domain) {
cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
}
status = cli_credentials_set_machine_account(credentials, dce_call->conn->dce_ctx->lp_ctx);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
} else if (dce_call->conn->auth_state.session_info->credentials) {
DEBUG(5, ("dcerpc_remote: RPC Proxy: Using delegated credentials\n"));
credentials = dce_call->conn->auth_state.session_info->credentials;
must_free_credentials = false;
} else {
DEBUG(1,("dcerpc_remote: RPC Proxy: You must supply binding, user and password or have delegated credentials\n"));
return NT_STATUS_INVALID_PARAMETER;
}
/* parse binding string to the structure */
status = dcerpc_parse_binding(dce_call->context, binding, &b);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Failed to parse dcerpc binding '%s'\n", binding));
return status;
}
/* If we already have a remote association group ID, then use that */
if (dce_call->context->assoc_group->proxied_id != 0) {
status = dcerpc_binding_set_assoc_group_id(b,
dce_call->context->assoc_group->proxied_id);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("dcerpc_binding_set_assoc_group_id() - %s'\n",
nt_errstr(status)));
return status;
}
}
status = dcerpc_binding_set_abstract_syntax(b, &iface->syntax_id);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("dcerpc_binding_set_abstract_syntax() - %s'\n",
nt_errstr(status)));
return status;
}
DEBUG(3, ("Using binding %s\n", dcerpc_binding_string(dce_call->context, b)));
pipe_conn_req = dcerpc_pipe_connect_b_send(dce_call->context, b, table,
credentials, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx);
status = dcerpc_pipe_connect_b_recv(pipe_conn_req, dce_call->context, &(priv->c_pipe));
if (must_free_credentials) {
talloc_free(credentials);
}
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (dce_call->context->assoc_group->proxied_id == 0) {
dce_call->context->assoc_group->proxied_id =
dcerpc_binding_get_assoc_group_id(priv->c_pipe->binding);
}
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NT_STATUS_OK;
}
bool torture_net_become_dc(struct torture_context *torture)
{
bool ret = true;
NTSTATUS status;
struct libnet_BecomeDC b;
struct libnet_UnbecomeDC u;
struct libnet_vampire_cb_state *s;
struct ldb_message *msg;
int ldb_ret;
uint32_t i;
char *private_dir;
const char *address;
struct nbt_name name;
const char *netbios_name;
struct cli_credentials *machine_account;
struct test_join *tj;
struct loadparm_context *lp_ctx;
struct ldb_context *ldb;
struct libnet_context *ctx;
struct dsdb_schema *schema;
char *location = NULL;
torture_assert_ntstatus_ok(torture, torture_temp_dir(torture, "libnet_BecomeDC", &location),
"torture_temp_dir should return NT_STATUS_OK" );
netbios_name = lpcfg_parm_string(torture->lp_ctx, NULL, "become dc", "smbtorture dc");
if (!netbios_name || !netbios_name[0]) {
netbios_name = "smbtorturedc";
}
make_nbt_name_server(&name, torture_setting_string(torture, "host", NULL));
/* do an initial name resolution to find its IP */
status = resolve_name_ex(lpcfg_resolve_context(torture->lp_ctx),
0, 0,
&name, torture, &address, torture->ev);
torture_assert_ntstatus_ok(torture, status, talloc_asprintf(torture,
"Failed to resolve %s - %s\n",
name.name, nt_errstr(status)));
/* Join domain as a member server. */
tj = torture_join_domain(torture, netbios_name,
ACB_WSTRUST,
&machine_account);
torture_assert(torture, tj, talloc_asprintf(torture,
"%s failed to join domain as workstation\n",
netbios_name));
s = libnet_vampire_cb_state_init(torture, torture->lp_ctx, torture->ev,
netbios_name,
torture_join_dom_netbios_name(tj),
torture_join_dom_dns_name(tj),
location);
torture_assert(torture, s, "libnet_vampire_cb_state_init");
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
ctx->cred = cmdline_credentials;
ZERO_STRUCT(b);
b.in.domain_dns_name = torture_join_dom_dns_name(tj);
b.in.domain_netbios_name = torture_join_dom_netbios_name(tj);
b.in.domain_sid = torture_join_sid(tj);
b.in.source_dsa_address = address;
b.in.dest_dsa_netbios_name = netbios_name;
b.in.callbacks.private_data = s;
b.in.callbacks.check_options = libnet_vampire_cb_check_options;
b.in.callbacks.prepare_db = libnet_vampire_cb_prepare_db;
b.in.callbacks.schema_chunk = libnet_vampire_cb_schema_chunk;
b.in.callbacks.config_chunk = libnet_vampire_cb_store_chunk;
b.in.callbacks.domain_chunk = libnet_vampire_cb_store_chunk;
status = libnet_BecomeDC(ctx, s, &b);
torture_assert_ntstatus_ok_goto(torture, status, ret, cleanup, talloc_asprintf(torture,
"libnet_BecomeDC() failed - %s %s\n",
nt_errstr(status), b.out.error_string));
ldb = libnet_vampire_cb_ldb(s);
msg = ldb_msg_new(s);
torture_assert_int_equal_goto(torture, (msg?1:0), 1, ret, cleanup,
"ldb_msg_new() failed\n");
msg->dn = ldb_dn_new(msg, ldb, "@ROOTDSE");
torture_assert_int_equal_goto(torture, (msg->dn?1:0), 1, ret, cleanup,
"ldb_msg_new(@ROOTDSE) failed\n");
ldb_ret = ldb_msg_add_string(msg, "isSynchronized", "TRUE");
torture_assert_int_equal_goto(torture, ldb_ret, LDB_SUCCESS, ret, cleanup,
"ldb_msg_add_string(msg, isSynchronized, TRUE) failed\n");
for (i=0; i < msg->num_elements; i++) {
msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
}
torture_comment(torture, "mark ROOTDSE with isSynchronized=TRUE\n");
ldb_ret = ldb_modify(libnet_vampire_cb_ldb(s), msg);
torture_assert_int_equal_goto(torture, ldb_ret, LDB_SUCCESS, ret, cleanup,
"ldb_modify() failed\n");
/* commit the transaction now we know the secrets were written
* out properly
*/
ldb_ret = ldb_transaction_commit(ldb);
torture_assert_int_equal_goto(torture, ldb_ret, LDB_SUCCESS, ret, cleanup,
"ldb_transaction_commit() failed\n");
/* reopen the ldb */
talloc_unlink(s, ldb);
lp_ctx = libnet_vampire_cb_lp_ctx(s);
private_dir = talloc_asprintf(s, "%s/%s", location, "private");
lpcfg_set_cmdline(lp_ctx, "private dir", private_dir);
torture_comment(torture, "Reopen the SAM LDB with system credentials and all replicated data: %s\n", private_dir);
ldb = samdb_connect(s, torture->ev, lp_ctx, system_session(lp_ctx), 0);
torture_assert_goto(torture, ldb != NULL, ret, cleanup,
talloc_asprintf(torture,
"Failed to open '%s/sam.ldb'\n", private_dir));
torture_assert_goto(torture, dsdb_uses_global_schema(ldb), ret, cleanup,
"Uses global schema");
schema = dsdb_get_schema(ldb, s);
torture_assert_goto(torture, schema != NULL, ret, cleanup,
"Failed to get loaded dsdb_schema\n");
/* Make sure we get this from the command line */
if (lpcfg_parm_bool(torture->lp_ctx, NULL, "become dc", "do not unjoin", false)) {
talloc_free(s);
return ret;
}
cleanup:
ZERO_STRUCT(u);
u.in.domain_dns_name = torture_join_dom_dns_name(tj);
u.in.domain_netbios_name = torture_join_dom_netbios_name(tj);
u.in.source_dsa_address = address;
u.in.dest_dsa_netbios_name = netbios_name;
status = libnet_UnbecomeDC(ctx, s, &u);
torture_assert_ntstatus_ok(torture, status, talloc_asprintf(torture,
"libnet_UnbecomeDC() failed - %s %s\n",
nt_errstr(status), u.out.error_string));
/* Leave domain. */
torture_leave_domain(torture, tj);
talloc_free(s);
return ret;
}
/**
\details Initialize the EMSMDBP context and open connections to
Samba databases.
\param lp_ctx pointer to the loadparm_context
\param username account name for current session
\param ldb_ctx pointer to the openchange dispatcher ldb database
\return Allocated emsmdbp_context pointer on success, otherwise
NULL
*/
_PUBLIC_ struct emsmdbp_context *emsmdbp_init(struct loadparm_context *lp_ctx,
const char *username,
void *oc_ctx)
{
TALLOC_CTX *mem_ctx;
struct emsmdbp_context *emsmdbp_ctx;
struct tevent_context *ev;
enum mapistore_error ret;
const char *samdb_url;
/* Sanity Checks */
if (!lp_ctx) return NULL;
mem_ctx = talloc_named(NULL, 0, "emsmdbp_init");
emsmdbp_ctx = talloc_zero(mem_ctx, struct emsmdbp_context);
if (!emsmdbp_ctx) {
talloc_free(mem_ctx);
return NULL;
}
emsmdbp_ctx->mem_ctx = mem_ctx;
ev = tevent_context_init(mem_ctx);
if (!ev) {
talloc_free(mem_ctx);
return NULL;
}
tevent_loop_allow_nesting(ev);
/* Save a pointer to the loadparm context */
emsmdbp_ctx->lp_ctx = lp_ctx;
/* Retrieve samdb url (local or external) */
samdb_url = lpcfg_parm_string(lp_ctx, NULL, "dcerpc_mapiproxy", "samdb_url");
/* return an opaque context pointer on samDB database */
if (!samdb_url) {
emsmdbp_ctx->samdb_ctx = samdb_connect(mem_ctx, ev, lp_ctx, system_session(lp_ctx), 0);
} else {
emsmdbp_ctx->samdb_ctx = samdb_connect_url(mem_ctx, ev, lp_ctx, system_session(lp_ctx), 0, samdb_url);
}
if (!emsmdbp_ctx->samdb_ctx) {
talloc_free(mem_ctx);
DEBUG(0, ("[%s:%d]: Connection to \"sam.ldb\" failed\n", __FUNCTION__, __LINE__));
return NULL;
}
/* Reference global OpenChange dispatcher database pointer within current context */
emsmdbp_ctx->oc_ctx = oc_ctx;
/* Initialize the mapistore context */
emsmdbp_ctx->mstore_ctx = mapistore_init(mem_ctx, lp_ctx, NULL);
if (!emsmdbp_ctx->mstore_ctx) {
DEBUG(0, ("[%s:%d]: MAPISTORE initialization failed\n", __FUNCTION__, __LINE__));
talloc_free(mem_ctx);
return NULL;
}
ret = mapistore_set_connection_info(emsmdbp_ctx->mstore_ctx, emsmdbp_ctx->samdb_ctx, emsmdbp_ctx->oc_ctx, username);
if (ret != MAPISTORE_SUCCESS) {
DEBUG(0, ("[%s:%d]: MAPISTORE connection info initialization failed\n", __FUNCTION__, __LINE__));
talloc_free(mem_ctx);
return NULL;
}
talloc_set_destructor((void *)emsmdbp_ctx->mstore_ctx, (int (*)(void *))emsmdbp_mapi_store_destructor);
/* Initialize MAPI handles context */
emsmdbp_ctx->handles_ctx = mapi_handles_init(mem_ctx);
if (!emsmdbp_ctx->handles_ctx) {
DEBUG(0, ("[%s:%d]: MAPI handles context initialization failed\n", __FUNCTION__, __LINE__));
talloc_free(mem_ctx);
return NULL;
}
talloc_set_destructor((void *)emsmdbp_ctx->handles_ctx, (int (*)(void *))emsmdbp_mapi_handles_destructor);
return emsmdbp_ctx;
}