The branch, master has been updated
via fcbe8f0... s4:kdc: setup the local and remote tsocket_address at
accept time
via 4dc958c... s4:kdc: convert UDP based communication to tdgram_context
from 32861b9... Actually explain the twisty paths of tortured logic
behind reply_doserror(), reply_nterror(), and reply_nterror(NT_STATUS_DOS()).
http://gitweb.samba.org/?p=samba.git;a=shortlog;h=master
- Log -----------------------------------------------------------------
commit fcbe8f0c80e3848e87d37476a46c7eb553d592c1
Author: Stefan Metzmacher <me...@samba.org>
Date: Wed Nov 4 19:22:53 2009 +0100
s4:kdc: setup the local and remote tsocket_address at accept time
metze
commit 4dc958c7c8cff9044b86e59b9ea8165ee1847aad
Author: Stefan Metzmacher <me...@samba.org>
Date: Wed Nov 4 19:22:53 2009 +0100
s4:kdc: convert UDP based communication to tdgram_context
metze
-----------------------------------------------------------------------
Summary of changes:
source4/kdc/config.mk | 3 +-
source4/kdc/kdc.c | 405 ++++++++++++++++++++++---------------------------
2 files changed, 187 insertions(+), 221 deletions(-)
Changeset truncated at 500 lines:
diff --git a/source4/kdc/config.mk b/source4/kdc/config.mk
index 7a99857..a9d0158 100644
--- a/source4/kdc/config.mk
+++ b/source4/kdc/config.mk
@@ -6,7 +6,8 @@
INIT_FUNCTION = server_service_kdc_init
SUBSYSTEM = service
PRIVATE_DEPENDENCIES = \
- HEIMDAL_KDC HDB_SAMBA4 PAC_GLUE LIBSAMBA-HOSTCONFIG
+ HEIMDAL_KDC HDB_SAMBA4 PAC_GLUE LIBSAMBA-HOSTCONFIG \
+ LIBTSOCKET
# End SUBSYSTEM KDC
#######################
diff --git a/source4/kdc/kdc.c b/source4/kdc/kdc.c
index 6a9df0b..2c07f89 100644
--- a/source4/kdc/kdc.c
+++ b/source4/kdc/kdc.c
@@ -48,13 +48,6 @@ TALLOC_CTX *hdb_samba4_mem_ctx;
struct tevent_context *hdb_samba4_ev_ctx;
struct loadparm_context *hdb_samba4_lp_ctx;
-/* hold all the info needed to send a reply */
-struct kdc_reply {
- struct kdc_reply *next, *prev;
- struct socket_address *dest;
- DATA_BLOB packet;
-};
-
typedef bool (*kdc_process_fn_t)(struct kdc_server *kdc,
TALLOC_CTX *mem_ctx,
DATA_BLOB *input,
@@ -65,15 +58,11 @@ typedef bool (*kdc_process_fn_t)(struct kdc_server *kdc,
/* hold information about one kdc socket */
struct kdc_socket {
- struct socket_context *sock;
struct kdc_server *kdc;
- struct tevent_fd *fde;
-
- /* a queue of outgoing replies that have been deferred */
- struct kdc_reply *send_queue;
-
+ struct tsocket_address *local_address;
kdc_process_fn_t process;
};
+
/*
state of an open tcp connection
*/
@@ -82,152 +71,14 @@ struct kdc_tcp_connection {
struct stream_connection *conn;
/* the kdc_server the connection belongs to */
- struct kdc_server *kdc;
+ struct kdc_socket *kdc_socket;
- struct packet_context *packet;
+ struct tsocket_address *local_address;
+ struct tsocket_address *remote_address;
- kdc_process_fn_t process;
+ struct packet_context *packet;
};
-/*
- handle fd send events on a KDC socket
-*/
-static void kdc_send_handler(struct kdc_socket *kdc_socket)
-{
- while (kdc_socket->send_queue) {
- struct kdc_reply *rep = kdc_socket->send_queue;
- NTSTATUS status;
- size_t sendlen;
-
- status = socket_sendto(kdc_socket->sock, &rep->packet, &sendlen,
- rep->dest);
- if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
- break;
- }
- if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_BUFFER_SIZE)) {
- /* Replace with a krb err, response to big */
- }
-
- DLIST_REMOVE(kdc_socket->send_queue, rep);
- talloc_free(rep);
- }
-
- if (kdc_socket->send_queue == NULL) {
- EVENT_FD_NOT_WRITEABLE(kdc_socket->fde);
- }
-}
-
-
-/*
- handle fd recv events on a KDC socket
-*/
-static void kdc_recv_handler(struct kdc_socket *kdc_socket)
-{
- NTSTATUS status;
- TALLOC_CTX *tmp_ctx = talloc_new(kdc_socket);
- DATA_BLOB blob;
- struct kdc_reply *rep;
- DATA_BLOB reply;
- size_t nread, dsize;
- struct socket_address *src;
- struct socket_address *my_addr;
- struct tsocket_address *tsrcaddr;
- struct tsocket_address *tmyaddr;
- int ret;
-
- status = socket_pending(kdc_socket->sock, &dsize);
- if (!NT_STATUS_IS_OK(status)) {
- talloc_free(tmp_ctx);
- return;
- }
-
- blob = data_blob_talloc(tmp_ctx, NULL, dsize);
- if (blob.data == NULL) {
- /* hope this is a temporary low memory condition */
- talloc_free(tmp_ctx);
- return;
- }
-
- status = socket_recvfrom(kdc_socket->sock, blob.data, blob.length,
&nread,
- tmp_ctx, &src);
- if (!NT_STATUS_IS_OK(status)) {
- talloc_free(tmp_ctx);
- return;
- }
- blob.length = nread;
-
- DEBUG(10,("Received krb5 UDP packet of length %lu from %s:%u\n",
- (long)blob.length, src->addr, (uint16_t)src->port));
-
- my_addr = socket_get_my_addr(kdc_socket->sock, tmp_ctx);
- if (!my_addr) {
- talloc_free(tmp_ctx);
- return;
- }
-
- ret = tsocket_address_bsd_from_sockaddr(tmp_ctx, src->sockaddr,
- src->sockaddrlen, &tsrcaddr);
- if (ret < 0) {
- talloc_free(tmp_ctx);
- return;
- }
-
- ret = tsocket_address_bsd_from_sockaddr(tmp_ctx, my_addr->sockaddr,
- my_addr->sockaddrlen, &tmyaddr);
- if (ret < 0) {
- talloc_free(tmp_ctx);
- return;
- }
-
- /* Call krb5 */
- ret = kdc_socket->process(kdc_socket->kdc,
- tmp_ctx,
- &blob,
- &reply,
- tsrcaddr,
- tmyaddr,
- 1 /* Datagram */);
- if (!ret) {
- talloc_free(tmp_ctx);
- return;
- }
-
- /* queue a pending reply */
- rep = talloc(kdc_socket, struct kdc_reply);
- if (rep == NULL) {
- talloc_free(tmp_ctx);
- return;
- }
- rep->dest = talloc_steal(rep, src);
- rep->packet = reply;
- talloc_steal(rep, reply.data);
-
- if (rep->packet.data == NULL) {
- talloc_free(rep);
- talloc_free(tmp_ctx);
- return;
- }
-
- DLIST_ADD_END(kdc_socket->send_queue, rep, struct kdc_reply *);
- EVENT_FD_WRITEABLE(kdc_socket->fde);
- talloc_free(tmp_ctx);
-}
-
-/*
- handle fd events on a KDC socket
-*/
-static void kdc_socket_handler(struct tevent_context *ev, struct tevent_fd
*fde,
- uint16_t flags, void *private_data)
-{
- struct kdc_socket *kdc_socket = talloc_get_type(private_data, struct
kdc_socket);
- if (flags & EVENT_FD_WRITE) {
- kdc_send_handler(kdc_socket);
- }
- if (flags & EVENT_FD_READ) {
- kdc_recv_handler(kdc_socket);
- }
-}
-
static void kdc_tcp_terminate_connection(struct kdc_tcp_connection *kdcconn,
const char *reason)
{
stream_terminate_connection(kdcconn->conn, reason);
@@ -244,49 +95,18 @@ static NTSTATUS kdc_tcp_recv(void *private_data, DATA_BLOB
blob)
TALLOC_CTX *tmp_ctx = talloc_new(kdcconn);
int ret;
DATA_BLOB input, reply;
- struct socket_address *src_addr;
- struct socket_address *my_addr;
- struct tsocket_address *tsrcaddr;
- struct tsocket_address *tmyaddr;
-
talloc_steal(tmp_ctx, blob.data);
- src_addr = socket_get_peer_addr(kdcconn->conn->socket, tmp_ctx);
- if (!src_addr) {
- talloc_free(tmp_ctx);
- return NT_STATUS_NO_MEMORY;
- }
-
- my_addr = socket_get_my_addr(kdcconn->conn->socket, tmp_ctx);
- if (!my_addr) {
- talloc_free(tmp_ctx);
- return NT_STATUS_NO_MEMORY;
- }
-
- ret = tsocket_address_bsd_from_sockaddr(tmp_ctx, src_addr->sockaddr,
- src_addr->sockaddrlen, &tsrcaddr);
- if (ret < 0) {
- talloc_free(tmp_ctx);
- return NT_STATUS_NO_MEMORY;
- }
-
- ret = tsocket_address_bsd_from_sockaddr(tmp_ctx, my_addr->sockaddr,
- my_addr->sockaddrlen, &tmyaddr);
- if (ret < 0) {
- talloc_free(tmp_ctx);
- return NT_STATUS_NO_MEMORY;
- }
-
/* Call krb5 */
input = data_blob_const(blob.data + 4, blob.length - 4);
- ret = kdcconn->process(kdcconn->kdc,
- tmp_ctx,
- &input,
- &reply,
- tsrcaddr,
- tmyaddr,
- 0 /* Not datagram */);
+ ret = kdcconn->kdc_socket->process(kdcconn->kdc_socket->kdc,
+ tmp_ctx,
+ &input,
+ &reply,
+ kdcconn->remote_address,
+ kdcconn->local_address,
+ 0 /* Not datagram */);
if (!ret) {
talloc_free(tmp_ctx);
return NT_STATUS_INTERNAL_ERROR;
@@ -404,17 +224,52 @@ static void kdc_tcp_accept(struct stream_connection *conn)
{
struct kdc_socket *kdc_socket = talloc_get_type(conn->private_data,
struct kdc_socket);
struct kdc_tcp_connection *kdcconn;
+ struct socket_address *src_addr;
+ struct socket_address *my_addr;
+ int ret;
kdcconn = talloc_zero(conn, struct kdc_tcp_connection);
if (!kdcconn) {
stream_terminate_connection(conn, "kdc_tcp_accept: out of
memory");
return;
}
- kdcconn->conn = conn;
- kdcconn->kdc = kdc_socket->kdc;
- kdcconn->process = kdc_socket->process;
+ kdcconn->conn = conn;
+ kdcconn->kdc_socket = kdc_socket;
conn->private_data = kdcconn;
+ src_addr = socket_get_peer_addr(kdcconn->conn->socket, kdcconn);
+ if (!src_addr) {
+ kdc_tcp_terminate_connection(kdcconn, "kdc_tcp_accept: out of
memory");
+ return;
+ }
+
+ my_addr = socket_get_my_addr(kdcconn->conn->socket, kdcconn);
+ if (!my_addr) {
+ kdc_tcp_terminate_connection(kdcconn, "kdc_tcp_accept: out of
memory");
+ return;
+ }
+
+ ret = tsocket_address_bsd_from_sockaddr(kdcconn,
+ src_addr->sockaddr,
+ src_addr->sockaddrlen,
+ &kdcconn->remote_address);
+ if (ret < 0) {
+ kdc_tcp_terminate_connection(kdcconn, "kdc_tcp_accept: out of
memory");
+ return;
+ }
+
+ ret = tsocket_address_bsd_from_sockaddr(kdcconn,
+ my_addr->sockaddr,
+ my_addr->sockaddrlen,
+ &kdcconn->local_address);
+ if (ret < 0) {
+ kdc_tcp_terminate_connection(kdcconn, "kdc_tcp_accept: out of
memory");
+ return;
+ }
+
+ TALLOC_FREE(src_addr);
+ TALLOC_FREE(my_addr);
+
kdcconn->packet = packet_init(kdcconn);
if (kdcconn->packet == NULL) {
kdc_tcp_terminate_connection(kdcconn, "kdc_tcp_accept: out of
memory");
@@ -437,6 +292,105 @@ static const struct stream_server_ops kdc_tcp_stream_ops
= {
.send_handler = kdc_tcp_send
};
+/* hold information about one kdc/kpasswd udp socket */
+struct kdc_udp_socket {
+ struct kdc_socket *kdc_socket;
+ struct tdgram_context *dgram;
+ struct tevent_queue *send_queue;
+};
+
+struct kdc_udp_call {
+ struct tsocket_address *src;
+ DATA_BLOB in;
+ DATA_BLOB out;
+};
+
+static void kdc_udp_call_sendto_done(struct tevent_req *subreq);
+
+static void kdc_udp_call_loop(struct tevent_req *subreq)
+{
+ struct kdc_udp_socket *sock = tevent_req_callback_data(subreq,
+ struct kdc_udp_socket);
+ struct kdc_udp_call *call;
+ uint8_t *buf;
+ ssize_t len;
+ int sys_errno;
+ int ret;
+
+ call = talloc(sock, struct kdc_udp_call);
+ if (call == NULL) {
+ talloc_free(call);
+ goto done;
+ }
+
+ len = tdgram_recvfrom_recv(subreq, &sys_errno,
+ call, &buf, &call->src);
+ TALLOC_FREE(subreq);
+ if (len == -1) {
+ talloc_free(call);
+ goto done;
+ }
+
+ call->in.data = buf;
+ call->in.length = len;
+
+ DEBUG(10,("Received krb5 UDP packet of length %lu from %s\n",
+ (long)call->in.length,
+ tsocket_address_string(call->src, call)));
+
+ /* Call krb5 */
+ ret = sock->kdc_socket->process(sock->kdc_socket->kdc,
+ call,
+ &call->in,
+ &call->out,
+ call->src,
+ sock->kdc_socket->local_address,
+ 1 /* Datagram */);
+ if (!ret) {
+ talloc_free(call);
+ goto done;
+ }
+
+ subreq = tdgram_sendto_queue_send(call,
+
sock->kdc_socket->kdc->task->event_ctx,
+ sock->dgram,
+ sock->send_queue,
+ call->out.data,
+ call->out.length,
+ call->src);
+ if (subreq == NULL) {
+ talloc_free(call);
+ goto done;
+ }
+ tevent_req_set_callback(subreq, kdc_udp_call_sendto_done, call);
+
+done:
+ subreq = tdgram_recvfrom_send(sock,
+ sock->kdc_socket->kdc->task->event_ctx,
+ sock->dgram);
+ if (subreq == NULL) {
+ task_server_terminate(sock->kdc_socket->kdc->task,
+ "no memory for tdgram_recvfrom_send",
+ true);
+ return;
+ }
+ tevent_req_set_callback(subreq, kdc_udp_call_loop, sock);
+}
+
+static void kdc_udp_call_sendto_done(struct tevent_req *subreq)
+{
+ struct kdc_udp_call *call = tevent_req_callback_data(subreq,
+ struct kdc_udp_call);
+ ssize_t ret;
+ int sys_errno;
+
+ ret = tdgram_sendto_queue_recv(subreq, &sys_errno);
+
+ /* We don't care about errors */
+
+ talloc_free(call);
+}
+
/*
start listening on the given address
*/
@@ -447,38 +401,23 @@ static NTSTATUS kdc_add_socket(struct kdc_server *kdc,
uint16_t port,
kdc_process_fn_t process)
{
- struct kdc_socket *kdc_socket;
- struct socket_address *socket_address;
+ struct kdc_socket *kdc_socket;
+ struct kdc_udp_socket *kdc_udp_socket;
+ struct tevent_req *udpsubreq;
NTSTATUS status;
+ int ret;
kdc_socket = talloc(kdc, struct kdc_socket);
NT_STATUS_HAVE_NO_MEMORY(kdc_socket);
- status = socket_create("ip", SOCKET_TYPE_DGRAM, &kdc_socket->sock, 0);
- if (!NT_STATUS_IS_OK(status)) {
- talloc_free(kdc_socket);
- return status;
- }
-
kdc_socket->kdc = kdc;
- kdc_socket->send_queue = NULL;
kdc_socket->process = process;
- talloc_steal(kdc_socket, kdc_socket->sock);
-
- kdc_socket->fde = event_add_fd(kdc->task->event_ctx, kdc,
- socket_get_fd(kdc_socket->sock),
EVENT_FD_READ,
- kdc_socket_handler, kdc_socket);
-
- socket_address = socket_address_from_strings(kdc_socket,
kdc_socket->sock->backend_name,
- address, port);
- NT_STATUS_HAVE_NO_MEMORY_AND_FREE(socket_address, kdc_socket);
-
- status = socket_listen(kdc_socket->sock, socket_address, 0, 0);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0,("Failed to bind to %s:%d UDP for %s - %s\n",
- address, port, name, nt_errstr(status)));
- talloc_free(kdc_socket);
+ ret = tsocket_address_inet_from_strings(kdc_socket, "ip",
+ address, port,
+ &kdc_socket->local_address);
+ if (ret != 0) {
+ status = map_nt_error_from_unix(errno);
return status;
}
@@ -496,6 +435,32 @@ static NTSTATUS kdc_add_socket(struct kdc_server *kdc,
return status;
}
+ kdc_udp_socket = talloc(kdc_socket, struct kdc_udp_socket);
+ NT_STATUS_HAVE_NO_MEMORY(kdc_udp_socket);
+
+ kdc_udp_socket->kdc_socket = kdc_socket;
+
+ ret = tdgram_inet_udp_socket(kdc_socket->local_address,
+ NULL,
+ kdc_udp_socket,
+ &kdc_udp_socket->dgram);
+ if (ret != 0) {
+ status = map_nt_error_from_unix(errno);
+ DEBUG(0,("Failed to bind to %s:%u UDP - %s\n",
+ address, port, nt_errstr(status)));
+ return status;
+ }
+
+ kdc_udp_socket->send_queue = tevent_queue_create(kdc_udp_socket,
+ "kdc_udp_send_queue");
+ NT_STATUS_HAVE_NO_MEMORY(kdc_udp_socket->send_queue);
+
+ udpsubreq = tdgram_recvfrom_send(kdc_udp_socket,
+ kdc->task->event_ctx,
--
Samba Shared Repository
