1 files changed, 192 insertions, 266 deletions

diff --git a/source4/kdc/kdc.c b/source4/kdc/kdc.c
index 6a9df0bf02..93f1c7d6ec 100644
--- a/source4/kdc/kdc.c
+++ b/source4/kdc/kdc.c
@@ -1,4 +1,4 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
 
    KDC Server startup
@@ -11,12 +11,12 @@
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 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, see <http://www.gnu.org/licenses/>.
 */
@@ -42,22 +42,15 @@
 #include "librpc/gen_ndr/ndr_misc.h"
 
 
-/* Disgusting hack to get a mem_ctx and lp_ctx into the hdb plugin, when 
+/* Disgusting hack to get a mem_ctx and lp_ctx into the hdb plugin, when
  * used as a keytab */
 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, 
+				 TALLOC_CTX *mem_ctx,
+				 DATA_BLOB *input,
 				 DATA_BLOB *reply,
 				 struct tsocket_address *peer_addr,
 				 struct tsocket_address *my_addr,
@@ -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,11 @@ 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;
-
-	kdc_process_fn_t process;
 };
 
-/*
-  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 +92,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 */);
+	input = data_blob_const(blob.data + 4, blob.length - 4);
+
+	ret = kdcconn->kdc_socket->process(kdcconn->kdc_socket->kdc,
+					   tmp_ctx,
+					   &input,
+					   &reply,
+					   kdcconn->conn->remote_address,
+					   kdcconn->conn->local_address,
+					   0 /* Not datagram */);
 	if (!ret) {
 		talloc_free(tmp_ctx);
 		return NT_STATUS_INTERNAL_ERROR;
@@ -300,7 +117,7 @@ static NTSTATUS kdc_tcp_recv(void *private_data, DATA_BLOB blob)
 	}
 
 	RSIVAL(blob.data, 0, reply.length);
-	memcpy(blob.data + 4, reply.data, reply.length);	
+	memcpy(blob.data + 4, reply.data, reply.length);
 
 	status = packet_send(kdcconn->packet, blob);
 	if (!NT_STATUS_IS_OK(status)) {
@@ -349,8 +166,8 @@ static void kdc_tcp_send(struct stream_connection *conn, uint16_t flags)
 */
 
 static bool kdc_process(struct kdc_server *kdc,
-			TALLOC_CTX *mem_ctx, 
-			DATA_BLOB *input, 
+			TALLOC_CTX *mem_ctx,
+			DATA_BLOB *input,
 			DATA_BLOB *reply,
 			struct tsocket_address *peer_addr,
 			struct tsocket_address *my_addr,
@@ -377,7 +194,7 @@ static bool kdc_process(struct kdc_server *kdc,
 	DEBUG(10,("Received KDC packet of length %lu from %s\n",
 				(long)input->length - 4, pa));
 
-	ret = krb5_kdc_process_krb5_request(kdc->smb_krb5_context->krb5_context, 
+	ret = krb5_kdc_process_krb5_request(kdc->smb_krb5_context->krb5_context,
 					    kdc->config,
 					    input->data, input->length,
 					    &k5_reply,
@@ -392,7 +209,7 @@ static bool kdc_process(struct kdc_server *kdc,
 		*reply = data_blob_talloc(mem_ctx, k5_reply.data, k5_reply.length);
 		krb5_data_free(&k5_reply);
 	} else {
-		*reply = data_blob(NULL, 0);	
+		*reply = data_blob(NULL, 0);
 	}
 	return true;
 }
@@ -410,9 +227,8 @@ static void kdc_tcp_accept(struct stream_connection *conn)
 		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;
 
 	kdcconn->packet = packet_init(kdcconn);
@@ -437,6 +253,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,47 +362,32 @@ 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;
 	}
 
-	status = stream_setup_socket(kdc->task->event_ctx, 
+	status = stream_setup_socket(kdc->task->event_ctx,
 				     kdc->task->lp_ctx,
-				     model_ops, 
-				     &kdc_tcp_stream_ops, 
-				     "ip", address, &port, 
-				     lp_socket_options(kdc->task->lp_ctx), 
+				     model_ops,
+				     &kdc_tcp_stream_ops,
+				     "ip", address, &port,
+				     lp_socket_options(kdc->task->lp_ctx),
 				     kdc_socket);
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0,("Failed to bind to %s:%u TCP - %s\n",
@@ -496,6 +396,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,
+					 kdc_udp_socket->dgram);
+	NT_STATUS_HAVE_NO_MEMORY(udpsubreq);
+	tevent_req_set_callback(udpsubreq, kdc_udp_call_loop, kdc_udp_socket);
+
 	return NT_STATUS_OK;
 }
 
@@ -522,7 +448,7 @@ static NTSTATUS kdc_startup_interfaces(struct kdc_server *kdc, struct loadparm_c
 	}
 
 	num_interfaces = iface_count(ifaces);
-	
+
 	for (i=0; i<num_interfaces; i++) {
 		const char *address = talloc_strdup(tmp_ctx, iface_n_ip(ifaces, i));
 		uint16_t kdc_port = lp_krb5_port(lp_ctx);
@@ -549,7 +475,7 @@ static NTSTATUS kdc_startup_interfaces(struct kdc_server *kdc, struct loadparm_c
 }
 
 
-static NTSTATUS kdc_check_generic_kerberos(struct irpc_message *msg, 
+static NTSTATUS kdc_check_generic_kerberos(struct irpc_message *msg,
 				 struct kdc_check_generic_kerberos *r)
 {
 	struct PAC_Validate pac_validate;
@@ -567,14 +493,14 @@ static NTSTATUS kdc_check_generic_kerberos(struct irpc_message *msg,
 	/* There is no reply to this request */
 	r->out.generic_reply = data_blob(NULL, 0);
 
-	ndr_err = ndr_pull_struct_blob(&r->in.generic_request, msg, 
-				       lp_iconv_convenience(kdc->task->lp_ctx), 
+	ndr_err = ndr_pull_struct_blob(&r->in.generic_request, msg,
+				       lp_iconv_convenience(kdc->task->lp_ctx),
 				       &pac_validate,
 				       (ndr_pull_flags_fn_t)ndr_pull_PAC_Validate);
 	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 		return NT_STATUS_INVALID_PARAMETER;
 	}
-	
+
 	if (pac_validate.MessageType != 3) {
 		/* We don't implement any other message types - such as certificate validation - yet */
 		return NT_STATUS_INVALID_PARAMETER;
@@ -585,10 +511,10 @@ static NTSTATUS kdc_check_generic_kerberos(struct irpc_message *msg,
 	    || pac_validate.ChecksumAndSignature.length < pac_validate.SignatureLength ) {
 		return NT_STATUS_INVALID_PARAMETER;
 	}
-	
-	srv_sig = data_blob_const(pac_validate.ChecksumAndSignature.data, 
+
+	srv_sig = data_blob_const(pac_validate.ChecksumAndSignature.data,
 				  pac_validate.ChecksumLength);
-	
+
 	if (pac_validate.SignatureType == CKSUMTYPE_HMAC_MD5) {
 		etype = ETYPE_ARCFOUR_HMAC_MD5;
 	} else {
@@ -599,16 +525,16 @@ static NTSTATUS kdc_check_generic_kerberos(struct irpc_message *msg,
 		}
 	}
 
-	ret = krb5_make_principal(kdc->smb_krb5_context->krb5_context, &principal, 
+	ret = krb5_make_principal(kdc->smb_krb5_context->krb5_context, &principal,
 				  lp_realm(kdc->task->lp_ctx),
-				  "krbtgt", lp_realm(kdc->task->lp_ctx), 
+				  "krbtgt", lp_realm(kdc->task->lp_ctx),
 				  NULL);
 
 	if (ret != 0) {
 		return NT_STATUS_NO_MEMORY;
 	}
 
-	ret = kdc->config->db[0]->hdb_fetch(kdc->smb_krb5_context->krb5_context, 
+	ret = kdc->config->db[0]->hdb_fetch(kdc->smb_krb5_context->krb5_context,
 					    kdc->config->db[0],
 					    principal,
 					    HDB_F_GET_KRBTGT | HDB_F_DECRYPT,
@@ -617,10 +543,10 @@ static NTSTATUS kdc_check_generic_kerberos(struct irpc_message *msg,
 	if (ret != 0) {
 		hdb_free_entry(kdc->smb_krb5_context->krb5_context, &ent);
 		krb5_free_principal(kdc->smb_krb5_context->krb5_context, principal);
-	
+
 		return NT_STATUS_LOGON_FAILURE;
 	}
-	
+
 	ret = hdb_enctype2key(kdc->smb_krb5_context->krb5_context, &ent.entry, etype, &key);
 
 	if (ret != 0) {
@@ -630,11 +556,11 @@ static NTSTATUS kdc_check_generic_kerberos(struct irpc_message *msg,
 	}
 
 	keyblock = key->key;
-	
+
 	kdc_sig.type = pac_validate.SignatureType;
 	kdc_sig.signature = data_blob_const(&pac_validate.ChecksumAndSignature.data[pac_validate.ChecksumLength],
 					    pac_validate.SignatureLength);
-	ret = check_pac_checksum(msg, srv_sig, &kdc_sig, 
+	ret = check_pac_checksum(msg, srv_sig, &kdc_sig,
 			   kdc->smb_krb5_context->krb5_context, &keyblock);
 
 	hdb_free_entry(kdc->smb_krb5_context->krb5_context, &ent);
@@ -643,7 +569,7 @@ static NTSTATUS kdc_check_generic_kerberos(struct irpc_message *msg,
 	if (ret != 0) {
 		return NT_STATUS_LOGON_FAILURE;
 	}
-	
+
 	return NT_STATUS_OK;
 }
 
@@ -691,21 +617,21 @@ static void kdc_task_init(struct task_server *task)
 
 	ret = smb_krb5_init_context(kdc, task->event_ctx, task->lp_ctx, &kdc->smb_krb5_context);
 	if (ret) {
-		DEBUG(1,("kdc_task_init: krb5_init_context failed (%s)\n", 
+		DEBUG(1,("kdc_task_init: krb5_init_context failed (%s)\n",
 			 error_message(ret)));
 		task_server_terminate(task, "kdc: krb5_init_context failed", true);
-		return; 
+		return;
 	}
 
 	krb5_add_et_list(kdc->smb_krb5_context->krb5_context, initialize_hdb_error_table_r);
 
-	ret = krb5_kdc_get_config(kdc->smb_krb5_context->krb5_context, 
+	ret = krb5_kdc_get_config(kdc->smb_krb5_context->krb5_context,
 				  &kdc->config);
 	if(ret) {
 		task_server_terminate(task, "kdc: failed to get KDC configuration", true);
 		return;
 	}
- 
+
 	kdc->config->logf = kdc->smb_krb5_context->logf;
 	kdc->config->db = talloc(kdc, struct HDB *);
 	if (!kdc->config->db) {
@@ -713,13 +639,13 @@ static void kdc_task_init(struct task_server *task)
 		return;
 	}
 	kdc->config->num_db = 1;
-		
-	status = hdb_samba4_create_kdc(kdc, task->event_ctx, task->lp_ctx, 
-				       kdc->smb_krb5_context->krb5_context, 
+
+	status = hdb_samba4_create_kdc(kdc, task->event_ctx, task->lp_ctx,
+				       kdc->smb_krb5_context->krb5_context,
 				       &kdc->config->db[0]);
 	if (!NT_STATUS_IS_OK(status)) {
 		task_server_terminate(task, "kdc: hdb_samba4_create_kdc (setup KDC database) failed", true);
-		return; 
+		return;
 	}
 
 	/* Register hdb-samba4 hooks for use as a keytab */
@@ -727,13 +653,13 @@ static void kdc_task_init(struct task_server *task)
 	kdc->hdb_samba4_context = talloc(kdc, struct hdb_samba4_context);
 	if (!kdc->hdb_samba4_context) {
 		task_server_terminate(task, "kdc: out of memory", true);
-		return; 
+		return;
 	}
 
 	kdc->hdb_samba4_context->ev_ctx = task->event_ctx;
 	kdc->hdb_samba4_context->lp_ctx = task->lp_ctx;
 
-	ret = krb5_plugin_register(kdc->smb_krb5_context->krb5_context, 
+	ret = krb5_plugin_register(kdc->smb_krb5_context->krb5_context,
 				   PLUGIN_TYPE_DATA, "hdb",
 				   &hdb_samba4);
 	if(ret) {
@@ -748,7 +674,7 @@ static void kdc_task_init(struct task_server *task)
 	}
 
 	/* Registar WinDC hooks */
-	ret = krb5_plugin_register(kdc->smb_krb5_context->krb5_context, 
+	ret = krb5_plugin_register(kdc->smb_krb5_context->krb5_context,
 				   PLUGIN_TYPE_DATA, "windc",
 				   &windc_plugin_table);
 	if(ret) {
@@ -765,7 +691,7 @@ static void kdc_task_init(struct task_server *task)
 		return;
 	}
 
-	status = IRPC_REGISTER(task->msg_ctx, irpc, KDC_CHECK_GENERIC_KERBEROS, 
+	status = IRPC_REGISTER(task->msg_ctx, irpc, KDC_CHECK_GENERIC_KERBEROS,
 			       kdc_check_generic_kerberos, kdc);
 	if (!NT_STATUS_IS_OK(status)) {
 		task_server_terminate(task, "nbtd failed to setup monitoring", true);