+
+
+struct domain_list_state {
+ struct libnet_context *ctx;
+ struct libnet_RpcConnect rpcconn;
+ struct samr_Connect samrconn;
+ struct samr_EnumDomains enumdom;
+ struct samr_Close samrclose;
+ const char *hostname;
+ struct policy_handle connect_handle;
+ int buf_size;
+ struct domainlist *domains;
+ uint32_t resume_handle;
+ uint32_t count;
+
+ void (*monitor_fn)(struct monitor_msg*);
+};
+
+
+static void continue_rpc_connect(struct composite_context *c);
+static void continue_samr_connect(struct tevent_req *subreq);
+static void continue_samr_enum_domains(struct tevent_req *subreq);
+static void continue_samr_close_handle(struct tevent_req *subreq);
+
+static struct domainlist* get_domain_list(TALLOC_CTX *mem_ctx, struct domain_list_state *s);
+
+
+/*
+ Stage 1: Receive connected rpc pipe and send connection
+ request to SAMR service
+*/
+static void continue_rpc_connect(struct composite_context *ctx)
+{
+ struct composite_context *c;
+ struct domain_list_state *s;
+ struct tevent_req *subreq;
+
+ c = talloc_get_type_abort(ctx->async.private_data, struct composite_context);
+ s = talloc_get_type_abort(c->private_data, struct domain_list_state);
+
+ c->status = libnet_RpcConnect_recv(ctx, s->ctx, c, &s->rpcconn);
+ if (!composite_is_ok(c)) return;
+
+ s->samrconn.in.system_name = 0;
+ s->samrconn.in.access_mask = SEC_GENERIC_READ; /* should be enough */
+ s->samrconn.out.connect_handle = &s->connect_handle;
+
+ subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
+ s->ctx->samr.pipe->binding_handle,
+ &s->samrconn);
+ if (composite_nomem(subreq, c)) return;
+
+ tevent_req_set_callback(subreq, continue_samr_connect, c);
+}
+
+
+/*
+ Stage 2: Receive policy handle to the connected SAMR service and issue
+ a request to enumerate domain databases available
+*/
+static void continue_samr_connect(struct tevent_req *subreq)
+{
+ struct composite_context *c;
+ struct domain_list_state *s;
+
+ c = tevent_req_callback_data(subreq, struct composite_context);
+ s = talloc_get_type_abort(c->private_data, struct domain_list_state);
+
+ c->status = dcerpc_samr_Connect_r_recv(subreq, s);
+ TALLOC_FREE(subreq);
+ if (!composite_is_ok(c)) return;
+
+ if (s->monitor_fn) {
+ struct monitor_msg msg;
+
+ msg.type = mon_SamrConnect;
+ msg.data = NULL;
+ msg.data_size = 0;
+ s->monitor_fn(&msg);
+ }
+
+ s->enumdom.in.connect_handle = &s->connect_handle;
+ s->enumdom.in.resume_handle = &s->resume_handle;
+ s->enumdom.in.buf_size = s->buf_size;
+ s->enumdom.out.resume_handle = &s->resume_handle;
+ s->enumdom.out.num_entries = talloc(s, uint32_t);
+ if (composite_nomem(s->enumdom.out.num_entries, c)) return;
+ s->enumdom.out.sam = talloc(s, struct samr_SamArray *);
+ if (composite_nomem(s->enumdom.out.sam, c)) return;
+
+ subreq = dcerpc_samr_EnumDomains_r_send(s, c->event_ctx,
+ s->ctx->samr.pipe->binding_handle,
+ &s->enumdom);
+ if (composite_nomem(subreq, c)) return;
+
+ tevent_req_set_callback(subreq, continue_samr_enum_domains, c);
+}
+
+
+/*
+ Stage 3: Receive domain names available and repeat the request
+ enumeration is not complete yet. Close samr connection handle
+ upon completion.
+*/
+static void continue_samr_enum_domains(struct tevent_req *subreq)
+{
+ struct composite_context *c;
+ struct domain_list_state *s;
+
+ c = tevent_req_callback_data(subreq, struct composite_context);
+ s = talloc_get_type_abort(c->private_data, struct domain_list_state);
+
+ c->status = dcerpc_samr_EnumDomains_r_recv(subreq, s);
+ TALLOC_FREE(subreq);
+ if (!composite_is_ok(c)) return;
+
+ if (s->monitor_fn) {
+ struct monitor_msg msg;
+
+ msg.type = mon_SamrEnumDomains;
+ msg.data = NULL;
+ msg.data_size = 0;
+ s->monitor_fn(&msg);
+ }
+
+ if (NT_STATUS_IS_OK(s->enumdom.out.result)) {
+
+ s->domains = get_domain_list(c, s);
+
+ } else if (NT_STATUS_EQUAL(s->enumdom.out.result, STATUS_MORE_ENTRIES)) {
+
+ s->domains = get_domain_list(c, s);
+
+ /* prepare next round of enumeration */
+ s->enumdom.in.connect_handle = &s->connect_handle;
+ s->enumdom.in.resume_handle = &s->resume_handle;
+ s->enumdom.in.buf_size = s->ctx->samr.buf_size;
+ s->enumdom.out.resume_handle = &s->resume_handle;
+
+ /* send the request */
+ subreq = dcerpc_samr_EnumDomains_r_send(s, c->event_ctx,
+ s->ctx->samr.pipe->binding_handle,
+ &s->enumdom);
+ if (composite_nomem(subreq, c)) return;
+
+ tevent_req_set_callback(subreq, continue_samr_enum_domains, c);
+
+ } else {
+ composite_error(c, s->enumdom.out.result);
+ return;
+ }
+
+ /* close samr connection handle */
+ s->samrclose.in.handle = &s->connect_handle;
+ s->samrclose.out.handle = &s->connect_handle;
+
+ /* send the request */
+ subreq = dcerpc_samr_Close_r_send(s, c->event_ctx,
+ s->ctx->samr.pipe->binding_handle,
+ &s->samrclose);
+ if (composite_nomem(subreq, c)) return;
+
+ tevent_req_set_callback(subreq, continue_samr_close_handle, c);
+}
+
+
+/*
+ Stage 4: Receive result of closing samr connection handle.
+*/
+static void continue_samr_close_handle(struct tevent_req *subreq)
+{
+ struct composite_context *c;
+ struct domain_list_state *s;
+
+ c = tevent_req_callback_data(subreq, struct composite_context);
+ s = talloc_get_type_abort(c->private_data, struct domain_list_state);
+
+ c->status = dcerpc_samr_Close_r_recv(subreq, s);
+ TALLOC_FREE(subreq);
+ if (!composite_is_ok(c)) return;
+
+ if (s->monitor_fn) {
+ struct monitor_msg msg;
+
+ msg.type = mon_SamrClose;
+ msg.data = NULL;
+ msg.data_size = 0;
+ s->monitor_fn(&msg);
+ }
+
+ /* did everything go fine ? */
+ if (!NT_STATUS_IS_OK(s->samrclose.out.result)) {
+ composite_error(c, s->samrclose.out.result);
+ return;
+ }
+
+ composite_done(c);
+}
+
+
+/*
+ Utility function to copy domain names from result of samr_EnumDomains call
+*/
+static struct domainlist* get_domain_list(TALLOC_CTX *mem_ctx, struct domain_list_state *s)
+{
+ uint32_t i;
+ if (mem_ctx == NULL || s == NULL) return NULL;
+
+ /* prepare domains array */
+ if (s->domains == NULL) {
+ s->domains = talloc_array(mem_ctx, struct domainlist,
+ *s->enumdom.out.num_entries);
+ } else {
+ s->domains = talloc_realloc(mem_ctx, s->domains, struct domainlist,
+ s->count + *s->enumdom.out.num_entries);
+ }
+
+ /* copy domain names returned from samr_EnumDomains call */
+ for (i = s->count; i < s->count + *s->enumdom.out.num_entries; i++)
+ {
+ struct lsa_String *domain_name = &(*s->enumdom.out.sam)->entries[i - s->count].name;
+
+ /* strdup name as a child of allocated array to make it follow the array
+ in case of talloc_steal or talloc_free */
+ s->domains[i].name = talloc_strdup(s->domains, domain_name->string);
+ s->domains[i].sid = NULL; /* this is to be filled out later */
+ }
+
+ /* number of entries returned (domains enumerated) */
+ s->count += *s->enumdom.out.num_entries;
+
+ return s->domains;
+}
+
+
+/**
+ * Sends a request to list domains on given host
+ *
+ * @param ctx initialised libnet context
+ * @param mem_ctx memory context
+ * @param io arguments and results of the call
+ * @param monitor pointer to monitor function that is passed monitor messages
+ */
+
+struct composite_context* libnet_DomainList_send(struct libnet_context *ctx,
+ TALLOC_CTX *mem_ctx,
+ struct libnet_DomainList *io,
+ void (*monitor)(struct monitor_msg*))
+{
+ struct composite_context *c;
+ struct domain_list_state *s;
+ struct composite_context *rpcconn_req;
+ struct tevent_req *subreq;
+
+ /* composite context and state structure allocation */
+ c = composite_create(ctx, ctx->event_ctx);
+ if (c == NULL) return c;
+
+ s = talloc_zero(c, struct domain_list_state);
+ if (composite_nomem(s, c)) return c;
+
+ c->private_data = s;
+ s->monitor_fn = monitor;
+
+ s->ctx = ctx;
+ s->hostname = talloc_strdup(c, io->in.hostname);
+ if (composite_nomem(s->hostname, c)) return c;
+
+ /* check whether samr pipe has already been opened */
+ if (ctx->samr.pipe == NULL) {
+ ZERO_STRUCT(s->rpcconn);
+
+ /* prepare rpc connect call */
+ s->rpcconn.level = LIBNET_RPC_CONNECT_SERVER;
+ s->rpcconn.in.name = s->hostname;
+ s->rpcconn.in.dcerpc_iface = &ndr_table_samr;
+
+ rpcconn_req = libnet_RpcConnect_send(ctx, c, &s->rpcconn, s->monitor_fn);
+ if (composite_nomem(rpcconn_req, c)) return c;
+
+ composite_continue(c, rpcconn_req, continue_rpc_connect, c);
+
+ } else {
+ /* prepare samr_Connect call */
+ s->samrconn.in.system_name = 0;
+ s->samrconn.in.access_mask = SEC_GENERIC_READ;
+ s->samrconn.out.connect_handle = &s->connect_handle;
+
+ subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
+ s->ctx->samr.pipe->binding_handle,
+ &s->samrconn);
+ if (composite_nomem(subreq, c)) return c;
+
+ tevent_req_set_callback(subreq, continue_samr_connect, c);
+ }
+
+ return c;
+}
+
+
+/**
+ * Receive result of domain list request
+ *
+ * @param c composite context returned by DomainList_send function
+ * @param ctx initialised libnet context
+ * @param mem_ctx memory context of the call
+ * @param io results and arguments of the call
+ */
+
+NTSTATUS libnet_DomainList_recv(struct composite_context *c, struct libnet_context *ctx,
+ TALLOC_CTX *mem_ctx, struct libnet_DomainList *io)
+{
+ NTSTATUS status;
+ struct domain_list_state *s;
+
+ status = composite_wait(c);
+
+ s = talloc_get_type_abort(c->private_data, struct domain_list_state);
+
+ if (NT_STATUS_IS_OK(status) && ctx && mem_ctx && io) {
+ /* fetch the results to be returned by io structure */
+ io->out.count = s->count;
+ io->out.domains = talloc_steal(mem_ctx, s->domains);
+ io->out.error_string = talloc_asprintf(mem_ctx, "Success");
+
+ } else if (!NT_STATUS_IS_OK(status)) {
+ /* there was an error, so return description of the status code */
+ io->out.error_string = talloc_asprintf(mem_ctx, "Error: %s", nt_errstr(status));
+ }
+
+ talloc_free(c);
+ return status;
+}
+
+
+/**
+ * Synchronous version of DomainList call
+ *
+ * @param ctx initialised libnet context
+ * @param mem_ctx memory context for the call
+ * @param io arguments and results of the call
+ * @return nt status code of execution
+ */
+
+NTSTATUS libnet_DomainList(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
+ struct libnet_DomainList *io)
+{
+ struct composite_context *c;
+
+ c = libnet_DomainList_send(ctx, mem_ctx, io, NULL);
+ return libnet_DomainList_recv(c, ctx, mem_ctx, io);
+}
git.samba.org / bbaumbach / samba-autobuild / .git / blobdiff