libnet_domain.c

来自「samba最新软件」· C语言 代码 · 共 1,253 行 · 第 1/3 页

NTSTATUS libnet_DomainCloseSamr_recv(struct composite_context *c, struct libnet_context *ctx,
				     TALLOC_CTX *mem_ctx, struct libnet_DomainClose *io)
{
	NTSTATUS status;

	status = composite_wait(c);

	if (NT_STATUS_IS_OK(status) && io) {
		/* domain policy handle closed successfully */

		ZERO_STRUCT(ctx->samr.handle);
		talloc_free(ctx->samr.name);
		talloc_free(ctx->samr.sid);
		ctx->samr.name = NULL;
		ctx->samr.sid = NULL;

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


struct composite_context* libnet_DomainClose_send(struct libnet_context *ctx,
						  struct libnet_DomainClose *io,
						  void (*monitor)(struct monitor_msg*))
{
	struct composite_context *c;

	switch (io->in.type) {
	case DOMAIN_LSA:
		/* request to close policy handle on \pipe\lsarpc */
		c = libnet_DomainCloseLsa_send(ctx, io, monitor);
		break;

	case DOMAIN_SAMR:
	default:
		/* request to close domain policy handle on \pipe\samr */
		c = libnet_DomainCloseSamr_send(ctx, io, monitor);
		break;
	}
	
	return c;
}


NTSTATUS libnet_DomainClose_recv(struct composite_context *c, struct libnet_context *ctx,
				 TALLOC_CTX *mem_ctx, struct libnet_DomainClose *io)
{
	NTSTATUS status;

	switch (io->in.type) {
	case DOMAIN_LSA:
		/* receive result of closing lsa policy handle */
		status = libnet_DomainCloseLsa_recv(c, ctx, mem_ctx, io);
		break;

	case DOMAIN_SAMR:
	default:
		/* receive result of closing samr domain policy handle */
		status = libnet_DomainCloseSamr_recv(c, ctx, mem_ctx, io);
		break;
	}
	
	return status;
}


NTSTATUS libnet_DomainClose(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
			    struct libnet_DomainClose *io)
{
	struct composite_context *c;
	
	c = libnet_DomainClose_send(ctx, io, NULL);
	return libnet_DomainClose_recv(c, ctx, mem_ctx, io);
}


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 rpc_request *c);
static void continue_samr_enum_domains(struct rpc_request *req);
static void continue_samr_close_handle(struct rpc_request *req);

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 rpc_request *samrconn_req;

	c = talloc_get_type(ctx->async.private_data, struct composite_context);
	s = talloc_get_type(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;

	samrconn_req = dcerpc_samr_Connect_send(s->ctx->samr.pipe, c, &s->samrconn);
	if (composite_nomem(samrconn_req, c)) return;

	composite_continue_rpc(c, samrconn_req, 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 rpc_request *req)
{
	struct composite_context *c;
	struct domain_list_state *s;
	struct rpc_request *enumdom_req;

	c = talloc_get_type(req->async.private_data, struct composite_context);
	s = talloc_get_type(c->private_data, struct domain_list_state);
	
	c->status = dcerpc_ndr_request_recv(req);
	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;

	enumdom_req = dcerpc_samr_EnumDomains_send(s->ctx->samr.pipe, c, &s->enumdom);
	if (composite_nomem(enumdom_req, c)) return;

	composite_continue_rpc(c, enumdom_req, 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 rpc_request *req)
{
	struct composite_context *c;
	struct domain_list_state *s;
	struct rpc_request *enumdom_req;
	struct rpc_request *samrclose_req;

	c = talloc_get_type(req->async.private_data, struct composite_context);
	s = talloc_get_type(c->private_data, struct domain_list_state);
	
	c->status = dcerpc_ndr_request_recv(req);
	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 */
		enumdom_req = dcerpc_samr_EnumDomains_send(s->ctx->samr.pipe, c, &s->enumdom);
		if (composite_nomem(enumdom_req, c)) return;

		composite_continue_rpc(c, enumdom_req, 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 */
	samrclose_req = dcerpc_samr_Close_send(s->ctx->samr.pipe, c, &s->samrclose);
	if (composite_nomem(samrclose_req, c)) return;

	composite_continue_rpc(c, samrclose_req, continue_samr_close_handle, c);
}


/*
  Stage 4: Receive result of closing samr connection handle.
*/
static void continue_samr_close_handle(struct rpc_request *req)
{
	struct composite_context *c;
	struct domain_list_state *s;

	c = talloc_get_type(req->async.private_data, struct composite_context);
	s = talloc_get_type(c->private_data, struct domain_list_state);

	c->status = dcerpc_ndr_request_recv(req);
	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);
	}

	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)
{
	int 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 initalised 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 rpc_request *samrconn_req;

	/* 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) {
		/* 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;
		
		samrconn_req = dcerpc_samr_Connect_send(s->ctx->samr.pipe, c, &s->samrconn);
		if (composite_nomem(samrconn_req, c)) return c;

		composite_continue_rpc(c, samrconn_req, 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(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);
}