if (!reply) {
return NULL;
}
+ reply->msg = talloc(reply, struct ldap_message);
+ if (reply->msg == NULL) {
+ talloc_free(reply);
+ return NULL;
+ }
reply->prev = reply->next = NULL;
reply->state = LDAPSRV_REPLY_STATE_NEW;
- reply->msg.messageid = call->request.messageid;
- reply->msg.type = type;
- reply->msg.mem_ctx = reply;
+ reply->msg->messageid = call->request->messageid;
+ reply->msg->type = type;
return reply;
}
struct ldapsrv_reply *reply;
struct ldap_ExtendedResponse *r;
- DEBUG(10,("Unwilling type[%d] id[%d]\n", call->request.type, call->request.messageid));
+ DEBUG(10,("Unwilling type[%d] id[%d]\n", call->request->type, call->request->messageid));
reply = ldapsrv_init_reply(call, LDAP_TAG_ExtendedResponse);
if (!reply) {
return NT_STATUS_NO_MEMORY;
}
- r = &reply->msg.r.ExtendedResponse;
+ r = &reply->msg->r.ExtendedResponse;
r->response.resultcode = error;
r->response.dn = NULL;
r->response.errormessage = NULL;
static NTSTATUS ldapsrv_SearchRequest(struct ldapsrv_call *call)
{
- struct ldap_SearchRequest *req = &call->request.r.SearchRequest;
+ struct ldap_SearchRequest *req = &call->request->r.SearchRequest;
struct ldapsrv_partition *part;
DEBUG(10, ("SearchRequest"));
return NT_STATUS_NO_MEMORY;
}
- done = &done_r->msg.r.SearchResultDone;
+ done = &done_r->msg->r.SearchResultDone;
done->resultcode = 53;
done->dn = NULL;
done->errormessage = NULL;
static NTSTATUS ldapsrv_ModifyRequest(struct ldapsrv_call *call)
{
- struct ldap_ModifyRequest *req = &call->request.r.ModifyRequest;
+ struct ldap_ModifyRequest *req = &call->request->r.ModifyRequest;
struct ldapsrv_partition *part;
DEBUG(10, ("ModifyRequest"));
static NTSTATUS ldapsrv_AddRequest(struct ldapsrv_call *call)
{
- struct ldap_AddRequest *req = &call->request.r.AddRequest;
+ struct ldap_AddRequest *req = &call->request->r.AddRequest;
struct ldapsrv_partition *part;
DEBUG(10, ("AddRequest"));
static NTSTATUS ldapsrv_DelRequest(struct ldapsrv_call *call)
{
- struct ldap_DelRequest *req = &call->request.r.DelRequest;
+ struct ldap_DelRequest *req = &call->request->r.DelRequest;
struct ldapsrv_partition *part;
DEBUG(10, ("DelRequest"));
static NTSTATUS ldapsrv_ModifyDNRequest(struct ldapsrv_call *call)
{
- struct ldap_ModifyDNRequest *req = &call->request.r.ModifyDNRequest;
+ struct ldap_ModifyDNRequest *req = &call->request->r.ModifyDNRequest;
struct ldapsrv_partition *part;
DEBUG(10, ("ModifyDNRequrest"));
static NTSTATUS ldapsrv_CompareRequest(struct ldapsrv_call *call)
{
- struct ldap_CompareRequest *req = &call->request.r.CompareRequest;
+ struct ldap_CompareRequest *req = &call->request->r.CompareRequest;
struct ldapsrv_partition *part;
DEBUG(10, ("CompareRequest"));
return NT_STATUS_NO_MEMORY;
}
- ZERO_STRUCT(reply->msg.r);
+ ZERO_STRUCT(reply->msg->r);
return ldapsrv_queue_reply(call, reply);
}
NTSTATUS ldapsrv_do_call(struct ldapsrv_call *call)
{
- switch(call->request.type) {
+ switch(call->request->type) {
case LDAP_TAG_BindRequest:
return ldapsrv_BindRequest(call);
case LDAP_TAG_UnbindRequest:
static NTSTATUS ldapsrv_BindSimple(struct ldapsrv_call *call)
{
- struct ldap_BindRequest *req = &call->request.r.BindRequest;
+ struct ldap_BindRequest *req = &call->request->r.BindRequest;
struct ldapsrv_reply *reply;
struct ldap_BindResponse *resp;
return NT_STATUS_NO_MEMORY;
}
- resp = &reply->msg.r.BindResponse;
+ resp = &reply->msg->r.BindResponse;
resp->response.resultcode = 0;
resp->response.dn = NULL;
resp->response.errormessage = NULL;
static NTSTATUS ldapsrv_BindSASL(struct ldapsrv_call *call)
{
- struct ldap_BindRequest *req = &call->request.r.BindRequest;
+ struct ldap_BindRequest *req = &call->request->r.BindRequest;
struct ldapsrv_reply *reply;
struct ldap_BindResponse *resp;
struct ldapsrv_connection *conn;
if (!reply) {
return NT_STATUS_NO_MEMORY;
}
- resp = &reply->msg.r.BindResponse;
+ resp = &reply->msg->r.BindResponse;
conn = call->conn;
NTSTATUS ldapsrv_BindRequest(struct ldapsrv_call *call)
{
- struct ldap_BindRequest *req = &call->request.r.BindRequest;
+ struct ldap_BindRequest *req = &call->request->r.BindRequest;
struct ldapsrv_reply *reply;
struct ldap_BindResponse *resp;
return NT_STATUS_NO_MEMORY;
}
- resp = &reply->msg.r.BindResponse;
+ resp = &reply->msg->r.BindResponse;
resp->response.resultcode = 7;
resp->response.dn = NULL;
resp->response.errormessage = talloc_asprintf(reply, "Bad AuthenticationChoice [%d]", req->mechanism);
ent_r = ldapsrv_init_reply(call, LDAP_TAG_SearchResultEntry);
NT_STATUS_HAVE_NO_MEMORY(ent_r);
- ent = &ent_r->msg.r.SearchResultEntry;
+ ent = &ent_r->msg->r.SearchResultEntry;
ent->dn = talloc_steal(ent_r, wkdn);
DEBUG(0,("hacked result [0] dn: %s\n", ent->dn));
ent->num_attributes = 0;
DEBUG(10,("hacked_Search: results: [%d]\n",count));
- done = &done_r->msg.r.SearchResultDone;
+ done = &done_r->msg->r.SearchResultDone;
done->dn = NULL;
done->resultcode = LDAP_SUCCESS;
done->errormessage = NULL;
ent_r = ldapsrv_init_reply(call, LDAP_TAG_SearchResultEntry);
NT_STATUS_HAVE_NO_MEMORY(ent_r);
- ent = &ent_r->msg.r.SearchResultEntry;
+ ent = &ent_r->msg->r.SearchResultEntry;
ent->dn = talloc_steal(ent_r, res[0]->dn);
DEBUG(0,("hacked result [0] dn: %s\n", ent->dn));
ent->num_attributes = 0;
ent_r = ldapsrv_init_reply(call, LDAP_TAG_SearchResultEntry);
NT_STATUS_HAVE_NO_MEMORY(ent_r);
- ent = &ent_r->msg.r.SearchResultEntry;
+ ent = &ent_r->msg->r.SearchResultEntry;
ent->dn = talloc_steal(ent_r, res[i]->dn);
DEBUG(0,("hacked result [%d] dn: %s\n", i, ent->dn));
ent->num_attributes = 0;
errstr = ldb_errstring(samdb);
}
- done = &done_r->msg.r.SearchResultDone;
+ done = &done_r->msg->r.SearchResultDone;
done->dn = NULL;
done->resultcode = result;
done->errormessage = (errstr?talloc_strdup(done_r,errstr):NULL);;
}
}
- add_result = &add_reply->msg.r.AddResponse;
+ add_result = &add_reply->msg->r.AddResponse;
add_result->dn = NULL;
add_result->resultcode = result;
add_result->errormessage = (errstr?talloc_strdup(add_reply,errstr):NULL);
}
}
- del_result = &del_reply->msg.r.DelResponse;
+ del_result = &del_reply->msg->r.DelResponse;
del_result->dn = NULL;
del_result->resultcode = result;
del_result->errormessage = (errstr?talloc_strdup(del_reply,errstr):NULL);
}
}
- modify_result = &modify_reply->msg.r.AddResponse;
+ modify_result = &modify_reply->msg->r.AddResponse;
modify_result->dn = NULL;
modify_result->resultcode = result;
modify_result->errormessage = (errstr?talloc_strdup(modify_reply,errstr):NULL);
}
}
- compare = &compare_r->msg.r.CompareResponse;
+ compare = &compare_r->msg->r.CompareResponse;
compare->dn = NULL;
compare->resultcode = result;
compare->errormessage = (errstr?talloc_strdup(compare_r,errstr):NULL);
}
}
- modifydn = &modifydn_r->msg.r.ModifyDNResponse;
+ modifydn = &modifydn_r->msg->r.ModifyDNResponse;
modifydn->dn = NULL;
modifydn->resultcode = result;
modifydn->errormessage = (errstr?talloc_strdup(modifydn_r,errstr):NULL);
ent_r = ldapsrv_init_reply(call, LDAP_TAG_SearchResultEntry);
NT_STATUS_HAVE_NO_MEMORY(ent_r);
- ent = &ent_r->msg.r.SearchResultEntry;
+ ent = &ent_r->msg->r.SearchResultEntry;
ent->dn = "";
ent->num_attributes = 0;
ent->attributes = NULL;
errstr = ldb_errstring(rootdsedb->ldb);
}
- done = &done_r->msg.r.SearchResultDone;
+ done = &done_r->msg->r.SearchResultDone;
done->dn = NULL;
done->resultcode = result;
done->errormessage = (errstr?talloc_strdup(done_r,errstr):NULL);;
for (call=conn->calls; call; call=next_call) {
for (reply=call->replies; reply; reply=next_reply) {
- if (!ldap_encode_to_buf(&reply->msg, &conn->out_buffer)) {
+ if (!ldap_encode_to_buf(reply->msg, &conn->out_buffer)) {
return NT_STATUS_FOOBAR;
}
next_reply = reply->next;
return;
}
- call = talloc(ldap_conn, struct ldapsrv_call);
+ call = talloc_zero(ldap_conn, struct ldapsrv_call);
if (!call) {
ldapsrv_terminate_connection(ldap_conn, "no memory");
return;
}
- ZERO_STRUCTP(call);
+ call->request = talloc_zero(call, struct ldap_message);
+ if (call->request == NULL) {
+ ldapsrv_terminate_connection(ldap_conn, "no memory");
+ return;
+ }
+
call->state = LDAPSRV_CALL_STATE_NEW;
call->conn = ldap_conn;
- call->request.mem_ctx = call;
- if (!ldap_decode(&data, &call->request)) {
+ if (!ldap_decode(&data, call->request)) {
dump_data(0,buf, msg_length);
asn1_free(&data);
ldapsrv_terminate_connection(ldap_conn, "ldap_decode() failed");
struct ldapsrv_connection *conn;
- struct ldap_message request;
+ struct ldap_message *request;
struct ldapsrv_reply {
struct ldapsrv_reply *prev,*next;
enum ldapsrv_reply_state state;
- struct ldap_message msg;
+ struct ldap_message *msg;
} *replies;
};
attrs[i] = NULL;
}
+ DEBUG(5,("ldb_search_bytree dn=%s filter=%s\n",
+ basedn->dn, ldb_filter_from_tree(call, r->tree)));
+
count = ldb_search_bytree(samdb, basedn->dn, scope, r->tree, attrs, &res);
talloc_steal(samdb, res);
ent_r = ldapsrv_init_reply(call, LDAP_TAG_SearchResultEntry);
NT_STATUS_HAVE_NO_MEMORY(ent_r);
- ent = &ent_r->msg.r.SearchResultEntry;
+ ent = &ent_r->msg->r.SearchResultEntry;
ent->dn = talloc_steal(ent_r, res[i]->dn);
ent->num_attributes = 0;
ent->attributes = NULL;
}
}
- done = &done_r->msg.r.SearchResultDone;
+ done = &done_r->msg->r.SearchResultDone;
done->dn = NULL;
done->resultcode = result;
done->errormessage = (errstr?talloc_strdup(done_r,errstr):NULL);
}
}
- add_result = &add_reply->msg.r.AddResponse;
+ add_result = &add_reply->msg->r.AddResponse;
add_result->dn = NULL;
add_result->resultcode = result;
add_result->errormessage = (errstr?talloc_strdup(add_reply,errstr):NULL);
}
}
- del_result = &del_reply->msg.r.DelResponse;
+ del_result = &del_reply->msg->r.DelResponse;
del_result->dn = NULL;
del_result->resultcode = result;
del_result->errormessage = (errstr?talloc_strdup(del_reply,errstr):NULL);
}
}
- modify_result = &modify_reply->msg.r.AddResponse;
+ modify_result = &modify_reply->msg->r.AddResponse;
modify_result->dn = NULL;
modify_result->resultcode = result;
modify_result->errormessage = (errstr?talloc_strdup(modify_reply,errstr):NULL);
}
}
- compare = &compare_r->msg.r.CompareResponse;
+ compare = &compare_r->msg->r.CompareResponse;
compare->dn = NULL;
compare->resultcode = result;
compare->errormessage = (errstr?talloc_strdup(compare_r,errstr):NULL);
}
}
- modifydn = &modifydn_r->msg.r.ModifyDNResponse;
+ modifydn = &modifydn_r->msg->r.ModifyDNResponse;
modifydn->dn = NULL;
modifydn->resultcode = result;
modifydn->errormessage = (errstr?talloc_strdup(modifydn_r,errstr):NULL);
DATA_BLOB blob;
size_t nread, dsize;
struct asn1_data asn1;
- struct ldap_message ldap_msg;
+ struct ldap_message *ldap_msg;
struct cldap_request *req;
status = socket_pending(cldap->sock, &dsize);
}
talloc_steal(tmp_ctx, asn1.data);
- ZERO_STRUCT(ldap_msg);
- ldap_msg.mem_ctx = tmp_ctx;
+ ldap_msg = talloc(tmp_ctx, struct ldap_message);
+ if (ldap_msg == NULL) {
+ talloc_free(tmp_ctx);
+ return;
+ }
/* this initial decode is used to find the message id */
- if (!ldap_decode(&asn1, &ldap_msg)) {
+ if (!ldap_decode(&asn1, ldap_msg)) {
DEBUG(2,("Failed to decode ldap message\n"));
talloc_free(tmp_ctx);
return;
}
/* find the pending request */
- req = idr_find(cldap->idr, ldap_msg.messageid);
+ req = idr_find(cldap->idr, ldap_msg->messageid);
if (req == NULL) {
if (cldap->incoming.handler) {
- cldap->incoming.handler(cldap, &ldap_msg, src_addr, src_port);
+ cldap->incoming.handler(cldap, ldap_msg, src_addr, src_port);
} else {
DEBUG(2,("Mismatched cldap reply %u from %s:%d\n",
- ldap_msg.messageid, src_addr, src_port));
+ ldap_msg->messageid, src_addr, src_port));
}
talloc_free(tmp_ctx);
return;
struct cldap_request *cldap_search_send(struct cldap_socket *cldap,
struct cldap_search *io)
{
- struct ldap_message msg;
+ struct ldap_message *msg;
struct cldap_request *req;
struct ldap_SearchRequest *search;
talloc_set_destructor(req, cldap_request_destructor);
- msg.mem_ctx = req;
- msg.messageid = req->message_id;
- msg.type = LDAP_TAG_SearchRequest;
- msg.num_controls = 0;
- msg.controls = NULL;
- search = &msg.r.SearchRequest;
+ msg = talloc(req, struct ldap_message);
+ if (msg == NULL) goto failed;
+ msg->messageid = req->message_id;
+ msg->type = LDAP_TAG_SearchRequest;
+ msg->num_controls = 0;
+ msg->controls = NULL;
+ search = &msg->r.SearchRequest;
search->basedn = "";
search->scope = LDAP_SEARCH_SCOPE_BASE;
goto failed;
}
- if (!ldap_encode(&msg, &req->encoded)) {
+ if (!ldap_encode(msg, &req->encoded)) {
DEBUG(0,("Failed to encode cldap message to %s:%d\n",
req->dest_addr, req->dest_port));
goto failed;
*/
NTSTATUS cldap_reply_send(struct cldap_socket *cldap, struct cldap_reply *io)
{
- struct ldap_message msg;
+ struct ldap_message *msg;
struct cldap_request *req;
DATA_BLOB blob1, blob2;
NTSTATUS status = NT_STATUS_NO_MEMORY;
talloc_set_destructor(req, cldap_request_destructor);
- msg.mem_ctx = req;
- msg.messageid = io->messageid;
- msg.num_controls = 0;
- msg.controls = NULL;
+ msg = talloc(req, struct ldap_message);
+ if (msg == NULL) goto failed;
+ msg->messageid = io->messageid;
+ msg->num_controls = 0;
+ msg->controls = NULL;
if (io->response) {
- msg.type = LDAP_TAG_SearchResultEntry;
- msg.r.SearchResultEntry = *io->response;
+ msg->type = LDAP_TAG_SearchResultEntry;
+ msg->r.SearchResultEntry = *io->response;
- if (!ldap_encode(&msg, &blob1)) {
+ if (!ldap_encode(msg, &blob1)) {
DEBUG(0,("Failed to encode cldap message to %s:%d\n",
req->dest_addr, req->dest_port));
status = NT_STATUS_INVALID_PARAMETER;
blob1 = data_blob(NULL, 0);
}
- msg.type = LDAP_TAG_SearchResultDone;
- msg.r.SearchResultDone = *io->result;
+ msg->type = LDAP_TAG_SearchResultDone;
+ msg->r.SearchResultDone = *io->result;
- if (!ldap_encode(&msg, &blob2)) {
+ if (!ldap_encode(msg, &blob2)) {
DEBUG(0,("Failed to encode cldap message to %s:%d\n",
req->dest_addr, req->dest_port));
status = NT_STATUS_INVALID_PARAMETER;
TALLOC_CTX *mem_ctx,
struct cldap_search *io)
{
- struct ldap_message ldap_msg;
+ struct ldap_message *ldap_msg;
if (req == NULL) {
return NT_STATUS_NO_MEMORY;
return NT_STATUS_IO_TIMEOUT;
}
- ZERO_STRUCT(ldap_msg);
- ldap_msg.mem_ctx = mem_ctx;
+ ldap_msg = talloc(mem_ctx, struct ldap_message);
+ NT_STATUS_HAVE_NO_MEMORY(ldap_msg);
- if (!ldap_decode(&req->asn1, &ldap_msg)) {
+ if (!ldap_decode(&req->asn1, ldap_msg)) {
talloc_free(req);
return NT_STATUS_INVALID_PARAMETER;
}
ZERO_STRUCT(io->out);
/* the first possible form has a search result in first place */
- if (ldap_msg.type == LDAP_TAG_SearchResultEntry) {
+ if (ldap_msg->type == LDAP_TAG_SearchResultEntry) {
io->out.response = talloc(mem_ctx, struct ldap_SearchResEntry);
NT_STATUS_HAVE_NO_MEMORY(io->out.response);
- *io->out.response = ldap_msg.r.SearchResultEntry;
+ *io->out.response = ldap_msg->r.SearchResultEntry;
/* decode the 2nd part */
- if (!ldap_decode(&req->asn1, &ldap_msg)) {
+ if (!ldap_decode(&req->asn1, ldap_msg)) {
talloc_free(req);
return NT_STATUS_INVALID_PARAMETER;
}
}
- if (ldap_msg.type != LDAP_TAG_SearchResultDone) {
+ if (ldap_msg->type != LDAP_TAG_SearchResultDone) {
talloc_free(req);
return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
}
io->out.result = talloc(mem_ctx, struct ldap_Result);
NT_STATUS_HAVE_NO_MEMORY(io->out.result);
- *io->out.result = ldap_msg.r.SearchResultDone;
+ *io->out.result = ldap_msg->r.SearchResultDone;
talloc_free(req);
return NT_STATUS_OK;
msg->type = LDAP_TAG_BindRequest;
asn1_start_tag(data, tag);
asn1_read_Integer(data, &r->version);
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->dn);
+ asn1_read_OctetString_talloc(msg, data, &r->dn);
if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(0))) {
int pwlen;
r->creds.password = "";
asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(0));
pwlen = asn1_tag_remaining(data);
if (pwlen != 0) {
- char *pw = talloc_size(msg->mem_ctx, pwlen+1);
+ char *pw = talloc_size(msg, pwlen+1);
asn1_read(data, pw, pwlen);
pw[pwlen] = '\0';
r->creds.password = pw;
} else if (asn1_peek_tag(data, ASN1_CONTEXT(3))){
asn1_start_tag(data, ASN1_CONTEXT(3));
r->mechanism = LDAP_AUTH_MECH_SASL;
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->creds.SASL.mechanism);
+ asn1_read_OctetString_talloc(msg, data, &r->creds.SASL.mechanism);
asn1_read_OctetString(data, &r->creds.SASL.secblob);
if (r->creds.SASL.secblob.data) {
- talloc_steal(msg->mem_ctx, r->creds.SASL.secblob.data);
+ talloc_steal(msg, r->creds.SASL.secblob.data);
}
asn1_end_tag(data);
}
struct ldap_BindResponse *r = &msg->r.BindResponse;
msg->type = LDAP_TAG_BindResponse;
asn1_start_tag(data, tag);
- ldap_decode_response(msg->mem_ctx, data, &r->response);
+ ldap_decode_response(msg, data, &r->response);
if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(7))) {
DATA_BLOB tmp_blob = data_blob(NULL, 0);
asn1_read_ContextSimple(data, 7, &tmp_blob);
- r->SASL.secblob = data_blob_talloc(msg->mem_ctx, tmp_blob.data, tmp_blob.length);
+ r->SASL.secblob = data_blob_talloc(msg, tmp_blob.data, tmp_blob.length);
data_blob_free(&tmp_blob);
} else {
r->SASL.secblob = data_blob(NULL, 0);
struct ldap_SearchRequest *r = &msg->r.SearchRequest;
msg->type = LDAP_TAG_SearchRequest;
asn1_start_tag(data, tag);
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->basedn);
+ asn1_read_OctetString_talloc(msg, data, &r->basedn);
asn1_read_enumerated(data, (int *)&(r->scope));
asn1_read_enumerated(data, (int *)&(r->deref));
asn1_read_Integer(data, &r->sizelimit);
asn1_read_Integer(data, &r->timelimit);
asn1_read_BOOLEAN(data, &r->attributesonly);
- r->tree = ldap_decode_filter_tree(msg->mem_ctx, data);
+ r->tree = ldap_decode_filter_tree(msg, data);
if (r->tree == NULL) {
return False;
}
while (asn1_tag_remaining(data) > 0) {
const char *attr;
- if (!asn1_read_OctetString_talloc(msg->mem_ctx, data,
+ if (!asn1_read_OctetString_talloc(msg, data,
&attr))
return False;
- if (!add_string_to_array(msg->mem_ctx, attr,
+ if (!add_string_to_array(msg, attr,
&r->attributes,
&r->num_attributes))
return False;
r->attributes = NULL;
r->num_attributes = 0;
asn1_start_tag(data, tag);
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->dn);
- ldap_decode_attribs(msg->mem_ctx, data, &r->attributes,
+ asn1_read_OctetString_talloc(msg, data, &r->dn);
+ ldap_decode_attribs(msg, data, &r->attributes,
&r->num_attributes);
asn1_end_tag(data);
break;
struct ldap_Result *r = &msg->r.SearchResultDone;
msg->type = LDAP_TAG_SearchResultDone;
asn1_start_tag(data, tag);
- ldap_decode_response(msg->mem_ctx, data, r);
+ ldap_decode_response(msg, data, r);
asn1_end_tag(data);
break;
}
struct ldap_SearchResRef *r = &msg->r.SearchResultReference;
msg->type = LDAP_TAG_SearchResultReference;
asn1_start_tag(data, tag);
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->referral);
+ asn1_read_OctetString_talloc(msg, data, &r->referral);
asn1_end_tag(data);
break;
}
struct ldap_ModifyRequest *r = &msg->r.ModifyRequest;
msg->type = LDAP_TAG_ModifyRequest;
asn1_start_tag(data, ASN1_APPLICATION(LDAP_TAG_ModifyRequest));
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->dn);
+ asn1_read_OctetString_talloc(msg, data, &r->dn);
asn1_start_tag(data, ASN1_SEQUENCE(0));
r->num_mods = 0;
asn1_start_tag(data, ASN1_SEQUENCE(0));
asn1_read_enumerated(data, &v);
mod.type = v;
- ldap_decode_attrib(msg->mem_ctx, data, &mod.attrib);
+ ldap_decode_attrib(msg, data, &mod.attrib);
asn1_end_tag(data);
- if (!add_mod_to_array_talloc(msg->mem_ctx, &mod,
+ if (!add_mod_to_array_talloc(msg, &mod,
&r->mods, &r->num_mods))
break;
}
struct ldap_Result *r = &msg->r.ModifyResponse;
msg->type = LDAP_TAG_ModifyResponse;
asn1_start_tag(data, tag);
- ldap_decode_response(msg->mem_ctx, data, r);
+ ldap_decode_response(msg, data, r);
asn1_end_tag(data);
break;
}
struct ldap_AddRequest *r = &msg->r.AddRequest;
msg->type = LDAP_TAG_AddRequest;
asn1_start_tag(data, tag);
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->dn);
+ asn1_read_OctetString_talloc(msg, data, &r->dn);
r->attributes = NULL;
r->num_attributes = 0;
- ldap_decode_attribs(msg->mem_ctx, data, &r->attributes,
+ ldap_decode_attribs(msg, data, &r->attributes,
&r->num_attributes);
asn1_end_tag(data);
struct ldap_Result *r = &msg->r.AddResponse;
msg->type = LDAP_TAG_AddResponse;
asn1_start_tag(data, tag);
- ldap_decode_response(msg->mem_ctx, data, r);
+ ldap_decode_response(msg, data, r);
asn1_end_tag(data);
break;
}
asn1_start_tag(data,
ASN1_APPLICATION_SIMPLE(LDAP_TAG_DelRequest));
len = asn1_tag_remaining(data);
- dn = talloc_size(msg->mem_ctx, len+1);
+ dn = talloc_size(msg, len+1);
if (dn == NULL)
break;
asn1_read(data, dn, len);
struct ldap_Result *r = &msg->r.DelResponse;
msg->type = LDAP_TAG_DelResponse;
asn1_start_tag(data, tag);
- ldap_decode_response(msg->mem_ctx, data, r);
+ ldap_decode_response(msg, data, r);
asn1_end_tag(data);
break;
}
msg->type = LDAP_TAG_ModifyDNRequest;
asn1_start_tag(data,
ASN1_APPLICATION(LDAP_TAG_ModifyDNRequest));
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->dn);
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->newrdn);
+ asn1_read_OctetString_talloc(msg, data, &r->dn);
+ asn1_read_OctetString_talloc(msg, data, &r->newrdn);
asn1_read_BOOLEAN(data, &r->deleteolddn);
r->newsuperior = NULL;
if (asn1_tag_remaining(data) > 0) {
char *newsup;
asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(0));
len = asn1_tag_remaining(data);
- newsup = talloc_size(msg->mem_ctx, len+1);
+ newsup = talloc_size(msg, len+1);
if (newsup == NULL)
break;
asn1_read(data, newsup, len);
struct ldap_Result *r = &msg->r.ModifyDNResponse;
msg->type = LDAP_TAG_ModifyDNResponse;
asn1_start_tag(data, tag);
- ldap_decode_response(msg->mem_ctx, data, r);
+ ldap_decode_response(msg, data, r);
asn1_end_tag(data);
break;
}
msg->type = LDAP_TAG_CompareRequest;
asn1_start_tag(data,
ASN1_APPLICATION(LDAP_TAG_CompareRequest));
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->dn);
+ asn1_read_OctetString_talloc(msg, data, &r->dn);
asn1_start_tag(data, ASN1_SEQUENCE(0));
- asn1_read_OctetString_talloc(msg->mem_ctx, data, &r->attribute);
+ asn1_read_OctetString_talloc(msg, data, &r->attribute);
asn1_read_OctetString(data, &r->value);
if (r->value.data) {
- talloc_steal(msg->mem_ctx, r->value.data);
+ talloc_steal(msg, r->value.data);
}
asn1_end_tag(data);
asn1_end_tag(data);
struct ldap_Result *r = &msg->r.CompareResponse;
msg->type = LDAP_TAG_CompareResponse;
asn1_start_tag(data, tag);
- ldap_decode_response(msg->mem_ctx, data, r);
+ ldap_decode_response(msg, data, r);
asn1_end_tag(data);
break;
}
if (!asn1_read_ContextSimple(data, 0, &tmp_blob)) {
return False;
}
- r->oid = blob2string_talloc(msg->mem_ctx, tmp_blob);
+ r->oid = blob2string_talloc(msg, tmp_blob);
data_blob_free(&tmp_blob);
if (!r->oid) {
return False;
if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(1))) {
asn1_read_ContextSimple(data, 1, &tmp_blob);
- r->value = data_blob_talloc(msg->mem_ctx, tmp_blob.data, tmp_blob.length);
+ r->value = data_blob_talloc(msg, tmp_blob.data, tmp_blob.length);
data_blob_free(&tmp_blob);
} else {
r->value = data_blob(NULL, 0);
struct ldap_ExtendedResponse *r = &msg->r.ExtendedResponse;
msg->type = LDAP_TAG_ExtendedResponse;
asn1_start_tag(data, tag);
- ldap_decode_response(msg->mem_ctx, data, &r->response);
+ ldap_decode_response(msg, data, &r->response);
/* I have to come across an operation that actually sends
* something back to really see what's going on. The currently
* needed pwdchange does not send anything back. */
for (i=0; asn1_peek_tag(data, ASN1_SEQUENCE(0)); i++) {
asn1_start_tag(data, ASN1_SEQUENCE(0));
- ctrl = talloc_realloc(msg->mem_ctx, ctrl, struct ldap_Control, i+1);
+ ctrl = talloc_realloc(msg, ctrl, struct ldap_Control, i+1);
if (!ctrl) {
return False;
}
if (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
asn1_read_OctetString(data, &ctrl[i].value);
if (ctrl[i].value.data) {
- talloc_steal(msg->mem_ctx, ctrl[i].value.data);
+ talloc_steal(msg, ctrl[i].value.data);
}
}
};
struct ldap_message {
- TALLOC_CTX *mem_ctx;
uint32_t messageid;
enum ldap_request_tag type;
union ldap_Request r;
};
struct ldap_connection {
- TALLOC_CTX *mem_ctx;
int sock;
int next_msgid;
char *host;
res->type = LDAP_TAG_BindRequest;
res->r.BindRequest.version = 3;
- res->r.BindRequest.dn = talloc_strdup(res->mem_ctx, dn);
+ res->r.BindRequest.dn = talloc_strdup(res, dn);
res->r.BindRequest.mechanism = LDAP_AUTH_MECH_SIMPLE;
- res->r.BindRequest.creds.password = talloc_strdup(res->mem_ctx, pw);
+ res->r.BindRequest.creds.password = talloc_strdup(res, pw);
return res;
}
res->r.BindRequest.version = 3;
res->r.BindRequest.dn = "";
res->r.BindRequest.mechanism = LDAP_AUTH_MECH_SASL;
- res->r.BindRequest.creds.SASL.mechanism = talloc_strdup(res->mem_ctx, sasl_mechanism);
+ res->r.BindRequest.creds.SASL.mechanism = talloc_strdup(res, sasl_mechanism);
res->r.BindRequest.creds.SASL.secblob = *secblob;
return res;
return NULL;
}
- result->mem_ctx = result;
result->next_msgid = 1;
result->outstanding = NULL;
result->searchid = 0;
return NULL;
}
- ret = ldap_parse_basic_url(conn->mem_ctx, url, &conn->host,
- &conn->port, &conn->ldaps);
+ ret = ldap_parse_basic_url(conn, url, &conn->host,
+ &conn->port, &conn->ldaps);
if (!ret) {
talloc_free(conn);
return NULL;
struct ldap_message *new_ldap_message(TALLOC_CTX *mem_ctx)
{
- struct ldap_message *result;
-
- result = talloc(mem_ctx, struct ldap_message);
-
- if (!result) {
- return NULL;
- }
-
- result->mem_ctx = result;
-
- return result;
+ return talloc(mem_ctx, struct ldap_message);
}
BOOL ldap_send_msg(struct ldap_connection *conn, struct ldap_message *msg,
return NULL;
status = gensec_wrap(conn->gensec,
- req->mem_ctx,
+ req,
&request,
&wrapped);
if (!NT_STATUS_IS_OK(status)) {
wrapped.length = len;
status = gensec_unwrap(conn->gensec,
- req->mem_ctx,
+ req,
&wrapped,
&request);
if (!NT_STATUS_IS_OK(status)) {
return NULL;
}
- rep = new_ldap_message(req->mem_ctx);
+ rep = new_ldap_message(req);
asn1_load(&asn1, request);
if (!ldap_decode(&asn1, rep)) {
goto done;
}
- status = gensec_start_mech_by_sasl_name(conn->gensec, "GSS-SPNEGO");
+ status = gensec_start_mech_by_sasl_name(conn->gensec, "NTLM");
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("Failed to start set GENSEC client SPNEGO mechanism: %s\n",
nt_errstr(status)));
}
done:
- if (mem_ctx)
- talloc_free(mem_ctx);
+ talloc_free(mem_ctx);
return result;
}
}
if (attrib == NULL) {
- r->attributes = talloc_realloc(msg->mem_ctx,
+ r->attributes = talloc_realloc(msg,
r->attributes,
struct ldap_attribute,
r->num_attributes+1);
attrib = &(r->attributes[r->num_attributes]);
r->num_attributes += 1;
ZERO_STRUCTP(attrib);
- attrib->name = talloc_strdup(msg->mem_ctx,
+ attrib->name = talloc_strdup(msg,
attr_name);
}
- if (!add_value_to_attrib(msg->mem_ctx, &value, attrib))
+ if (!add_value_to_attrib(msg, &value, attrib))
return False;
}
return True;
struct ldap_mod mod;
mod.type = LDAP_MODIFY_NONE;
- mod.attrib.name = talloc_strdup(msg->mem_ctx, value.data);
+ mod.attrib.name = talloc_strdup(msg, value.data);
if (strequal(attr_name, "add"))
mod.type = LDAP_MODIFY_ADD;
mod.attrib.name));
return False;
}
- if (!add_value_to_attrib(msg->mem_ctx, &value,
+ if (!add_value_to_attrib(msg, &value,
&mod.attrib)) {
DEBUG(3, ("Could not add value\n"));
return False;
}
}
- if (!add_mod_to_array_talloc(msg->mem_ctx, &mod, &r->mods,
+ if (!add_mod_to_array_talloc(msg, &mod, &r->mods,
&r->num_mods))
return False;
}
if (msg == NULL)
return NULL;
- chunk = next_chunk(msg->mem_ctx, fgetc_fn, private_data);
+ chunk = next_chunk(msg, fgetc_fn, private_data);
if (!chunk) {
goto failed;
}
goto failed;
}
- dn = talloc_strdup(msg->mem_ctx, value.data);
+ dn = talloc_strdup(msg, value.data);
if (next_attr(&s, &attr, &value) != 0) {
goto failed;
msg->r.SearchRequest.timelimit = 0;
msg->r.SearchRequest.sizelimit = 0;
msg->r.SearchRequest.attributesonly = False;
- msg->r.SearchRequest.tree = ldb_parse_tree(msg->mem_ctx, "(objectclass=*)");
+ msg->r.SearchRequest.tree = ldb_parse_tree(msg, "(objectclass=*)");
msg->r.SearchRequest.num_attributes = 0;
msg->r.SearchRequest.attributes = NULL;
(char *)r->attributes[i].values[j].data));
if (!(*basedn) &&
strcasecmp("defaultNamingContext",r->attributes[i].name)==0) {
- *basedn = talloc_asprintf(conn->mem_ctx, "%.*s",
+ *basedn = talloc_asprintf(conn, "%.*s",
r->attributes[i].values[j].length,
(char *)r->attributes[i].values[j].data);
}
req->type = LDAP_TAG_CompareRequest;
req->r.CompareRequest.dn = basedn;
- req->r.CompareRequest.attribute = talloc_strdup(req->mem_ctx, "objectClass");
+ req->r.CompareRequest.attribute = talloc_strdup(req, "objectClass");
val = "domain";
- req->r.CompareRequest.value = data_blob_talloc(req->mem_ctx, val, strlen(val));
+ req->r.CompareRequest.value = data_blob_talloc(req, val, strlen(val));
rep = ldap_transaction(conn, req);
if (!rep) {
git.samba.org / metze / samba / wip.git / commitdiff