*/
#include "includes.h"
+#include "lib/events/events.h"
+#include "auth/auth.h"
+#include "dlinklist.h"
+#include "asn_1.h"
+#include "ldap_server/ldap_server.h"
+#include "smbd/service_stream.h"
+#include "lib/socket/socket.h"
/*
close the socket and shutdown a server_context
*/
static void ldapsrv_terminate_connection(struct ldapsrv_connection *ldap_conn, const char *reason)
{
- server_terminate_connection(ldap_conn->connection, reason);
-}
-
-/*
- add a socket address to the list of events, one event per port
-*/
-static void add_socket(struct server_service *service,
- const struct model_ops *model_ops,
- struct in_addr *ifip)
-{
- struct server_socket *srv_sock;
- uint16_t port = 389;
- char *ip_str = talloc_strdup(service, inet_ntoa(*ifip));
-
- srv_sock = service_setup_socket(service, model_ops, ip_str, &port);
-
- talloc_free(ip_str);
-}
-
-/****************************************************************************
- Open the socket communication.
-****************************************************************************/
-static void ldapsrv_init(struct server_service *service,
- const struct model_ops *model_ops)
-{
- 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();
- int i;
-
- /* We have been given an interfaces line, and been
- told to only bind to those interfaces. Create a
- socket per interface and bind to only these.
- */
- for(i = 0; i < num_interfaces; i++) {
- struct in_addr *ifip = iface_n_ip(i);
-
- if (ifip == NULL) {
- DEBUG(0,("ldapsrv_init: interface %d has NULL "
- "IP address !\n", i));
- continue;
- }
-
- add_socket(service, model_ops, ifip);
- }
- } else {
- struct in_addr *ifip;
-
- /* Just bind to lp_socket_address() (usually 0.0.0.0) */
- ifip = interpret_addr2(service, lp_socket_address());
- add_socket(service, model_ops, ifip);
-
- talloc_destroy(ifip);
- }
+ stream_terminate_connection(ldap_conn->connection, reason);
}
/* This rw-buf api is made to avoid memcpy. For now do that like mad... The
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);
+ memmove(buf->data, buf->data+length, buf->length-length);
buf->length -= length;
}
*out_length = buf->length;
}
-static BOOL append_to_buf(struct rw_buffer *buf, uint8_t *data, size_t 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)) {
+ 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;
}
+ tmp_blob.length = nread;
- 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);
{
NTSTATUS status;
DATA_BLOB tmp_blob;
- DATA_BLOB creds;
+ DATA_BLOB wrapped;
+ DATA_BLOB unwrapped;
BOOL ret;
uint8_t *buf;
- int buf_length, sasl_length;
+ size_t buf_length, sasl_length;
struct socket_context *sock = conn->connection->socket;
TALLOC_CTX *mem_ctx;
+ size_t nread;
- if (!conn->gensec ||
- !(gensec_have_feature(conn->gensec, GENSEC_WANT_SIGN) &&
- gensec_have_feature(conn->gensec, GENSEC_WANT_SEAL))) {
+ if (!conn->gensec) {
+ return read_into_buf(sock, &conn->in_buffer);
+ }
+ if (!conn->session_info) {
+ return read_into_buf(sock, &conn->in_buffer);
+ }
+ if (!(gensec_have_feature(conn->gensec, GENSEC_FEATURE_SIGN) ||
+ gensec_have_feature(conn->gensec, GENSEC_FEATURE_SEAL))) {
return read_into_buf(sock, &conn->in_buffer);
}
- mem_ctx = talloc(conn, 0);
+ mem_ctx = talloc_new(conn);
if (!mem_ctx) {
DEBUG(0,("no memory\n"));
return False;
}
- status = socket_recv(sock, mem_ctx, &tmp_blob, 1024, 0);
- if (!NT_STATUS_IS_OK(status)) {
+ tmp_blob = data_blob_talloc(mem_ctx, NULL, 1024);
+ if (tmp_blob.data == NULL) {
+ talloc_free(mem_ctx);
+ 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(mem_ctx);
return False;
}
+ tmp_blob.length = nread;
- ret = append_to_buf(&conn->sasl_in_buffer, tmp_blob.data, tmp_blob.length);
+ ret = ldapsrv_append_to_buf(&conn->sasl_in_buffer, tmp_blob.data, tmp_blob.length);
if (!ret) {
talloc_free(mem_ctx);
return False;
sasl_length = RIVAL(buf, 0);
- if (buf_length < (4 + sasl_length)) {
+ if ((buf_length - 4) < sasl_length) {
/* not enough yet */
talloc_free(mem_ctx);
return True;
}
- creds.data = buf + 4;
- creds.length = gensec_sig_size(conn->gensec);
+ wrapped.data = buf + 4;
+ wrapped.length = sasl_length;
- if (creds.length > sasl_length) {
- /* invalid packet? */
+ status = gensec_unwrap(conn->gensec, mem_ctx,
+ &wrapped,
+ &unwrapped);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("gensec_unwrap: %s\n",nt_errstr(status)));
talloc_free(mem_ctx);
return False;
}
- tmp_blob.data = buf + (4 + creds.length);
- tmp_blob.length = (4 + sasl_length) - (4 + creds.length);
-
- 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 {
- 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;
- }
- }
-
- ret = append_to_buf(&conn->in_buffer, tmp_blob.data, tmp_blob.length);
+ ret = ldapsrv_append_to_buf(&conn->in_buffer, unwrapped.data, unwrapped.length);
if (!ret) {
talloc_free(mem_ctx);
return False;
}
- consumed_from_buf(&conn->sasl_in_buffer, 4 + sasl_length);
+ ldapsrv_consumed_from_buf(&conn->sasl_in_buffer, 4 + sasl_length);
talloc_free(mem_ctx);
return ret;
tmp_blob.data = buf->data;
tmp_blob.length = buf->length;
- status = socket_send(sock, sock, &tmp_blob, &sendlen, 0);
+ 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;
}
- consumed_from_buf(buf, sendlen);
+ ldapsrv_consumed_from_buf(buf, sendlen);
return True;
}
static BOOL ldapsrv_write_buf(struct ldapsrv_connection *conn)
{
NTSTATUS status;
+ DATA_BLOB wrapped;
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;
- if (!conn->gensec ||
- !(gensec_have_feature(conn->gensec, GENSEC_WANT_SIGN) &&
- gensec_have_feature(conn->gensec, GENSEC_WANT_SEAL))) {
+
+ if (!conn->gensec) {
+ return write_from_buf(sock, &conn->out_buffer);
+ }
+ if (!conn->session_info) {
+ return write_from_buf(sock, &conn->out_buffer);
+ }
+ if (conn->sasl_out_buffer.length == 0 &&
+ !(gensec_have_feature(conn->gensec, GENSEC_FEATURE_SIGN) ||
+ gensec_have_feature(conn->gensec, GENSEC_FEATURE_SEAL))) {
return write_from_buf(sock, &conn->out_buffer);
}
- mem_ctx = talloc(conn, 0);
+ mem_ctx = talloc_new(conn);
if (!mem_ctx) {
DEBUG(0,("no memory\n"));
return False;
}
+ if (conn->out_buffer.length == 0) {
+ goto nodata;
+ }
+
tmp_blob.data = conn->out_buffer.data;
tmp_blob.length = conn->out_buffer.length;
-
- 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;
- }
+ status = gensec_wrap(conn->gensec, mem_ctx,
+ &tmp_blob,
+ &wrapped);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0,("gensec_wrap: %s\n",nt_errstr(status)));
+ talloc_free(mem_ctx);
+ return False;
}
- sasl = data_blob_talloc(mem_ctx, NULL, 4 + creds.length + tmp_blob.length);
+ sasl = data_blob_talloc(mem_ctx, NULL, 4 + wrapped.length);
if (!sasl.data) {
DEBUG(0,("no memory\n"));
talloc_free(mem_ctx);
return False;
}
- 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);
+ RSIVAL(sasl.data, 0, wrapped.length);
+ memcpy(sasl.data + 4, wrapped.data, wrapped.length);
- ret = append_to_buf(&conn->sasl_out_buffer, sasl.data, sasl.length);
+ ret = ldapsrv_append_to_buf(&conn->sasl_out_buffer, sasl.data, sasl.length);
if (!ret) {
talloc_free(mem_ctx);
return False;
}
- consumed_from_buf(&conn->out_buffer, tmp_blob.length);
+ ldapsrv_consumed_from_buf(&conn->out_buffer, conn->out_buffer.length);
+nodata:
+ tmp_blob.data = conn->sasl_out_buffer.data;
+ tmp_blob.length = conn->sasl_out_buffer.length;
- status = socket_send(sock, mem_ctx, &tmp_blob, &sendlen, 0);
+ 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;
}
- consumed_from_buf(&conn->sasl_out_buffer, sendlen);
+ ldapsrv_consumed_from_buf(&conn->sasl_out_buffer, sendlen);
talloc_free(mem_ctx);
return True;
}
-static BOOL ldap_append_to_buf(struct ldap_message *msg, struct rw_buffer *buf)
+static BOOL ldap_encode_to_buf(struct ldap_message *msg, struct rw_buffer *buf)
{
DATA_BLOB blob;
BOOL res;
if (!ldap_encode(msg, &blob))
return False;
- res = append_to_buf(buf, blob.data, blob.length);
+ res = ldapsrv_append_to_buf(buf, blob.data, blob.length);
data_blob_free(&blob);
return res;
}
-struct ldapsrv_reply *ldapsrv_init_reply(struct ldapsrv_call *call, enum ldap_request_tag type)
-{
- struct ldapsrv_reply *reply;
-
- reply = talloc_p(call, struct ldapsrv_reply);
- if (!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;
-
- 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;
-}
-
-struct ldapsrv_partition *ldapsrv_get_partition(struct ldapsrv_connection *conn, const char *dn)
-{
- if (strcasecmp("", dn) == 0) {
- return conn->service->rootDSE;
- }
-
- return conn->service->default_partition;
-}
-
-NTSTATUS ldapsrv_unwilling(struct ldapsrv_call *call, int error)
-{
- struct ldapsrv_reply *reply;
- struct ldap_ExtendedResponse *r;
-
- 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->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;
-
- return ldapsrv_queue_reply(call, reply);
-}
-
-static NTSTATUS ldapsrv_BindRequest(struct ldapsrv_call *call)
-{
- struct ldap_BindRequest *req = &call->request.r.BindRequest;
- struct ldapsrv_reply *reply;
- struct ldap_BindResponse *resp;
-
- DEBUG(10, ("BindRequest dn: %s\n",req->dn));
-
- reply = ldapsrv_init_reply(call, LDAP_TAG_BindResponse);
- if (!reply) {
- return NT_STATUS_NO_MEMORY;
- }
-
- 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);
-
- 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;
-}
-
-static NTSTATUS ldapsrv_SearchRequest(struct ldapsrv_call *call)
-{
- 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;
-
- return ldapsrv_queue_reply(call, done_r);
- }
-
- 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);
- }
-
- 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);
-
- if (!part->ops->Add) {
- return ldapsrv_unwilling(call, 53);
- }
-
- 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);
- }
-
- 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);
- }
-
- return part->ops->ModifyDN(part, call, req);
-}
-
-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);
-
- if (!part->ops->Compare) {
- return ldapsrv_unwilling(call, 53);
- }
-
- return part->ops->Compare(part, call, req);
-}
-
-static NTSTATUS ldapsrv_AbandonRequest(struct ldapsrv_call *call)
-{
-/* struct ldap_AbandonRequest *req = &call->request.r.AbandonRequest;*/
- DEBUG(10, ("AbandonRequest\n"));
- return NT_STATUS_OK;
-}
-
-static NTSTATUS ldapsrv_ExtendedRequest(struct ldapsrv_call *call)
-{
-/* 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;
- }
-
- ZERO_STRUCT(reply->msg.r);
-
- return ldapsrv_queue_reply(call, reply);
-}
-
-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);
- }
-}
-
-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,
- uint16_t flags)
+static void ldapsrv_recv(struct stream_connection *conn, uint16_t flags)
{
- struct ldapsrv_connection *ldap_conn = conn->private_data;
+ struct ldapsrv_connection *ldap_conn = talloc_get_type(conn->private, struct ldapsrv_connection);
uint8_t *buf;
- int buf_length, msg_length;
+ size_t buf_length, msg_length;
DATA_BLOB blob;
- ASN1_DATA data;
+ struct asn1_data data;
struct ldapsrv_call *call;
NTSTATUS status;
return;
}
- call = talloc_p(ldap_conn, struct ldapsrv_call);
+ call = talloc(ldap_conn, struct ldapsrv_call);
if (!call) {
ldapsrv_terminate_connection(ldap_conn, "no memory");
return;
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)) {
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)) {
}
if ((ldap_conn->out_buffer.length > 0)||(ldap_conn->sasl_out_buffer.length > 0)) {
- conn->event.fde->flags |= EVENT_FD_WRITE;
+ EVENT_FD_WRITEABLE(conn->event.fde);
}
return;
/*
called when a LDAP socket becomes writable
*/
-static void ldapsrv_send(struct server_connection *conn, time_t t,
- uint16_t flags)
+static void ldapsrv_send(struct stream_connection *conn, uint16_t flags)
{
- struct ldapsrv_connection *ldap_conn = conn->private_data;
+ struct ldapsrv_connection *ldap_conn = talloc_get_type(conn->private, struct ldapsrv_connection);
DEBUG(10,("ldapsrv_send\n"));
}
if (ldap_conn->out_buffer.length == 0 && ldap_conn->sasl_out_buffer.length == 0) {
- conn->event.fde->flags &= ~EVENT_FD_WRITE;
+ EVENT_FD_NOT_WRITEABLE(conn->event.fde);
}
return;
}
-/*
- called when connection is idle
-*/
-static void ldapsrv_idle(struct server_connection *conn, time_t t)
-{
- DEBUG(10,("ldapsrv_idle: not implemented!\n"));
- return;
-}
-
-static void ldapsrv_close(struct server_connection *conn, const char *reason)
-{
- return;
-}
-
/*
initialise a server_context from a open socket and register a event handler
for reading from that socket
*/
-static void ldapsrv_accept(struct server_connection *conn)
+static void ldapsrv_accept(struct stream_connection *conn)
{
struct ldapsrv_connection *ldap_conn;
DEBUG(10, ("ldapsrv_accept\n"));
- ldap_conn = talloc_p(conn, struct ldapsrv_connection);
+ ldap_conn = talloc_zero(conn, struct ldapsrv_connection);
if (ldap_conn == NULL)
return;
- ZERO_STRUCTP(ldap_conn);
ldap_conn->connection = conn;
- ldap_conn->service = talloc_reference(ldap_conn, conn->service->private_data);
-
- conn->private_data = ldap_conn;
-
- return;
+ ldap_conn->service = talloc_get_type(conn->private, struct ldapsrv_service);
+ conn->private = ldap_conn;
}
-/*
- called on a fatal error that should cause this server to terminate
-*/
-static void ldapsrv_exit(struct server_service *service, const char *reason)
-{
- DEBUG(10,("ldapsrv_exit\n"));
- return;
-}
-
-static const struct server_service_ops ldap_server_ops = {
+static const struct stream_server_ops ldap_stream_ops = {
.name = "ldap",
- .service_init = ldapsrv_init,
.accept_connection = ldapsrv_accept,
.recv_handler = ldapsrv_recv,
.send_handler = ldapsrv_send,
- .idle_handler = ldapsrv_idle,
- .close_connection = ldapsrv_close,
- .service_exit = ldapsrv_exit,
};
-const struct server_service_ops *ldapsrv_get_ops(void)
+/*
+ add a socket address to the list of events, one event per port
+*/
+static NTSTATUS add_socket(struct event_context *event_context, const struct model_ops *model_ops,
+ const char *address, struct ldapsrv_service *ldap_service)
{
- return &ldap_server_ops;
+ uint16_t port = 389;
+ NTSTATUS status;
+
+ status = stream_setup_socket(event_context, model_ops, &ldap_stream_ops,
+ "ipv4", address, &port, ldap_service);
+ NT_STATUS_NOT_OK_RETURN(status);
+
+ port = 3268;
+
+ return stream_setup_socket(event_context, model_ops, &ldap_stream_ops,
+ "ipv4", address, &port, ldap_service);
+}
+
+/*
+ open the ldap server sockets
+*/
+static NTSTATUS ldapsrv_init(struct event_context *event_context, const struct model_ops *model_ops)
+{
+ struct ldapsrv_service *ldap_service;
+ struct ldapsrv_partition *rootDSE_part;
+ struct ldapsrv_partition *part;
+ NTSTATUS status;
+
+ DEBUG(10,("ldapsrv_init\n"));
+
+ ldap_service = talloc_zero(event_context, struct ldapsrv_service);
+ NT_STATUS_HAVE_NO_MEMORY(ldap_service);
+
+ rootDSE_part = talloc(ldap_service, struct ldapsrv_partition);
+ NT_STATUS_HAVE_NO_MEMORY(rootDSE_part);
+
+ rootDSE_part->base_dn = ""; /* RootDSE */
+ rootDSE_part->ops = ldapsrv_get_rootdse_partition_ops();
+
+ ldap_service->rootDSE = rootDSE_part;
+ DLIST_ADD_END(ldap_service->partitions, rootDSE_part, struct ldapsrv_partition *);
+
+ part = talloc(ldap_service, struct ldapsrv_partition);
+ NT_STATUS_HAVE_NO_MEMORY(part);
+
+ part->base_dn = "*"; /* default partition */
+ if (lp_parm_bool(-1, "ldapsrv", "hacked", False)) {
+ part->ops = ldapsrv_get_hldb_partition_ops();
+ } else {
+ part->ops = ldapsrv_get_sldb_partition_ops();
+ }
+
+ ldap_service->default_partition = part;
+ DLIST_ADD_END(ldap_service->partitions, part, struct ldapsrv_partition *);
+
+ if (lp_interfaces() && lp_bind_interfaces_only()) {
+ int num_interfaces = iface_count();
+ int i;
+
+ /* We have been given an interfaces line, and been
+ told to only bind to those interfaces. Create a
+ socket per interface and bind to only these.
+ */
+ for(i = 0; i < num_interfaces; i++) {
+ const char *address = iface_n_ip(i);
+ status = add_socket(event_context, model_ops, address, ldap_service);
+ NT_STATUS_NOT_OK_RETURN(status);
+ }
+ } else {
+ status = add_socket(event_context, model_ops, lp_socket_address(), ldap_service);
+ NT_STATUS_NOT_OK_RETURN(status);
+ }
+
+ return NT_STATUS_OK;
}
+
NTSTATUS server_service_ldap_init(void)
{
- return NT_STATUS_OK;
+ return register_server_service("ldap", ldapsrv_init);
}
git.samba.org / jelmer / samba4-debian.git / blobdiff