Ejemplo n.º 1
0
/*
  put a packet in the send queue.  When the packet is actually sent,
  call send_callback.  

  Useful for operations that must occur after sending a message, such
  as the switch to SASL encryption after as sucessful LDAP bind relpy.
*/
_PUBLIC_ NTSTATUS packet_send_callback(struct packet_context *pc, DATA_BLOB blob,
				       packet_send_callback_fn_t send_callback, 
				       void *private_data)
{
	struct send_element *el;
	el = talloc(pc, struct send_element);
	NT_STATUS_HAVE_NO_MEMORY(el);

	DLIST_ADD_END(pc->send_queue, el, struct send_element *);
	el->blob = blob;
	el->nsent = 0;
	el->send_callback = send_callback;
	el->send_callback_private = private_data;

	/* if we aren't going to free the packet then we must reference it
	   to ensure it doesn't disappear before going out */
	if (pc->nofree) {
		if (!talloc_reference(el, blob.data)) {
			return NT_STATUS_NO_MEMORY;
		}
	} else {
		talloc_steal(el, blob.data);
	}

	if (private_data && !talloc_reference(el, private_data)) {
		return NT_STATUS_NO_MEMORY;
	}

	TEVENT_FD_WRITEABLE(pc->fde);

	return NT_STATUS_OK;
}
Ejemplo n.º 2
0
static bool test_lifeless(const struct torture_context *ctx)
{
	void *top = talloc_new(ctx);
	char *parent, *child; 
	void *child_owner = talloc_new(ctx);

	parent = talloc_strdup(top, "parent");
	if (!parent)
		return false;
	child = talloc_strdup(parent, "child");  
	if (!child) {
		talloc_free(parent);
		return false;
	}
	if (!talloc_reference(child, parent)) {
		talloc_free(parent);
		return false;
	}

	if (!talloc_reference(child_owner, child)) {
		talloc_unlink(child, parent);
		talloc_free(parent);
		return false;
	}

	talloc_unlink(top, parent);
	talloc_free(child);
	talloc_free(top);
	talloc_free(child_owner);
	talloc_free(child);

	return true;
}
Ejemplo n.º 3
0
struct context *context_new_defaults(struct clopts *o, void *context,
                                     struct makefile *mf,
                                     struct languagelist *ll,
                                     struct contextstack *s)
{
    struct context *c;

    c = talloc(context, struct context);
    c->type = CONTEXT_TYPE_DEFAULTS;
    c->parent = NULL;
    c->test_parent = NULL;
    c->bin_dir = talloc_strdup(c, "bin");
    c->lib_dir = talloc_strdup(c, "lib");
    c->hdr_dir = talloc_asprintf(c, "%sinclude", o->source_path);
    c->obj_dir = talloc_strdup(c, "obj");
    c->src_dir = talloc_asprintf(c, "%ssrc", o->source_path);
    c->chk_dir = talloc_strdup(c, "check");
    c->tst_dir = talloc_asprintf(c, "%stest", o->source_path);
    c->gen_dir = talloc_strdup(c, "obj/proc");
    c->prefix = talloc_strdup(c, DEFAULT_PREFIX);
    c->libexec_dir = talloc_strdup(c, "libexec");
    c->share_dir = talloc_strdup(c, "share");
    c->compile_opts = stringlist_new(c);
    c->link_opts = stringlist_new(c);
    c->shared_target = false;
    c->mf = talloc_reference(c, mf);
    c->ll = talloc_reference(c, ll);
    c->s = s;
    c->language = NULL;
    c->autodeps = true;

    return c;
}
Ejemplo n.º 4
0
static bool test_talloc_free_in_destructor(void)
{
	void *level0;
	void *level1;
	void *level2;
	void *level3;
	void *level4;
	void **level5;

	printf("test: free_in_destructor\n# TALLOC FREE IN DESTRUCTOR\n");

	level0 = talloc_new(NULL);
	level1 = talloc_new(level0);
	level2 = talloc_new(level1);
	level3 = talloc_new(level2);
	level4 = talloc_new(level3);
	level5 = talloc(level4, void *);

	*level5 = level3;
	(void)talloc_reference(level0, level3);
	(void)talloc_reference(level3, level3);
	(void)talloc_reference(level5, level3);

	talloc_set_destructor(level5, _test_talloc_free_in_destructor);

	talloc_free(level1);

	talloc_free(level0);

	printf("success: free_in_destructor\n");
	return true;
}
Ejemplo n.º 5
0
/**
  Start the GENSEC system, returning a context pointer.
  @param mem_ctx The parent TALLOC memory context.
  @param gensec_security Returned GENSEC context pointer.
  @note  The mem_ctx is only a parent and may be NULL.
  @note, the auth context is moved to be a referenced pointer of the
  @ gensec_security return 
*/
static NTSTATUS gensec_start(TALLOC_CTX *mem_ctx, 
			     struct tevent_context *ev,
			     struct gensec_settings *settings,
 			     struct auth_context *auth_context,
			     struct gensec_security **gensec_security)
{
	if (ev == NULL) {
		DEBUG(0, ("No event context available!\n"));
		return NT_STATUS_INTERNAL_ERROR;
	}

	(*gensec_security) = talloc_zero(mem_ctx, struct gensec_security);
	NT_STATUS_HAVE_NO_MEMORY(*gensec_security);

	(*gensec_security)->event_ctx = ev;
	SMB_ASSERT(settings->lp_ctx != NULL);
	(*gensec_security)->settings = talloc_reference(*gensec_security, settings);

	/* We need to reference this, not steal, as the caller may be
	 * python, which won't like it if we steal it's object away
	 * from it */
	(*gensec_security)->auth_context = talloc_reference(*gensec_security, auth_context);

	return NT_STATUS_OK;
}
Ejemplo n.º 6
0
static bool test_free_ref_null_context(void)
{
	void *p1, *p2, *p3;
	int ret;

	talloc_disable_null_tracking();
	p1 = talloc_new(NULL);
	p2 = talloc_new(NULL);

	p3 = talloc_reference(p2, p1);
	torture_assert("reference", p3 == p1, "failed: reference on null");

	ret = talloc_free(p1);
	torture_assert("ref free with null parent", ret == 0, "failed: free with null parent");
	talloc_free(p2);

	talloc_enable_null_tracking_no_autofree();
	p1 = talloc_new(NULL);
	p2 = talloc_new(NULL);

	p3 = talloc_reference(p2, p1);
	torture_assert("reference", p3 == p1, "failed: reference on null");

	ret = talloc_free(p1);
	torture_assert("ref free with null tracked parent", ret == 0, "failed: free with null parent");
	talloc_free(p2);

	return true;
}
Ejemplo n.º 7
0
/*
  test references 
*/
static bool test_ref1(void)
{
	void *root, *p1, *p2, *ref, *r1;

	printf("test: ref1\n# SINGLE REFERENCE FREE\n");

	root = talloc_named_const(NULL, 0, "root");
	p1 = talloc_named_const(root, 1, "p1");
	p2 = talloc_named_const(p1, 1, "p2");
	talloc_named_const(p1, 1, "x1");
	talloc_named_const(p1, 2, "x2");
	talloc_named_const(p1, 3, "x3");

	r1 = talloc_named_const(root, 1, "r1");	
	ref = talloc_reference(r1, p2);
	talloc_report_full(root, stderr);

	CHECK_BLOCKS("ref1", p1, 5);
	CHECK_BLOCKS("ref1", p2, 1);
	CHECK_BLOCKS("ref1", ref, 1);
	CHECK_BLOCKS("ref1", r1, 2);

	fprintf(stderr, "Freeing p2\n");
	talloc_unlink(r1, p2);
	talloc_report_full(root, stderr);

	CHECK_BLOCKS("ref1", p1, 5);
	CHECK_BLOCKS("ref1", p2, 1);
	CHECK_BLOCKS("ref1", r1, 1);

	fprintf(stderr, "Freeing p1\n");
	talloc_free(p1);
	talloc_report_full(root, stderr);

	CHECK_BLOCKS("ref1", r1, 1);

	fprintf(stderr, "Freeing r1\n");
	talloc_free(r1);
	talloc_report_full(NULL, stderr);

	fprintf(stderr, "Testing NULL\n");
	if (talloc_reference(root, NULL)) {
		return false;
	}

	CHECK_BLOCKS("ref1", root, 1);

	CHECK_SIZE("ref1", root, 0);

	talloc_free(root);
	printf("success: ref1\n");
	return true;
}
Ejemplo n.º 8
0
struct dsdb_schema *dsdb_get_schema(struct ldb_context *ldb, TALLOC_CTX *reference_ctx)
{
	const void *p;
	struct dsdb_schema *schema_out;
	struct dsdb_schema *schema_in;
	bool use_global_schema;
	TALLOC_CTX *tmp_ctx = talloc_new(reference_ctx);
	if (!tmp_ctx) {
		return NULL;
	}

	/* see if we have a cached copy */
	use_global_schema = dsdb_uses_global_schema(ldb);
	if (use_global_schema) {
		schema_in = global_schema;
	} else {
		p = ldb_get_opaque(ldb, "dsdb_schema");

		schema_in = talloc_get_type(p, struct dsdb_schema);
		if (!schema_in) {
			talloc_free(tmp_ctx);
			return NULL;
		}
	}

	if (schema_in->refresh_fn && !schema_in->refresh_in_progress) {
		if (!talloc_reference(tmp_ctx, schema_in)) {
			/*
			 * ensure that the schema_in->refresh_in_progress
			 * remains valid for the right amount of time
			 */
			talloc_free(tmp_ctx);
			return NULL;
		}
		schema_in->refresh_in_progress = true;
		/* This may change schema, if it needs to reload it from disk */
		schema_out = schema_in->refresh_fn(schema_in->loaded_from_module,
						   schema_in,
						   use_global_schema);
		schema_in->refresh_in_progress = false;
	} else {
		schema_out = schema_in;
	}

	/* This removes the extra reference above */
	talloc_free(tmp_ctx);
	if (!reference_ctx) {
		return schema_out;
	} else {
		return talloc_reference(reference_ctx, schema_out);
	}
}
Ejemplo n.º 9
0
/**
 * Create a sub torture context
 */
struct torture_context *torture_context_child(struct torture_context *parent)
{
    struct torture_context *subtorture = talloc_zero(parent, struct torture_context);

    if (subtorture == NULL)
        return NULL;

    subtorture->ev = talloc_reference(subtorture, parent->ev);
    subtorture->lp_ctx = talloc_reference(subtorture, parent->lp_ctx);
    subtorture->outputdir = talloc_reference(subtorture, parent->outputdir);
    subtorture->results = talloc_reference(subtorture, parent->results);

    return subtorture;
}
Ejemplo n.º 10
0
/**
 * Make this ldb use a specified schema, already fully calculated and belonging to another ldb
 */
int dsdb_reference_schema(struct ldb_context *ldb, struct dsdb_schema *schema,
			  bool write_attributes)
{
	int ret;
	struct dsdb_schema *old_schema;
	old_schema = ldb_get_opaque(ldb, "dsdb_schema");
	ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
	if (ret != LDB_SUCCESS) {
		return ret;
	}

	/* Remove the reference to the schema we just overwrote - if there was
	 * none, NULL is harmless here */
	talloc_unlink(ldb, old_schema);

	if (talloc_reference(ldb, schema) == NULL) {
		return ldb_oom(ldb);
	}

	/* Make this ldb use local schema preferably */
	ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", NULL);
	if (ret != LDB_SUCCESS) {
		return ret;
	}

	ret = dsdb_schema_set_attributes(ldb, schema, write_attributes);
	if (ret != LDB_SUCCESS) {
		return ret;
	}

	return LDB_SUCCESS;
}
Ejemplo n.º 11
0
krb5_error_code smb_krb5_get_keytab_container(TALLOC_CTX *mem_ctx,
				struct smb_krb5_context *smb_krb5_context,
				krb5_keytab opt_keytab,
				const char *keytab_name,
				struct keytab_container **ktc)
{
	krb5_keytab keytab;
	krb5_error_code ret;

	if (opt_keytab) {
		keytab = opt_keytab;
	} else {
		ret = krb5_kt_resolve(smb_krb5_context->krb5_context,
						keytab_name, &keytab);
		if (ret) {
			DEBUG(1,("failed to open krb5 keytab: %s\n",
				 smb_get_krb5_error_message(
					smb_krb5_context->krb5_context,
					ret, mem_ctx)));
			return ret;
		}
	}

	*ktc = talloc(mem_ctx, struct keytab_container);
	if (!*ktc) {
		return ENOMEM;
	}

	(*ktc)->smb_krb5_context = talloc_reference(*ktc, smb_krb5_context);
	(*ktc)->keytab = keytab;
	(*ktc)->password_based = false;
	talloc_set_destructor(*ktc, free_keytab_container);

	return 0;
}
Ejemplo n.º 12
0
static bool test_loop(void)
{
	void *top = talloc_new(NULL);
	char *parent;
	struct req1 {
		char *req2, *req3;
	} *req1;

	printf("test: loop\n# TALLOC LOOP DESTRUCTION\n");

	parent = talloc_strdup(top, "parent");
	req1 = talloc(parent, struct req1);
	req1->req2 = talloc_strdup(req1, "req2");  
	talloc_set_destructor(req1->req2, test_loop_destructor);
	req1->req3 = talloc_strdup(req1, "req3");
	(void)talloc_reference(req1->req3, req1);
	talloc_report_full(top, stderr);
	talloc_free(parent);
	talloc_report_full(top, stderr);
	talloc_report_full(NULL, stderr);
	talloc_free(top);

	torture_assert("loop", loop_destructor_count == 1, 
				   "FAILED TO FIRE LOOP DESTRUCTOR\n");
	loop_destructor_count = 0;

	printf("success: loop\n");
	return true;
}
Ejemplo n.º 13
0
_PUBLIC_ NTSTATUS auth_generate_session_info(TALLOC_CTX *mem_ctx, 
				    struct tevent_context *event_ctx, 
				    struct loadparm_context *lp_ctx,
				    struct auth_serversupplied_info *server_info, 
				    struct auth_session_info **_session_info) 
{
	struct auth_session_info *session_info;
	NTSTATUS nt_status;

	session_info = talloc(mem_ctx, struct auth_session_info);
	NT_STATUS_HAVE_NO_MEMORY(session_info);

	session_info->server_info = talloc_reference(session_info, server_info);

	/* unless set otherwise, the session key is the user session
	 * key from the auth subsystem */ 
	session_info->session_key = server_info->user_session_key;

	nt_status = security_token_create(session_info,
					  event_ctx,
					  lp_ctx,
					  server_info->account_sid,
					  server_info->primary_group_sid,
					  server_info->n_domain_groups,
					  server_info->domain_groups,
					  server_info->authenticated,
					  &session_info->security_token);
	NT_STATUS_NOT_OK_RETURN(nt_status);

	session_info->credentials = NULL;

	*_session_info = session_info;
	return NT_STATUS_OK;
}
Ejemplo n.º 14
0
/*
  test references 
*/
static bool test_ref3(void)
{
	void *root, *p1, *p2, *ref, *r1;

	printf("test: ref3 [\nPARENT REFERENCE FREE\n]\n");

	root = talloc_named_const(NULL, 0, "root");
	p1 = talloc_named_const(root, 1, "p1");
	p2 = talloc_named_const(root, 1, "p2");
	r1 = talloc_named_const(p1, 1, "r1");
	ref = talloc_reference(p2, r1);
	talloc_report_full(root, stderr);

	CHECK_BLOCKS("ref3", p1, 2);
	CHECK_BLOCKS("ref3", p2, 2);
	CHECK_BLOCKS("ref3", r1, 1);

	fprintf(stderr, "Freeing p1\n");
	talloc_free(p1);
	talloc_report_full(root, stderr);

	CHECK_BLOCKS("ref3", p2, 2);
	CHECK_BLOCKS("ref3", r1, 1);

	fprintf(stderr, "Freeing p2\n");
	talloc_free(p2);
	talloc_report_full(root, stderr);

	CHECK_SIZE("ref3", root, 0);

	talloc_free(root);

	printf("success: ref3\n");
	return true;
}
Ejemplo n.º 15
0
_PUBLIC_ int emsmdbp_source_key_from_fmid(TALLOC_CTX *mem_ctx, struct emsmdbp_context *emsmdbp_ctx, const char *username, uint64_t fmid, struct Binary_r **source_keyP)
{
	struct Binary_r	*source_key;
	uint64_t	gc;
	uint16_t	replid;
	uint8_t		*bytes;
	int		i;

	replid = fmid & 0xffff;
	source_key = talloc_zero(NULL, struct Binary_r);
	source_key->cb = 22;
	source_key->lpb = talloc_array(source_key, uint8_t, source_key->cb);
	if (emsmdbp_replid_to_guid(emsmdbp_ctx, username, replid, (struct GUID *) source_key->lpb)) {
		talloc_free(source_key);
		return MAPISTORE_ERROR;
	}

	(void) talloc_reference(mem_ctx, source_key);
	talloc_unlink(NULL, source_key);

	gc = fmid >> 16;

	bytes = source_key->lpb + 16;
	for (i = 0; i < 6; i++) {
		bytes[i] = gc & 0xff;
		gc >>= 8;
	}

	*source_keyP = source_key;

	return MAPISTORE_SUCCESS;
}
Ejemplo n.º 16
0
/**
  initialise a smb2_session structure
 */
struct smb2_session *smb2_session_init(struct smb2_transport *transport,
				       struct gensec_settings *settings,
				       TALLOC_CTX *parent_ctx, bool primary)
{
	struct smb2_session *session;
	NTSTATUS status;

	session = talloc_zero(parent_ctx, struct smb2_session);
	if (!session) {
		return NULL;
	}
	if (primary) {
		session->transport = talloc_steal(session, transport);
	} else {
		session->transport = talloc_reference(session, transport);
	}

	session->pid = getpid();

	/* prepare a gensec context for later use */
	status = gensec_client_start(session, &session->gensec, 
				     session->transport->socket->event.ctx, 
				     settings);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(session);
		return NULL;
	}

	gensec_want_feature(session->gensec, GENSEC_FEATURE_SESSION_KEY);

	return session;
}
krb5_error_code smb_krb5_context_set_event_ctx(struct smb_krb5_context *smb_krb5_context,
					       struct tevent_context *ev,
					       struct tevent_context **previous_ev)
{
	int ret;
	if (!ev) {
		return EINVAL;
	}

	*previous_ev = smb_krb5_context->current_ev;

	smb_krb5_context->current_ev = talloc_reference(smb_krb5_context, ev);
	if (!smb_krb5_context->current_ev) {
		return ENOMEM;
	}

	/* Set use of our socket lib */
	ret = krb5_set_send_to_kdc_func(smb_krb5_context->krb5_context,
					smb_krb5_send_and_recv_func,
					ev);
	if (ret) {
		TALLOC_CTX *tmp_ctx = talloc_new(NULL);
		DEBUG(1,("krb5_set_send_recv_func failed (%s)\n",
			 smb_get_krb5_error_message(smb_krb5_context->krb5_context, ret, tmp_ctx)));
		talloc_free(tmp_ctx);
		talloc_unlink(smb_krb5_context, smb_krb5_context->current_ev);
		smb_krb5_context->current_ev = NULL;
		return ret;
	}
	return 0;
}
Ejemplo n.º 18
0
/*
  a client has asked to register a unique name that someone else owns. We
  need to ask each of the current owners if they still want it. If they do
  then reject the registration, otherwise allow it
*/
static void wins_register_wack(struct nbt_name_socket *nbtsock, 
			       struct nbt_name_packet *packet, 
			       struct winsdb_record *rec,
			       struct socket_address *src,
			       enum wrepl_name_type new_type)
{
	struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
						       struct nbtd_interface);
	struct wins_server *winssrv = iface->nbtsrv->winssrv;
	struct nbtd_wins_wack_state *s;
	struct composite_context *c_req;
	uint32_t ttl;

	s = talloc_zero(nbtsock, struct nbtd_wins_wack_state);
	if (s == NULL) goto failed;

	/* package up the state variables for this wack request */
	s->winssrv		= winssrv;
	s->nbtsock		= nbtsock;
	s->iface		= iface;
	s->request_packet	= talloc_steal(s, packet);
	s->rec			= talloc_steal(s, rec);
	s->reg_address		= packet->additional[0].rdata.netbios.addresses[0].ipaddr;
	s->new_type		= new_type;
	s->src		        = src;
	if (talloc_reference(s, src) == NULL) goto failed;

	s->io.in.nbtd_server	= iface->nbtsrv;
	s->io.in.nbt_port       = lp_nbt_port(iface->nbtsrv->task->lp_ctx);
	s->io.in.event_ctx	= iface->nbtsrv->task->event_ctx;
	s->io.in.name		= rec->name;
	s->io.in.num_addresses	= winsdb_addr_list_length(rec->addresses);
	s->io.in.addresses	= winsdb_addr_string_list(s, rec->addresses);
	if (s->io.in.addresses == NULL) goto failed;

	DLIST_ADD_END(iface->wack_queue, s, struct nbtd_wins_wack_state *);

	talloc_set_destructor(s, nbtd_wins_wack_state_destructor);

	/*
	 * send a WACK to the client, specifying the maximum time it could
         * take to check with the owner, plus some slack
	 */
	ttl = 5 + 4 * winsdb_addr_list_length(rec->addresses);
	nbtd_wack_reply(nbtsock, packet, src, ttl);

	/*
	 * send the challenge to the old addresses
	 */
	c_req = wins_challenge_send(s, &s->io);
	if (c_req == NULL) goto failed;

	c_req->async.fn			= wack_wins_challenge_handler;
	c_req->async.private_data	= s;
	return;

failed:
	talloc_free(s);
	nbtd_name_registration_reply(nbtsock, packet, src, NBT_RCODE_SVR);
}
Ejemplo n.º 19
0
static krb5_error_code parse_principal(TALLOC_CTX *parent_ctx,
				       const char *princ_string,
				       struct smb_krb5_context *smb_krb5_context,
				       krb5_principal *princ,
				       const char **error_string)
{
	int ret;
	struct principal_container *mem_ctx;
	if (princ_string == NULL) {
		 *princ = NULL;
		 return 0;
	}

	ret = krb5_parse_name(smb_krb5_context->krb5_context,
			      princ_string, princ);

	if (ret) {
		(*error_string) = smb_get_krb5_error_message(smb_krb5_context->krb5_context, ret, parent_ctx);
		return ret;
	}

	mem_ctx = talloc(parent_ctx, struct principal_container);
	if (!mem_ctx) {
		(*error_string) = error_message(ENOMEM);
		return ENOMEM;
	}

	/* This song-and-dance effectivly puts the principal
	 * into talloc, so we can't loose it. */
	mem_ctx->smb_krb5_context = talloc_reference(mem_ctx, smb_krb5_context);
	mem_ctx->principal = *princ;
	talloc_set_destructor(mem_ctx, free_principal);
	return 0;
}
Ejemplo n.º 20
0
/**
 * Obtain the client principal for this credentials context.
 * @param cred credentials context
 * @retval The username set on this context.
 * @note Return value will never be NULL except by programmer error.
 */
const char *cli_credentials_get_principal(struct cli_credentials *cred, TALLOC_CTX *mem_ctx)
{
	if (cred->machine_account_pending) {
		cli_credentials_set_machine_account(cred);
	}

	if (cred->principal_obtained == CRED_CALLBACK && 
	    !cred->callback_running) {
	    	cred->callback_running = True;
		cred->principal = cred->principal_cb(cred);
	    	cred->callback_running = False;
		cred->principal_obtained = CRED_SPECIFIED;
	}

	if (cred->principal_obtained < cred->username_obtained) {
		if (cred->domain_obtained > cred->realm_obtained) {
			return talloc_asprintf(mem_ctx, "%s@%s", 
					       cli_credentials_get_username(cred),
					       cli_credentials_get_domain(cred));
		} else {
			return talloc_asprintf(mem_ctx, "%s@%s", 
					       cli_credentials_get_username(cred),
					       cli_credentials_get_realm(cred));
		}
	}
	return talloc_reference(mem_ctx, cred->principal);
}
Ejemplo n.º 21
0
/*
  queue a datagram for send
*/
NTSTATUS nbt_dgram_send(struct nbt_dgram_socket *dgmsock,
			struct nbt_dgram_packet *packet,
			struct socket_address *dest)
{
	struct nbt_dgram_request *req;
	NTSTATUS status = NT_STATUS_NO_MEMORY;
	enum ndr_err_code ndr_err;

	req = talloc(dgmsock, struct nbt_dgram_request);
	if (req == NULL) goto failed;

	req->dest = dest;
	if (talloc_reference(req, dest) == NULL) goto failed;

	ndr_err = ndr_push_struct_blob(&req->encoded, req, packet,
				      (ndr_push_flags_fn_t)ndr_push_nbt_dgram_packet);
	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
		status = ndr_map_error2ntstatus(ndr_err);
		goto failed;
	}

	DLIST_ADD_END(dgmsock->send_queue, req);

	TEVENT_FD_WRITEABLE(dgmsock->fde);

	return NT_STATUS_OK;

failed:
	talloc_free(req);
	return status;
}
Ejemplo n.º 22
0
/*
  initialise a nbt_dgram_socket. The event_ctx is optional, if provided
  then operations will use that event context
*/
struct nbt_dgram_socket *nbt_dgram_socket_init(TALLOC_CTX *mem_ctx, 
					      struct tevent_context *event_ctx,
					      struct smb_iconv_convenience *iconv_convenience)
{
	struct nbt_dgram_socket *dgmsock;
	NTSTATUS status;

	dgmsock = talloc(mem_ctx, struct nbt_dgram_socket);
	if (dgmsock == NULL) goto failed;

	dgmsock->event_ctx = talloc_reference(dgmsock, event_ctx);
	if (dgmsock->event_ctx == NULL) goto failed;

	status = socket_create("ip", SOCKET_TYPE_DGRAM, &dgmsock->sock, 0);
	if (!NT_STATUS_IS_OK(status)) goto failed;

	socket_set_option(dgmsock->sock, "SO_BROADCAST", "1");

	talloc_steal(dgmsock, dgmsock->sock);

	dgmsock->fde = event_add_fd(dgmsock->event_ctx, dgmsock, 
				    socket_get_fd(dgmsock->sock), 0,
				    dgm_socket_handler, dgmsock);

	dgmsock->send_queue = NULL;
	dgmsock->incoming.handler = NULL;
	dgmsock->mailslot_handlers = NULL;
	dgmsock->iconv_convenience = iconv_convenience;
	
	return dgmsock;

failed:
	talloc_free(dgmsock);
	return NULL;
}
Ejemplo n.º 23
0
 krb5_error_code principal_from_credentials(TALLOC_CTX *parent_ctx, 
					    struct cli_credentials *credentials, 
					    struct smb_krb5_context *smb_krb5_context,
					    krb5_principal *princ)
{
	krb5_error_code ret;
	const char *princ_string;
	struct principal_container *mem_ctx = talloc(parent_ctx, struct principal_container);
	if (!mem_ctx) {
		return ENOMEM;
	}
	
	princ_string = cli_credentials_get_principal(credentials, mem_ctx);

	/* A NULL here has meaning, as the gssapi server case will
	 * then use the principal from the client */
	if (!princ_string) {
		talloc_free(mem_ctx);
		princ = NULL;
		return 0;
	}

	ret = krb5_parse_name(smb_krb5_context->krb5_context,
			      princ_string, princ);

	if (ret == 0) {
		/* This song-and-dance effectivly puts the principal
		 * into talloc, so we can't loose it. */
		mem_ctx->smb_krb5_context = talloc_reference(mem_ctx, smb_krb5_context);
		mem_ctx->principal = *princ;
		talloc_set_destructor(mem_ctx, free_principal);
	}
	return ret;
}
Ejemplo n.º 24
0
/*
  wrapped connection to a ldb database
  to close just talloc_free() the returned ldb_context

  TODO:  We need an error_string parameter
 */
 struct ldb_context *ldb_wrap_connect(TALLOC_CTX *mem_ctx,
				      struct tevent_context *ev,
				      struct loadparm_context *lp_ctx,
				      const char *url,
				      struct auth_session_info *session_info,
				      struct cli_credentials *credentials,
				      unsigned int flags)
{
	struct ldb_context *ldb;
	int ret;

	ldb = ldb_wrap_find(url, ev, lp_ctx, session_info, credentials, flags);
	if (ldb != NULL)
		return talloc_reference(mem_ctx, ldb);

	ldb = samba_ldb_init(mem_ctx, ev, lp_ctx, session_info, credentials);

	if (ldb == NULL)
		return NULL;

	ret = samba_ldb_connect(ldb, lp_ctx, url, flags);
	if (ret != LDB_SUCCESS) {
		talloc_free(ldb);
		return NULL;
	}

	if (!ldb_wrap_add(url, ev, lp_ctx, session_info, credentials, flags, ldb)) {
		talloc_free(ldb);
		return NULL;
	}

	DEBUG(3,("ldb_wrap open of %s\n", url));

	return ldb;
}
Ejemplo n.º 25
0
static bool test_unref_reparent(void)
{
	void *root, *p1, *p2, *c1;

	printf("test: unref_reparent\n# UNREFERENCE AFTER PARENT FREED\n");

	root = talloc_named_const(NULL, 0, "root");
	p1 = talloc_named_const(root, 1, "orig parent");
	p2 = talloc_named_const(root, 1, "parent by reference");

	c1 = talloc_named_const(p1, 1, "child");
	talloc_reference(p2, c1);

	CHECK_PARENT("unref_reparent", c1, p1);

	talloc_free(p1);

	CHECK_PARENT("unref_reparent", c1, p2);

	talloc_unlink(p2, c1);

	CHECK_SIZE("unref_reparent", root, 1);

	talloc_free(p2);
	talloc_free(root);

	printf("success: unref_reparent\n");
	return true;
}
Ejemplo n.º 26
0
static WERROR rpc_get_predefined_key(struct registry_context *ctx,
				     uint32_t hkey_type,
				     struct registry_key **k)
{
	int n;
	struct rpc_key *mykeydata;
	struct rpc_registry_context *rctx = talloc_get_type(ctx, struct rpc_registry_context);

	*k = NULL;

	for(n = 0; known_hives[n].hkey; n++) {
		if(known_hives[n].hkey == hkey_type)
			break;
	}

	if (known_hives[n].open == NULL)  {
		DEBUG(1, ("No such hive %d\n", hkey_type));
		return WERR_NO_MORE_ITEMS;
	}

	mykeydata = talloc_zero(ctx, struct rpc_key);
	mykeydata->key.context = ctx;
	mykeydata->pipe = talloc_reference(mykeydata, rctx->pipe);
	mykeydata->num_values = -1;
	mykeydata->num_subkeys = -1;
	*k = (struct registry_key *)mykeydata;
	return known_hives[n].open(mykeydata->pipe, mykeydata, &(mykeydata->pol));
}
Ejemplo n.º 27
0
/**
  Start the GENSEC system, returning a context pointer.
  @param mem_ctx The parent TALLOC memory context.
  @param gensec_security Returned GENSEC context pointer.
  @note  The mem_ctx is only a parent and may be NULL.
  @note, the auth context is moved to be a child of the
  @ gensec_security return 
*/
static NTSTATUS gensec_start(TALLOC_CTX *mem_ctx, 
			     struct tevent_context *ev,
			     struct gensec_settings *settings,
 			     struct auth_context *auth_context,
			     struct gensec_security **gensec_security)
{
	if (ev == NULL) {
		DEBUG(0, ("No event context available!\n"));
		return NT_STATUS_INTERNAL_ERROR;
	}

	(*gensec_security) = talloc(mem_ctx, struct gensec_security);
	NT_STATUS_HAVE_NO_MEMORY(*gensec_security);

	(*gensec_security)->ops = NULL;
	(*gensec_security)->local_addr = NULL;
	(*gensec_security)->remote_addr = NULL;
	(*gensec_security)->private_data = NULL;

	ZERO_STRUCT((*gensec_security)->target);

	(*gensec_security)->subcontext = false;
	(*gensec_security)->want_features = 0;

	(*gensec_security)->event_ctx = ev;
	SMB_ASSERT(settings->lp_ctx != NULL);
	(*gensec_security)->settings = talloc_reference(*gensec_security, settings);
	(*gensec_security)->auth_context = talloc_steal(*gensec_security, auth_context);

	return NT_STATUS_OK;
}
Ejemplo n.º 28
0
/*
  initialise a wrepl_socket. The event_ctx is optional, if provided then
  operations will use that event context
*/
struct wrepl_socket *wrepl_socket_init(TALLOC_CTX *mem_ctx,
                                       struct tevent_context *event_ctx,
                                       struct smb_iconv_convenience *iconv_convenience)
{
    struct wrepl_socket *wrepl_socket;
    NTSTATUS status;

    wrepl_socket = talloc_zero(mem_ctx, struct wrepl_socket);
    if (!wrepl_socket) return NULL;

    wrepl_socket->event.ctx = talloc_reference(wrepl_socket, event_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;

    talloc_steal(wrepl_socket, wrepl_socket->sock);

    wrepl_socket->request_timeout	= WREPL_SOCKET_REQUEST_TIMEOUT;

    talloc_set_destructor(wrepl_socket, wrepl_socket_destructor);

    return wrepl_socket;

failed:
    talloc_free(wrepl_socket);
    return NULL;
}
Ejemplo n.º 29
0
/* initialise a dcerpc connection. 
   the event context is optional
*/
static struct dcerpc_connection *dcerpc_connection_init(TALLOC_CTX *mem_ctx, 
						 struct tevent_context *ev,
						 struct smb_iconv_convenience *ic)
{
	struct dcerpc_connection *c;

	c = talloc_zero(mem_ctx, struct dcerpc_connection);
	if (!c) {
		return NULL;
	}

	c->iconv_convenience = talloc_reference(c, ic);

	c->event_ctx = ev;

	if (c->event_ctx == NULL) {
		talloc_free(c);
		return NULL;
	}

	c->call_id = 1;
	c->security_state.auth_info = NULL;
	c->security_state.session_key = dcerpc_generic_session_key;
	c->security_state.generic_state = NULL;
	c->binding_string = NULL;
	c->flags = 0;
	c->srv_max_xmit_frag = 0;
	c->srv_max_recv_frag = 0;
	c->pending = NULL;

	talloc_set_destructor(c, dcerpc_connection_destructor);

	return c;
}
Ejemplo n.º 30
0
static WERROR rpc_query_key(TALLOC_CTX *mem_ctx, const struct registry_key *k)
{
	struct winreg_QueryInfoKey r;
	struct rpc_key *mykeydata = talloc_get_type(k, struct rpc_key);
	struct winreg_String classname;
	NTSTATUS status;

	classname.name = NULL;

	ZERO_STRUCT(r);
	r.in.handle = &mykeydata->pol;
	r.in.classname = &classname;
	r.out.classname = &classname;
	r.out.num_subkeys = &mykeydata->num_subkeys;
	r.out.max_subkeylen = &mykeydata->max_subkeylen;
	r.out.max_classlen = &mykeydata->max_classlen;
	r.out.num_values = &mykeydata->num_values;
	r.out.max_valnamelen = &mykeydata->max_valnamelen;
	r.out.max_valbufsize = &mykeydata->max_valbufsize;
	r.out.secdescsize = &mykeydata->secdescsize;
	r.out.last_changed_time = &mykeydata->last_changed_time;

	status = dcerpc_winreg_QueryInfoKey(mykeydata->pipe, mem_ctx, &r);

	if (!NT_STATUS_IS_OK(status)) {
		DEBUG(1, ("QueryInfoKey failed - %s\n", nt_errstr(status)));
		return ntstatus_to_werror(status);
	}

	mykeydata->classname = talloc_reference(mem_ctx, r.out.classname->name);

	return r.out.result;
}