*/
#include "includes.h"
+#include "events.h"
+#include "auth/auth.h"
+#include "dlinklist.h"
+#include "asn_1.h"
+#include "ldap_server/ldap_server.h"
/*
close the socket and shutdown a server_context
*/
static void add_socket(struct server_service *service,
const struct model_ops *model_ops,
- struct in_addr *ifip)
+ struct ipv4_addr *ifip)
{
struct server_socket *srv_sock;
uint16_t port = 389;
- char *ip_str = talloc_strdup(service, inet_ntoa(*ifip));
+ char *ip_str = talloc_strdup(service, sys_inet_ntoa(*ifip));
- srv_sock = service_setup_socket(service, model_ops, ip_str, &port);
+ srv_sock = service_setup_socket(service, model_ops, "ipv4", ip_str, &port);
+
+ port = 3268;
+ srv_sock = service_setup_socket(service, model_ops, "ipv4", ip_str, &port);
talloc_free(ip_str);
}
static void ldapsrv_init(struct server_service *service,
const struct model_ops *model_ops)
{
- DEBUG(1,("ldapsrv_init\n"));
+ struct ldapsrv_service *ldap_service;
+ struct ldapsrv_partition *part;
+
+ DEBUG(10,("ldapsrv_init\n"));
+
+ ldap_service = talloc_p(service, struct ldapsrv_service);
+ if (!ldap_service) {
+ DEBUG(0,("talloc_p(service, struct ldapsrv_service) failed\n"));
+ return;
+ }
+ ZERO_STRUCTP(ldap_service);
+
+ part = talloc_p(ldap_service, struct ldapsrv_partition);
+ if (!ldap_service) {
+ DEBUG(0,("talloc_p(ldap_service, struct ldapsrv_partition) failed\n"));
+ return;
+ }
+ part->base_dn = ""; /* RootDSE */
+ part->ops = ldapsrv_get_rootdse_partition_ops();
+
+ ldap_service->rootDSE = part;
+ DLIST_ADD_END(ldap_service->partitions, part, struct ldapsrv_partition *);
+
+ part = talloc_p(ldap_service, struct ldapsrv_partition);
+ if (!ldap_service) {
+ DEBUG(0,("talloc_p(ldap_service, struct ldapsrv_partition) failed\n"));
+ return;
+ }
+ part->base_dn = "*"; /* default partition */
+ part->ops = ldapsrv_get_sldb_partition_ops();
+
+ ldap_service->default_partition = part;
+ DLIST_ADD_END(ldap_service->partitions, part, struct ldapsrv_partition *);
+
+ service->private_data = ldap_service;
if (lp_interfaces() && lp_bind_interfaces_only()) {
int num_interfaces = iface_count();
socket per interface and bind to only these.
*/
for(i = 0; i < num_interfaces; i++) {
- struct in_addr *ifip = iface_n_ip(i);
+ struct ipv4_addr *ifip = iface_n_ip(i);
if (ifip == NULL) {
DEBUG(0,("ldapsrv_init: interface %d has NULL "
add_socket(service, model_ops, ifip);
}
} else {
- struct in_addr *ifip;
- TALLOC_CTX *mem_ctx = talloc_init("ldapsrv_init");
-
- if (!mem_ctx) {
- smb_panic("No memory");
- }
+ struct ipv4_addr ifip;
/* Just bind to lp_socket_address() (usually 0.0.0.0) */
- ifip = interpret_addr2(mem_ctx, lp_socket_address());
- add_socket(service, model_ops, ifip);
-
- talloc_destroy(mem_ctx);
+ ifip = interpret_addr2(lp_socket_address());
+ add_socket(service, model_ops, &ifip);
}
}
that a read(2) holds a complete request that is then thrown away
completely. */
-static void consumed_from_buf(struct rw_buffer *buf,
+void ldapsrv_consumed_from_buf(struct rw_buffer *buf,
size_t length)
{
memcpy(buf->data, buf->data+length, buf->length-length);
buf->length -= length;
}
-static BOOL append_to_buf(struct rw_buffer *buf, uint8_t *data, size_t length)
+static void peek_into_read_buf(struct rw_buffer *buf, uint8_t **out,
+ size_t *out_length)
+{
+ *out = buf->data;
+ *out_length = buf->length;
+}
+
+BOOL ldapsrv_append_to_buf(struct rw_buffer *buf, uint8_t *data, size_t length)
{
buf->data = realloc(buf->data, buf->length+length);
NTSTATUS status;
DATA_BLOB tmp_blob;
BOOL ret;
+ size_t nread;
- status = socket_recv(sock, sock, &tmp_blob, 1024, 0);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(1,("socket_recv: %s\n",nt_errstr(status)));
+ tmp_blob = data_blob_talloc(sock, NULL, 1024);
+ if (tmp_blob.data == NULL) {
+ return False;
+ }
+
+ status = socket_recv(sock, tmp_blob.data, tmp_blob.length, &nread, 0);
+ if (NT_STATUS_IS_ERR(status)) {
+ DEBUG(10,("socket_recv: %s\n",nt_errstr(status)));
+ talloc_free(tmp_blob.data);
return False;
}
- ret = append_to_buf(buf, tmp_blob.data, tmp_blob.length);
+ ret = ldapsrv_append_to_buf(buf, tmp_blob.data, tmp_blob.length);
talloc_free(tmp_blob.data);
return ret;
}
-static BOOL write_from_buf(struct socket_context *sock, struct rw_buffer *buf)
+static BOOL ldapsrv_read_buf(struct ldapsrv_connection *conn)
{
NTSTATUS status;
DATA_BLOB tmp_blob;
- size_t sendlen;
-
- tmp_blob.data = buf->data;
- tmp_blob.length = buf->length;
+ DATA_BLOB creds;
+ BOOL ret;
+ uint8_t *buf;
+ int buf_length, sasl_length;
+ struct socket_context *sock = conn->connection->socket;
+ TALLOC_CTX *mem_ctx;
+ size_t nread;
+
+ if (!conn->gensec || !conn->session_info ||
+ !(gensec_have_feature(conn->gensec, GENSEC_WANT_SIGN) &&
+ gensec_have_feature(conn->gensec, GENSEC_WANT_SEAL))) {
+ return read_into_buf(sock, &conn->in_buffer);
+ }
- status = socket_send(sock, sock, &tmp_blob, &sendlen, 0);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0,("socket_send() %s\n",nt_errstr(status)));
+ mem_ctx = talloc(conn, 0);
+ if (!mem_ctx) {
+ DEBUG(0,("no memory\n"));
return False;
}
- consumed_from_buf(buf, sendlen);
-
- return True;
-}
-
-static void peek_into_read_buf(struct rw_buffer *buf, uint8_t **out,
- size_t *out_length)
-{
- *out = buf->data;
- *out_length = buf->length;
-}
+ tmp_blob = data_blob_talloc(mem_ctx, NULL, 1024);
+ if (tmp_blob.data == NULL) {
+ talloc_free(mem_ctx);
+ return False;
+ }
-static BOOL ldap_append_to_buf(struct ldap_message *msg, struct rw_buffer *buf)
-{
- DATA_BLOB blob;
- BOOL res;
+ status = socket_recv(sock, tmp_blob.data, tmp_blob.length, &nread, 0);
+ if (NT_STATUS_IS_ERR(status)) {
+ DEBUG(10,("socket_recv: %s\n",nt_errstr(status)));
+ talloc_free(mem_ctx);
+ return False;
+ }
+ tmp_blob.length = nread;
- if (!ldap_encode(msg, &blob))
+ ret = ldapsrv_append_to_buf(&conn->sasl_in_buffer, tmp_blob.data, tmp_blob.length);
+ if (!ret) {
+ talloc_free(mem_ctx);
return False;
+ }
- res = append_to_buf(buf, blob.data, blob.length);
+ peek_into_read_buf(&conn->sasl_in_buffer, &buf, &buf_length);
- data_blob_free(&blob);
- return res;
-}
+ if (buf_length < 4) {
+ /* not enough yet */
+ talloc_free(mem_ctx);
+ return True;
+ }
-struct ldapsrv_reply *ldapsrv_init_reply(struct ldapsrv_call *call, enum ldap_request_tag type)
-{
- struct ldapsrv_reply *reply;
+ sasl_length = RIVAL(buf, 0);
- reply = talloc_p(call, struct ldapsrv_reply);
- if (!reply) {
- return NULL;
+ if (buf_length < (4 + sasl_length)) {
+ /* not enough yet */
+ talloc_free(mem_ctx);
+ return True;
}
- 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;
+ creds.data = buf + 4;
+ creds.length = gensec_sig_size(conn->gensec);
- return reply;
-}
-
-NTSTATUS ldapsrv_queue_reply(struct ldapsrv_call *call, struct ldapsrv_reply *reply)
-{
- DLIST_ADD_END(call->replies, reply, struct ldapsrv_reply *);
- return NT_STATUS_OK;
-}
+ if (creds.length > sasl_length) {
+ /* invalid packet? */
+ talloc_free(mem_ctx);
+ return False;
+ }
-struct ldapsrv_partition *ldapsrv_get_partition(struct ldapsrv_connection *conn, const char *dn)
-{
- static struct ldapsrv_partition null_part;
+ tmp_blob.data = buf + (4 + creds.length);
+ tmp_blob.length = (4 + sasl_length) - (4 + creds.length);
- if (strcasecmp("", dn) == 0) {
- null_part.ops = ldapsrv_get_rootdse_partition_ops();
+ if (gensec_have_feature(conn->gensec, GENSEC_WANT_SEAL)) {
+ status = gensec_unseal_packet(conn->gensec, mem_ctx,
+ tmp_blob.data, tmp_blob.length,
+ tmp_blob.data, tmp_blob.length,
+ &creds);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("gensec_unseal_packet: %s\n",nt_errstr(status)));
+ talloc_free(mem_ctx);
+ return False;
+ }
} else {
- null_part.ops = ldapsrv_get_sldb_partition_ops();
+ status = gensec_check_packet(conn->gensec, mem_ctx,
+ tmp_blob.data, tmp_blob.length,
+ tmp_blob.data, tmp_blob.length,
+ &creds);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("gensec_check_packet: %s\n",nt_errstr(status)));
+ talloc_free(mem_ctx);
+ return False;
+ }
}
- return &null_part;
-}
-
-NTSTATUS ldapsrv_unwilling(struct ldapsrv_call *call, int error)
-{
- struct ldapsrv_reply *reply;
- struct ldap_ExtendedResponse *r;
-
- DEBUG(0,("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;
+ ret = ldapsrv_append_to_buf(&conn->in_buffer, tmp_blob.data, tmp_blob.length);
+ if (!ret) {
+ talloc_free(mem_ctx);
+ return False;
}
- r = &reply->msg.r.ExtendedResponse;
- r->response.resultcode = error;
- r->response.dn = NULL;
- r->response.errormessage = NULL;
- r->response.referral = NULL;
- r->name = NULL;
- r->value.data = NULL;
- r->value.length = 0;
+ ldapsrv_consumed_from_buf(&conn->sasl_in_buffer, 4 + sasl_length);
- return ldapsrv_queue_reply(call, reply);
+ talloc_free(mem_ctx);
+ return ret;
}
-static NTSTATUS ldapsrv_BindRequest(struct ldapsrv_call *call)
+static BOOL write_from_buf(struct socket_context *sock, struct rw_buffer *buf)
{
- struct ldap_BindRequest *req = &call->request.r.BindRequest;
- struct ldapsrv_reply *reply;
- struct ldap_BindResponse *resp;
+ NTSTATUS status;
+ DATA_BLOB tmp_blob;
+ size_t sendlen;
- DEBUG(5, ("BindRequest dn: %s\n",req->dn));
+ tmp_blob.data = buf->data;
+ tmp_blob.length = buf->length;
- reply = ldapsrv_init_reply(call, LDAP_TAG_BindResponse);
- if (!reply) {
- return NT_STATUS_NO_MEMORY;
+ status = socket_send(sock, &tmp_blob, &sendlen, 0);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10,("socket_send() %s\n",nt_errstr(status)));
+ return False;
}
- resp = &reply->msg.r.BindResponse;
- resp->response.resultcode = 0;
- resp->response.dn = NULL;
- resp->response.errormessage = NULL;
- resp->response.referral = NULL;
- resp->SASL.secblob = data_blob(NULL, 0);
+ ldapsrv_consumed_from_buf(buf, sendlen);
- return ldapsrv_queue_reply(call, reply);
-}
-
-static NTSTATUS ldapsrv_UnbindRequest(struct ldapsrv_call *call)
-{
-/* struct ldap_UnbindRequest *req = &call->request->r.UnbindRequest;*/
- DEBUG(10, ("UnbindRequest\n"));
- return NT_STATUS_OK;
+ return True;
}
-static NTSTATUS ldapsrv_SearchRequest(struct ldapsrv_call *call)
+static BOOL ldapsrv_write_buf(struct ldapsrv_connection *conn)
{
- struct ldap_SearchRequest *req = &call->request.r.SearchRequest;
- struct ldapsrv_partition *part;
-
- DEBUG(10, ("SearchRequest"));
- DEBUGADD(10, (" basedn: %s", req->basedn));
- DEBUGADD(10, (" filter: %s\n", req->filter));
-
- part = ldapsrv_get_partition(call->conn, req->basedn);
-
- if (!part->ops->Search) {
- struct ldap_Result *done;
- struct ldapsrv_reply *done_r;
-
- done_r = ldapsrv_init_reply(call, LDAP_TAG_SearchResultDone);
- if (!done_r) {
- return NT_STATUS_NO_MEMORY;
- }
-
- done = &done_r->msg.r.SearchResultDone;
- done->resultcode = 53;
- done->dn = NULL;
- done->errormessage = NULL;
- done->referral = NULL;
+ NTSTATUS status;
+ DATA_BLOB tmp_blob;
+ DATA_BLOB creds;
+ DATA_BLOB sasl;
+ size_t sendlen;
+ BOOL ret;
+ struct socket_context *sock = conn->connection->socket;
+ TALLOC_CTX *mem_ctx;
- return ldapsrv_queue_reply(call, done_r);
+ if (!conn->gensec || !conn->session_info ||
+ !(gensec_have_feature(conn->gensec, GENSEC_WANT_SIGN) &&
+ gensec_have_feature(conn->gensec, GENSEC_WANT_SEAL))) {
+ return write_from_buf(sock, &conn->out_buffer);
}
- return part->ops->Search(part, call, req);
-}
-
-static NTSTATUS ldapsrv_ModifyRequest(struct ldapsrv_call *call)
-{
- struct ldap_ModifyRequest *req = &call->request.r.ModifyRequest;
- struct ldapsrv_partition *part;
-
- DEBUG(10, ("ModifyRequest"));
- DEBUGADD(10, (" dn: %s", req->dn));
-
- part = ldapsrv_get_partition(call->conn, req->dn);
-
- if (!part->ops->Modify) {
- return ldapsrv_unwilling(call, 53);
+ mem_ctx = talloc(conn, 0);
+ if (!mem_ctx) {
+ DEBUG(0,("no memory\n"));
+ return False;
}
- return part->ops->Modify(part, call, req);
-}
-
-static NTSTATUS ldapsrv_AddRequest(struct ldapsrv_call *call)
-{
- struct ldap_AddRequest *req = &call->request.r.AddRequest;
- struct ldapsrv_partition *part;
-
- DEBUG(10, ("AddRequest"));
- DEBUGADD(10, (" dn: %s", req->dn));
-
- part = ldapsrv_get_partition(call->conn, req->dn);
+ tmp_blob.data = conn->out_buffer.data;
+ tmp_blob.length = conn->out_buffer.length;
- if (!part->ops->Add) {
- return ldapsrv_unwilling(call, 53);
+ if (tmp_blob.length == 0) {
+ goto nodata;
}
- return part->ops->Add(part, call, req);
-}
-
-static NTSTATUS ldapsrv_DelRequest(struct ldapsrv_call *call)
-{
- struct ldap_DelRequest *req = &call->request.r.DelRequest;
- struct ldapsrv_partition *part;
-
- DEBUG(10, ("DelRequest"));
- DEBUGADD(10, (" dn: %s", req->dn));
-
- part = ldapsrv_get_partition(call->conn, req->dn);
-
- if (!part->ops->Del) {
- return ldapsrv_unwilling(call, 53);
+ if (gensec_have_feature(conn->gensec, GENSEC_WANT_SEAL)) {
+ status = gensec_seal_packet(conn->gensec, mem_ctx,
+ tmp_blob.data, tmp_blob.length,
+ tmp_blob.data, tmp_blob.length,
+ &creds);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("gensec_seal_packet: %s\n",nt_errstr(status)));
+ talloc_free(mem_ctx);
+ return False;
+ }
+ } else {
+ status = gensec_sign_packet(conn->gensec, mem_ctx,
+ tmp_blob.data, tmp_blob.length,
+ tmp_blob.data, tmp_blob.length,
+ &creds);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("gensec_sign_packet: %s\n",nt_errstr(status)));
+ talloc_free(mem_ctx);
+ return False;
+ }
}
- return part->ops->Del(part, call, req);
-}
-
-static NTSTATUS ldapsrv_ModifyDNRequest(struct ldapsrv_call *call)
-{
- struct ldap_ModifyDNRequest *req = &call->request.r.ModifyDNRequest;
- struct ldapsrv_partition *part;
-
- DEBUG(10, ("ModifyDNRequrest"));
- DEBUGADD(10, (" dn: %s", req->dn));
- DEBUGADD(10, (" newrdn: %s", req->newrdn));
-
- part = ldapsrv_get_partition(call->conn, req->dn);
-
- if (!part->ops->ModifyDN) {
- return ldapsrv_unwilling(call, 53);
+ sasl = data_blob_talloc(mem_ctx, NULL, 4 + creds.length + tmp_blob.length);
+ if (!sasl.data) {
+ DEBUG(0,("no memory\n"));
+ talloc_free(mem_ctx);
+ return False;
}
- return part->ops->ModifyDN(part, call, req);
-}
+ RSIVAL(sasl.data, 0, creds.length + tmp_blob.length);
+ memcpy(sasl.data + 4, creds.data, creds.length);
+ memcpy(sasl.data + 4 + creds.length, tmp_blob.data, tmp_blob.length);
-static NTSTATUS ldapsrv_CompareRequest(struct ldapsrv_call *call)
-{
- struct ldap_CompareRequest *req = &call->request.r.CompareRequest;
- struct ldapsrv_partition *part;
-
- DEBUG(10, ("CompareRequest"));
- DEBUGADD(10, (" dn: %s", req->dn));
-
- part = ldapsrv_get_partition(call->conn, req->dn);
+ ret = ldapsrv_append_to_buf(&conn->sasl_out_buffer, sasl.data, sasl.length);
+ if (!ret) {
+ talloc_free(mem_ctx);
+ return False;
+ }
+ ldapsrv_consumed_from_buf(&conn->out_buffer, tmp_blob.length);
+nodata:
+ tmp_blob.data = conn->sasl_out_buffer.data;
+ tmp_blob.length = conn->sasl_out_buffer.length;
- if (!part->ops->Compare) {
- return ldapsrv_unwilling(call, 53);
+ status = socket_send(sock, &tmp_blob, &sendlen, 0);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10,("socket_send() %s\n",nt_errstr(status)));
+ talloc_free(mem_ctx);
+ return False;
}
- return part->ops->Compare(part, call, req);
-}
+ ldapsrv_consumed_from_buf(&conn->sasl_out_buffer, sendlen);
-static NTSTATUS ldapsrv_AbandonRequest(struct ldapsrv_call *call)
-{
-/* struct ldap_AbandonRequest *req = &call->request.r.AbandonRequest;*/
- DEBUG(10, ("AbandonRequest\n"));
- return NT_STATUS_OK;
+ talloc_free(mem_ctx);
+
+ return True;
}
-static NTSTATUS ldapsrv_ExtendedRequest(struct ldapsrv_call *call)
+static BOOL ldap_encode_to_buf(struct ldap_message *msg, struct rw_buffer *buf)
{
-/* struct ldap_ExtendedRequest *req = &call->request.r.ExtendedRequest;*/
- struct ldapsrv_reply *reply;
-
- DEBUG(10, ("Extended\n"));
-
- reply = ldapsrv_init_reply(call, LDAP_TAG_ExtendedResponse);
- if (!reply) {
- return NT_STATUS_NO_MEMORY;
- }
+ DATA_BLOB blob;
+ BOOL res;
- ZERO_STRUCT(reply->msg.r);
+ if (!ldap_encode(msg, &blob))
+ return False;
- return ldapsrv_queue_reply(call, reply);
-}
+ res = ldapsrv_append_to_buf(buf, blob.data, blob.length);
-static NTSTATUS ldapsrv_do_call(struct ldapsrv_call *call)
-{
- switch(call->request.type) {
- case LDAP_TAG_BindRequest:
- return ldapsrv_BindRequest(call);
- case LDAP_TAG_UnbindRequest:
- return ldapsrv_UnbindRequest(call);
- case LDAP_TAG_SearchRequest:
- return ldapsrv_SearchRequest(call);
- case LDAP_TAG_ModifyRequest:
- return ldapsrv_ModifyRequest(call);
- case LDAP_TAG_AddRequest:
- return ldapsrv_AddRequest(call);
- case LDAP_TAG_DelRequest:
- return ldapsrv_DelRequest(call);
- case LDAP_TAG_ModifyDNRequest:
- return ldapsrv_ModifyDNRequest(call);
- case LDAP_TAG_CompareRequest:
- return ldapsrv_CompareRequest(call);
- case LDAP_TAG_AbandonRequest:
- return ldapsrv_AbandonRequest(call);
- case LDAP_TAG_ExtendedRequest:
- return ldapsrv_ExtendedRequest(call);
- default:
- return ldapsrv_unwilling(call, 2);
- }
+ data_blob_free(&blob);
+ return res;
}
-static NTSTATUS ldapsrv_do_responses(struct ldapsrv_connection *conn)
+NTSTATUS ldapsrv_do_responses(struct ldapsrv_connection *conn)
{
struct ldapsrv_call *call, *next_call = NULL;
struct ldapsrv_reply *reply, *next_reply = NULL;
for (call=conn->calls; call; call=next_call) {
for (reply=call->replies; reply; reply=next_reply) {
- if (!ldap_append_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 NT_STATUS_OK;
}
+NTSTATUS ldapsrv_flush_responses(struct ldapsrv_connection *conn)
+{
+ return NT_STATUS_OK;
+}
+
/*
called when a LDAP socket becomes readable
*/
-static void ldapsrv_recv(struct server_connection *conn, time_t t,
+static void ldapsrv_recv(struct server_connection *conn, struct timeval t,
uint16_t flags)
{
struct ldapsrv_connection *ldap_conn = conn->private_data;
uint8_t *buf;
int buf_length, msg_length;
DATA_BLOB blob;
- ASN1_DATA data;
+ struct asn1_data data;
struct ldapsrv_call *call;
NTSTATUS status;
DEBUG(10,("ldapsrv_recv\n"));
- if (!read_into_buf(conn->socket, &ldap_conn->in_buffer)) {
- ldapsrv_terminate_connection(ldap_conn, "read_into_buf() failed");
+ if (!ldapsrv_read_buf(ldap_conn)) {
+ ldapsrv_terminate_connection(ldap_conn, "ldapsrv_read_buf() failed");
return;
}
peek_into_read_buf(&ldap_conn->in_buffer, &buf, &buf_length);
while (buf_length > 0) {
-
- peek_into_read_buf(&ldap_conn->in_buffer, &buf, &buf_length);
/* LDAP Messages are always SEQUENCES */
if (!asn1_object_length(buf, buf_length, ASN1_SEQUENCE(0),
ZERO_STRUCTP(call);
call->state = LDAPSRV_CALL_STATE_NEW;
call->conn = ldap_conn;
- /* TODO: we should use talloc_reference() here */
- call->session_info = ldap_conn->session_info;
call->request.mem_ctx = call;
if (!ldap_decode(&data, &call->request)) {
dump_data(0,buf, msg_length);
+ asn1_free(&data);
ldapsrv_terminate_connection(ldap_conn, "ldap_decode() failed");
return;
}
+ asn1_free(&data);
+
DLIST_ADD_END(ldap_conn->calls, call,
struct ldapsrv_call *);
- consumed_from_buf(&ldap_conn->in_buffer, msg_length);
+ ldapsrv_consumed_from_buf(&ldap_conn->in_buffer, msg_length);
status = ldapsrv_do_call(call);
if (!NT_STATUS_IS_OK(status)) {
return;
}
- if (ldap_conn->out_buffer.length > 0) {
+ if ((ldap_conn->out_buffer.length > 0)||(ldap_conn->sasl_out_buffer.length > 0)) {
conn->event.fde->flags |= EVENT_FD_WRITE;
}
/*
called when a LDAP socket becomes writable
*/
-static void ldapsrv_send(struct server_connection *conn, time_t t,
+static void ldapsrv_send(struct server_connection *conn, struct timeval t,
uint16_t flags)
{
struct ldapsrv_connection *ldap_conn = conn->private_data;
DEBUG(10,("ldapsrv_send\n"));
- if (!write_from_buf(conn->socket, &ldap_conn->out_buffer)) {
- ldapsrv_terminate_connection(ldap_conn, "write_from_buf() failed");
+ if (!ldapsrv_write_buf(ldap_conn)) {
+ ldapsrv_terminate_connection(ldap_conn, "ldapsrv_write_buf() failed");
return;
}
- if (ldap_conn->out_buffer.length == 0) {
+ if (ldap_conn->out_buffer.length == 0 && ldap_conn->sasl_out_buffer.length == 0) {
conn->event.fde->flags &= ~EVENT_FD_WRITE;
}
/*
called when connection is idle
*/
-static void ldapsrv_idle(struct server_connection *conn, time_t t)
+static void ldapsrv_idle(struct server_connection *conn, struct timeval t)
{
DEBUG(10,("ldapsrv_idle: not implemented!\n"));
return;
{
struct ldapsrv_connection *ldap_conn;
- DEBUG(5, ("ldapsrv_accept\n"));
+ DEBUG(10, ("ldapsrv_accept\n"));
ldap_conn = talloc_p(conn, struct ldapsrv_connection);
ZERO_STRUCTP(ldap_conn);
ldap_conn->connection = conn;
+ ldap_conn->service = talloc_reference(ldap_conn, conn->service->private_data);
conn->private_data = ldap_conn;
*/
static void ldapsrv_exit(struct server_service *service, const char *reason)
{
- DEBUG(1,("ldapsrv_exit\n"));
+ DEBUG(10,("ldapsrv_exit\n"));
return;
}