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; }