--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+ LDAP server
+ Copyright (C) Volker Lendecke 2004
+ Copyright (C) Stefan Metzmacher 2004
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.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 socket_context *socket_ctx,
+ struct in_addr *ifip)
+{
+ uint16_t port = 389;
+
+ service_setup_socket(service, model_ops, socket_ctx, ifip, &port);
+}
+
+/****************************************************************************
+ Open the socket communication.
+****************************************************************************/
+static void ldapsrv_init(struct server_service *service,
+ const struct model_ops *model_ops)
+{
+ DEBUG(1,("ldapsrv_init\n"));
+
+ 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, NULL, ifip);
+ }
+ } else {
+ struct in_addr *ifip;
+ TALLOC_CTX *mem_ctx = talloc_init("ldapsrv_init");
+
+ if (!mem_ctx) {
+ smb_panic("No memory");
+ }
+
+ /* Just bind to lp_socket_address() (usually 0.0.0.0) */
+ ifip = interpret_addr2(mem_ctx, lp_socket_address());
+ add_socket(service, model_ops, NULL, ifip);
+
+ talloc_destroy(mem_ctx);
+ }
+}
+
+/* This rw-buf api is made to avoid memcpy. For now do that like mad... The
+ idea is to write into a circular list of buffers where the ideal case is
+ that a read(2) holds a complete request that is then thrown away
+ completely. */
+
+static BOOL append_to_buf(struct rw_buffer *buf, uint8_t *data, size_t length)
+{
+ buf->data = realloc(buf->data, buf->length+length);
+
+ if (buf->data == NULL)
+ return False;
+
+ memcpy(buf->data+buf->length, data, length);
+
+ buf->length += length;
+ return True;
+}
+
+static BOOL read_into_buf(int fd, struct rw_buffer *buf)
+{
+ char tmp_buf[1024];
+ int len;
+
+ len = read(fd, tmp_buf, sizeof(tmp_buf));
+ if (len == 0)
+ return False;
+
+ return append_to_buf(buf, tmp_buf, len);
+}
+
+static BOOL write_from_buf(int fd, struct rw_buffer *buf)
+{
+ int len;
+
+ len = write(fd, buf->data, buf->length);
+ if (len != buf->length)
+ return False;
+
+ 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;
+}
+
+static void consumed_from_read_buf(struct rw_buffer *buf,
+ size_t length)
+{
+ memcpy(buf->data, buf->data+length, buf->length-length);
+ buf->length -= length;
+}
+
+static BOOL ldap_append_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);
+
+ data_blob_free(&blob);
+ return res;
+}
+
+static void reply_unwilling(struct ldapsrv_connection *ldap_conn, int error)
+{
+ struct ldap_message *msg;
+ struct ldap_ExtendedResponse *r;
+
+ msg = new_ldap_message();
+
+ if (msg == NULL) {
+ ldapsrv_terminate_connection(ldap_conn, "new_ldap_message() failed");
+ return;
+ }
+
+ msg->messageid = 0;
+ r = &msg->r.ExtendedResponse;
+
+ /* When completely freaking out, OpenLDAP responds with an ExtResp */
+ msg->type = LDAP_TAG_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;
+
+ ldap_append_to_buf(msg, &ldap_conn->out_buffer);
+
+ talloc_destroy(msg->mem_ctx);
+}
+
+static void ldap_reply_BindRequest(struct ldapsrv_connection *conn,
+ struct ldap_message *request)
+{
+ struct ldap_BindRequest *req = &request->r.BindRequest;
+
+ struct ldap_message *msg;
+ struct ldap_BindResponse *resp;
+
+ DEBUG(5, ("Binding as %s with pw %s\n",
+ req->dn, req->creds.password));
+
+ msg = new_ldap_message();
+
+ if (msg == NULL) {
+ ldapsrv_terminate_connection(conn, "new_ldap_message() failed");
+ return;
+ }
+
+ resp = &msg->r.BindResponse;
+
+ msg->messageid = request->messageid;
+ msg->type = LDAP_TAG_BindResponse;
+ resp->response.resultcode = 0;
+ resp->response.dn = NULL;
+ resp->response.errormessage = NULL;
+ resp->response.referral = NULL;
+ resp->SASL.secblob = data_blob(NULL, 0);
+
+ ldap_append_to_buf(msg, &conn->out_buffer);
+ talloc_destroy(msg->mem_ctx);
+}
+
+static void ldap_reply_SearchRequest(struct ldapsrv_connection *conn,
+ struct ldap_message *request)
+{
+ struct ldap_SearchRequest *req = &request->r.SearchRequest;
+
+ struct ldap_message *msg;
+ struct ldap_Result *resp;
+
+ DEBUG(10, ("Search filter: %s\n", req->filter));
+
+ msg = new_ldap_message();
+
+ if (msg == NULL) {
+ ldapsrv_terminate_connection(conn, "new_ldap_message() failed");
+ return;
+ }
+
+ msg->messageid = request->messageid;
+ resp = &msg->r.SearchResultDone;
+
+ /* Is this a rootdse request? */
+ if ((strlen(req->basedn) == 0) &&
+ (req->scope == LDAP_SEARCH_SCOPE_BASE) &&
+ strequal(req->filter, "(objectclass=*)")) {
+ msg->type = LDAP_TAG_SearchResultEntry;
+ msg->r.SearchResultEntry.dn = "";
+ msg->r.SearchResultEntry.num_attributes = 0;
+ msg->r.SearchResultEntry.attributes = NULL;
+ return;
+ }
+
+ msg->type = LDAP_TAG_SearchResultDone;
+ resp->resultcode = 0;
+ resp->dn = NULL;
+ resp->errormessage = NULL;
+ resp->referral = NULL;
+
+ ldap_append_to_buf(msg, &conn->out_buffer);
+ talloc_destroy(msg->mem_ctx);
+}
+
+static void switch_ldap_message(struct ldapsrv_connection *conn,
+ struct ldap_message *msg)
+{
+ switch(msg->type) {
+ case LDAP_TAG_BindRequest:
+ ldap_reply_BindRequest(conn, msg);
+ break;
+ case LDAP_TAG_SearchRequest:
+ ldap_reply_SearchRequest(conn, msg);
+ break;
+ default:
+ reply_unwilling(conn, 2);
+ break;
+ }
+}
+
+static void ldap_queue_run(struct server_connection *conn)
+{
+ struct ldapsrv_connection *ldap_conn = conn->private_data;
+
+ while (ldap_conn->in_queue) {
+ struct ldap_message_queue *req = ldap_conn->in_queue;
+ DLIST_REMOVE(ldap_conn->in_queue, req);
+
+ switch_ldap_message(ldap_conn, req->msg);
+ talloc_destroy(req->msg->mem_ctx);
+ }
+}
+
+/*
+ called when a LDAP socket becomes readable
+*/
+static void ldapsrv_recv(struct server_connection *conn, time_t 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 ldap_message *msg;
+ struct ldap_message_queue *queue_entry;
+
+ DEBUG(10,("ldapsrv_recv\n"));
+
+ if (!read_into_buf(conn->event.fde->fd, &ldap_conn->in_buffer)) {
+ ldapsrv_terminate_connection(ldap_conn, "read_into_buf() failed");
+ return;
+ }
+
+ peek_into_read_buf(&ldap_conn->in_buffer, &buf, &buf_length);
+
+ while (buf_length > 0) {
+
+ /* LDAP Messages are always SEQUENCES */
+
+ if (!asn1_object_length(buf, buf_length, ASN1_SEQUENCE(0),
+ &msg_length)) {
+ ldapsrv_terminate_connection(ldap_conn, "asn1_object_length() failed");
+ return;
+ }
+
+ if (buf_length < msg_length) {
+ /* Not enough yet */
+ break;
+ }
+
+ /* We've got a complete LDAP request in the in-buffer, convert
+ * that to a ldap_message and put it into the incoming
+ * queue. */
+
+ blob.data = buf;
+ blob.length = msg_length;
+
+ if (!asn1_load(&data, blob)) {
+ ldapsrv_terminate_connection(ldap_conn, "asn1_load() failed");
+ return;
+ }
+
+ msg = new_ldap_message();
+
+ if ((msg == NULL) || !ldap_decode(&data, msg)) {
+ ldapsrv_terminate_connection(ldap_conn, "ldap_decode() failed");
+ return;
+ }
+
+ queue_entry = talloc_p(msg->mem_ctx, struct ldap_message_queue);
+
+ if (queue_entry == NULL) {
+ ldapsrv_terminate_connection(ldap_conn, "alloc_p(msg->mem_ctx, struct ldap_message_queue) failed");
+ return;
+ }
+
+ queue_entry->msg = msg;
+
+ DLIST_ADD_END(ldap_conn->in_queue, queue_entry,
+ struct ldap_message_queue *);
+
+ consumed_from_read_buf(&ldap_conn->in_buffer, msg_length);
+
+ peek_into_read_buf(&ldap_conn->in_buffer, &buf, &buf_length);
+ }
+
+ ldap_queue_run(conn);
+
+ return;
+}
+
+/*
+ called when a LDAP socket becomes writable
+*/
+static void ldapsrv_send(struct server_connection *conn, time_t t,
+ uint16_t flags)
+{
+ struct ldapsrv_connection *ldap_conn = conn->private_data;
+
+ DEBUG(10,("ldapsrv_send\n"));
+
+ if (!write_from_buf(conn->event.fde->fd, &ldap_conn->out_buffer)) {
+ ldapsrv_terminate_connection(ldap_conn, "write_from_buf() failed");
+ return;
+ }
+
+ 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)
+{
+ struct ldapsrv_connection *ldap_conn = conn->private_data;
+
+ talloc_free(ldap_conn);
+
+ 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)
+{
+ struct ldapsrv_connection *ldap_conn;
+
+ DEBUG(5, ("ldapsrv_accept\n"));
+
+ ldap_conn = talloc_p(NULL, struct ldapsrv_connection);
+
+ if (ldap_conn == NULL)
+ return;
+
+ ZERO_STRUCTP(ldap_conn);
+ ldap_conn->connection = conn;
+
+ conn->private_data = ldap_conn;
+
+ return;
+}
+
+/*
+ called on a fatal error that should cause this server to terminate
+*/
+static void ldapsrv_exit(struct server_service *service, const char *reason)
+{
+ DEBUG(1,("ldapsrv_exit\n"));
+ return;
+}
+
+static const struct server_service_ops ldap_server_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)
+{
+ return &ldap_server_ops;
+}
+
+NTSTATUS server_service_ldap_init(void)
+{
+ return NT_STATUS_OK;
+}
git.samba.org / metze / samba / wip.git / commitdiff