Revert "s4-smb: Migrate named_pipe_server to tsocket."

This reverts commit 69d5cea2e59162f19460e7ce4b6382fc5fdd6ca0.

This commit causes issues with the RPC server, revert it until we find the
exact issue and possibly have a torture test to avoid it happening again.
Found playing with w2k8r2 and forest trusts.

1 files changed, 210 insertions, 278 deletions

diff --git a/source4/smbd/service_named_pipe.c b/source4/smbd/service_named_pipe.c
index 18ae823dd2..c10f43273c 100644
--- a/source4/smbd/service_named_pipe.c
+++ b/source4/smbd/service_named_pipe.c
@@ -25,12 +25,9 @@
 #include "param/param.h"
 #include "auth/session.h"
 #include "auth/auth_sam_reply.h"
-#include "lib/socket/socket.h"
-#include "lib/tsocket/tsocket.h"
-#include "libcli/util/tstream.h"
+#include "lib/stream/packet.h"
 #include "librpc/gen_ndr/ndr_named_pipe_auth.h"
 #include "system/passwd.h"
-#include "system/network.h"
 #include "libcli/raw/smb.h"
 #include "auth/credentials/credentials.h"
 #include "auth/credentials/credentials_krb5.h"
@@ -44,293 +41,224 @@ struct named_pipe_socket {
 
 struct named_pipe_connection {
 	struct stream_connection *connection;
+	struct packet_context *packet;
 	const struct named_pipe_socket *pipe_sock;
-	struct tstream_context *tstream;
+	NTSTATUS status;
 };
 
-static void named_pipe_terminate_connection(struct named_pipe_connection *pipe_conn, const char *reason)
-{
-	stream_terminate_connection(pipe_conn->connection, reason);
-}
-
-static NTSTATUS named_pipe_full_request(void *private_data, DATA_BLOB blob, size_t *size)
+static void named_pipe_handover_connection(void *private_data)
 {
-	if (blob.length < 8) {
-		return STATUS_MORE_ENTRIES;
-	}
-
-	if (memcmp(NAMED_PIPE_AUTH_MAGIC, &blob.data[4], 4) != 0) {
-		DEBUG(0,("named_pipe_full_request: wrong protocol\n"));
-		*size = blob.length;
-		/* the error will be handled in named_pipe_recv_auth_request */
-		return NT_STATUS_OK;
-	}
-
-	*size = 4 + RIVAL(blob.data, 0);
-	if (*size > blob.length) {
-		return STATUS_MORE_ENTRIES;
-	}
-
-	return NT_STATUS_OK;
-}
+	struct named_pipe_connection *pipe_conn = talloc_get_type(
+		private_data, struct named_pipe_connection);
+	struct stream_connection *conn = pipe_conn->connection;
 
-static void named_pipe_auth_request(struct tevent_req *subreq);
+	TEVENT_FD_NOT_WRITEABLE(conn->event.fde);
 
-static void named_pipe_accept(struct stream_connection *conn)
-{
-	struct named_pipe_socket *pipe_sock = talloc_get_type(conn->private_data,
-						struct named_pipe_socket);
-	struct named_pipe_connection *pipe_conn;
-	struct tevent_req *subreq;
-	int rc;
+	packet_set_socket(pipe_conn->packet, NULL);
+	packet_set_event_context(pipe_conn->packet, NULL);
+	packet_set_fde(pipe_conn->packet, NULL);
+	TALLOC_FREE(pipe_conn->packet);
 
-	pipe_conn = talloc_zero(conn, struct named_pipe_connection);
-	if (pipe_conn == NULL) {
-		stream_terminate_connection(conn,
-				"named_pipe_accept: out of memory");
+	if (!NT_STATUS_IS_OK(pipe_conn->status)) {
+		stream_terminate_connection(conn, nt_errstr(pipe_conn->status));
 		return;
 	}
 
-	TALLOC_FREE(conn->event.fde);
-
-	rc = tstream_bsd_existing_socket(pipe_conn->tstream,
-			socket_get_fd(conn->socket),
-			&pipe_conn->tstream);
-	if (rc < 0) {
-		stream_terminate_connection(conn,
-				"named_pipe_accept: out of memory");
-		return;
-	}
+	/*
+	 * remove the named_pipe layer together with its packet layer
+	 */
+	conn->ops		= pipe_conn->pipe_sock->ops;
+	conn->private_data	= pipe_conn->pipe_sock->private_data;
+	talloc_unlink(conn, pipe_conn);
 
-	pipe_conn->connection = conn;
-	pipe_conn->pipe_sock = pipe_sock;
-	conn->private_data = pipe_conn;
+	/* we're now ready to start receiving events on this stream */
+	TEVENT_FD_READABLE(conn->event.fde);
 
 	/*
-	 * The named pipe pdu's have the length as 8 byte (initial_read_size),
-	 * named_pipe_full_request provides the pdu length then.
+	 * hand over to the real pipe implementation,
+	 * now that we have setup the transport session_info
 	 */
-	subreq = tstream_read_pdu_blob_send(pipe_conn,
-					    pipe_conn->connection->event.ctx,
-					    pipe_conn->tstream,
-					    8, /* initial_read_size */
-					    named_pipe_full_request,
-					    pipe_conn);
-	if (subreq == NULL) {
-		named_pipe_terminate_connection(pipe_conn,
-				"named_pipe_accept: "
-				"no memory for tstream_read_pdu_blob_send");
-		return;
-	}
-	tevent_req_set_callback(subreq, named_pipe_auth_request, pipe_conn);
-}
-
-struct named_pipe_call {
-	struct named_pipe_connection *pipe_conn;
-	DATA_BLOB in;
-	DATA_BLOB out;
-	struct iovec out_iov[1];
-	NTSTATUS status;
-};
+	conn->ops->accept_connection(conn);
 
-static void named_pipe_handover_connection(struct tevent_req *subreq);
+	DEBUG(10,("named_pipe_handover_connection[%s]: succeeded\n",
+	      conn->ops->name));
+}
 
-static void named_pipe_auth_request(struct tevent_req *subreq)
+static NTSTATUS named_pipe_recv_auth_request(void *private_data,
+					     DATA_BLOB req_blob)
 {
-	struct named_pipe_connection *pipe_conn = tevent_req_callback_data(subreq,
-				      struct named_pipe_connection);
+	struct named_pipe_connection *pipe_conn = talloc_get_type(
+		private_data, struct named_pipe_connection);
 	struct stream_connection *conn = pipe_conn->connection;
-	struct named_pipe_call *call;
 	enum ndr_err_code ndr_err;
+	struct named_pipe_auth_req req;
 	union netr_Validation val;
 	struct auth_serversupplied_info *server_info;
-	struct named_pipe_auth_req pipe_request;
-	struct named_pipe_auth_rep pipe_reply;
+	struct named_pipe_auth_rep rep;
+	DATA_BLOB rep_blob;
 	NTSTATUS status;
 
-	call = talloc(pipe_conn, struct named_pipe_call);
-	if (call == NULL) {
-		named_pipe_terminate_connection(pipe_conn,
-				"named_pipe_auth_request: "
-				"no memory for named_pipe_call");
-		return;
-	}
-	call->pipe_conn = pipe_conn;
-
-	status = tstream_read_pdu_blob_recv(subreq,
-					    call,
-					    &call->in);
-	TALLOC_FREE(subreq);
-	if (!NT_STATUS_IS_OK(status)) {
-		const char *reason;
-
-		reason = talloc_asprintf(call, "named_pipe_call_loop: "
-					 "tstream_read_pdu_blob_recv() - %s",
-					 nt_errstr(status));
-		if (reason == NULL) {
-			reason = nt_errstr(status);
-		}
-
-		named_pipe_terminate_connection(pipe_conn, reason);
-		return;
-	}
-
-	DEBUG(10,("Received named_pipe packet of length %lu from %s\n",
-		 (long) call->in.length,
-		 tsocket_address_string(pipe_conn->connection->remote_address, call)));
-	dump_data(11, call->in.data, call->in.length);
+	/*
+	 * make sure nothing happens on the socket untill the
+	 * real implementation takes over
+	 */
+	packet_recv_disable(pipe_conn->packet);
 
 	/*
 	 * TODO: check it's a root (uid == 0) pipe
 	 */
 
-	ZERO_STRUCT(pipe_reply);
-	pipe_reply.level = 0;
-	pipe_reply.status = NT_STATUS_INTERNAL_ERROR;
+	ZERO_STRUCT(rep);
+	rep.level = 0;
+	rep.status = NT_STATUS_INTERNAL_ERROR;
+
+	DEBUG(10,("named_pipe_auth: req_blob.length[%u]\n",
+		  (unsigned int)req_blob.length));
+	dump_data(11, req_blob.data, req_blob.length);
 
 	/* parse the passed credentials */
 	ndr_err = ndr_pull_struct_blob_all(
-			&call->in,
+			&req_blob,
 			pipe_conn,
 			lp_iconv_convenience(conn->lp_ctx),
-			&pipe_request,
-			(ndr_pull_flags_fn_t) ndr_pull_named_pipe_auth_req);
+			&req,
+			(ndr_pull_flags_fn_t)ndr_pull_named_pipe_auth_req);
 	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-		pipe_reply.status = ndr_map_error2ntstatus(ndr_err);
+		rep.status = ndr_map_error2ntstatus(ndr_err);
 		DEBUG(2, ("Could not unmarshall named_pipe_auth_req: %s\n",
-			  nt_errstr(pipe_reply.status)));
+			  nt_errstr(rep.status)));
 		goto reply;
 	}
 
 	if (DEBUGLVL(10)) {
-		NDR_PRINT_DEBUG(named_pipe_auth_req, &pipe_request);
+		NDR_PRINT_DEBUG(named_pipe_auth_req, &req);
 	}
 
-	if (strcmp(NAMED_PIPE_AUTH_MAGIC, pipe_request.magic) != 0) {
+	if (strcmp(NAMED_PIPE_AUTH_MAGIC, req.magic) != 0) {
 		DEBUG(2, ("named_pipe_auth_req: invalid magic '%s' != %s\n",
-			  pipe_request.magic, NAMED_PIPE_AUTH_MAGIC));
-		pipe_reply.status = NT_STATUS_INVALID_PARAMETER;
+			  req.magic, NAMED_PIPE_AUTH_MAGIC));
+		rep.status = NT_STATUS_INVALID_PARAMETER;
 		goto reply;
 	}
 
-	switch (pipe_request.level) {
+	switch (req.level) {
 	case 0:
 		/*
 		 * anon connection, we don't create a session info
 		 * and leave it NULL
 		 */
-		pipe_reply.level = 0;
-		pipe_reply.status = NT_STATUS_OK;
+		rep.level = 0;
+		rep.status = NT_STATUS_OK;
 		break;
 	case 1:
-		val.sam3 = &pipe_request.info.info1;
-
-		pipe_reply.level = 1;
-		pipe_reply.status = make_server_info_netlogon_validation(pipe_conn,
-									 "TODO",
-									 3, &val,
-									 &server_info);
-		if (!NT_STATUS_IS_OK(pipe_reply.status)) {
+		val.sam3 = &req.info.info1;
+
+		rep.level = 1;
+		rep.status = make_server_info_netlogon_validation(pipe_conn,
+								  "TODO",
+								  3, &val,
+								  &server_info);
+		if (!NT_STATUS_IS_OK(rep.status)) {
 			DEBUG(2, ("make_server_info_netlogon_validation returned "
-				  "%s\n", nt_errstr(pipe_reply.status)));
+				  "%s\n", nt_errstr(rep.status)));
 			goto reply;
 		}
 
 		/* setup the session_info on the connection */
-		pipe_reply.status = auth_generate_session_info(conn,
-							       conn->event.ctx,
-							       conn->lp_ctx,
-							       server_info,
-							       &conn->session_info);
-		if (!NT_STATUS_IS_OK(pipe_reply.status)) {
+		rep.status = auth_generate_session_info(conn,
+							conn->event.ctx,
+							conn->lp_ctx,
+							server_info,
+							&conn->session_info);
+		if (!NT_STATUS_IS_OK(rep.status)) {
 			DEBUG(2, ("auth_generate_session_info failed: %s\n",
-				  nt_errstr(pipe_reply.status)));
+				  nt_errstr(rep.status)));
 			goto reply;
 		}
 
 		break;
 	case 2:
-		pipe_reply.level = 2;
-		pipe_reply.info.info2.file_type = FILE_TYPE_MESSAGE_MODE_PIPE;
-		pipe_reply.info.info2.device_state = 0xff | 0x0400 | 0x0100;
-		pipe_reply.info.info2.allocation_size = 4096;
+		rep.level = 2;
+		rep.info.info2.file_type = FILE_TYPE_MESSAGE_MODE_PIPE;
+		rep.info.info2.device_state = 0xff | 0x0400 | 0x0100;
+		rep.info.info2.allocation_size = 4096;
 
-		if (pipe_request.info.info2.sam_info3 == NULL) {
+		if (!req.info.info2.sam_info3) {
 			/*
 			 * anon connection, we don't create a session info
 			 * and leave it NULL
 			 */
-			pipe_reply.status = NT_STATUS_OK;
+			rep.status = NT_STATUS_OK;
 			break;
 		}
 
-		val.sam3 = pipe_request.info.info2.sam_info3;
+		val.sam3 = req.info.info2.sam_info3;
 
-		pipe_reply.status = make_server_info_netlogon_validation(pipe_conn,
+		rep.status = make_server_info_netlogon_validation(pipe_conn,
 						val.sam3->base.account_name.string,
 						3, &val, &server_info);
-		if (!NT_STATUS_IS_OK(pipe_reply.status)) {
+		if (!NT_STATUS_IS_OK(rep.status)) {
 			DEBUG(2, ("make_server_info_netlogon_validation returned "
-				  "%s\n", nt_errstr(pipe_reply.status)));
+				  "%s\n", nt_errstr(rep.status)));
 			goto reply;
 		}
 
 		/* setup the session_info on the connection */
-		pipe_reply.status = auth_generate_session_info(conn,
+		rep.status = auth_generate_session_info(conn,
 							conn->event.ctx,
 							conn->lp_ctx,
 							server_info,
 							&conn->session_info);
-		if (!NT_STATUS_IS_OK(pipe_reply.status)) {
+		if (!NT_STATUS_IS_OK(rep.status)) {
 			DEBUG(2, ("auth_generate_session_info failed: %s\n",
-				  nt_errstr(pipe_reply.status)));
+				  nt_errstr(rep.status)));
 			goto reply;
 		}
 
-		conn->session_info->session_key = data_blob_const(pipe_request.info.info2.session_key,
-							pipe_request.info.info2.session_key_length);
-		talloc_steal(conn->session_info, pipe_request.info.info2.session_key);
+		conn->session_info->session_key = data_blob_const(req.info.info2.session_key,
+							req.info.info2.session_key_length);
+		talloc_steal(conn->session_info, req.info.info2.session_key);
 
 		break;
 	case 3:
-		pipe_reply.level = 3;
-		pipe_reply.info.info3.file_type = FILE_TYPE_MESSAGE_MODE_PIPE;
-		pipe_reply.info.info3.device_state = 0xff | 0x0400 | 0x0100;
-		pipe_reply.info.info3.allocation_size = 4096;
+		rep.level = 3;
+		rep.info.info3.file_type = FILE_TYPE_MESSAGE_MODE_PIPE;
+		rep.info.info3.device_state = 0xff | 0x0400 | 0x0100;
+		rep.info.info3.allocation_size = 4096;
 
-		if (pipe_request.info.info3.sam_info3 == NULL) {
+		if (!req.info.info3.sam_info3) {
 			/*
 			 * anon connection, we don't create a session info
 			 * and leave it NULL
 			 */
-			pipe_reply.status = NT_STATUS_OK;
+			rep.status = NT_STATUS_OK;
 			break;
 		}
 
-		val.sam3 = pipe_request.info.info3.sam_info3;
+		val.sam3 = req.info.info3.sam_info3;
 
-		pipe_reply.status = make_server_info_netlogon_validation(pipe_conn,
+		rep.status = make_server_info_netlogon_validation(pipe_conn,
 						val.sam3->base.account_name.string,
 						3, &val, &server_info);
-		if (!NT_STATUS_IS_OK(pipe_reply.status)) {
+		if (!NT_STATUS_IS_OK(rep.status)) {
 			DEBUG(2, ("make_server_info_netlogon_validation returned "
-				  "%s\n", nt_errstr(pipe_reply.status)));
+				  "%s\n", nt_errstr(rep.status)));
 			goto reply;
 		}
 
 		/* setup the session_info on the connection */
-		pipe_reply.status = auth_generate_session_info(conn,
-							       conn->event.ctx,
-							       conn->lp_ctx,
-							       server_info,
-							       &conn->session_info);
-		if (!NT_STATUS_IS_OK(pipe_reply.status)) {
+		rep.status = auth_generate_session_info(conn,
+							conn->event.ctx,
+							conn->lp_ctx,
+							server_info,
+							&conn->session_info);
+		if (!NT_STATUS_IS_OK(rep.status)) {
 			DEBUG(2, ("auth_generate_session_info failed: %s\n",
-				  nt_errstr(pipe_reply.status)));
+				  nt_errstr(rep.status)));
 			goto reply;
 		}
 
-		if (pipe_request.info.info3.gssapi_delegated_creds_length) {
+		if (req.info.info3.gssapi_delegated_creds_length) {
 			OM_uint32 minor_status;
 			gss_buffer_desc cred_token;
 			gss_cred_id_t cred_handle;
@@ -338,20 +266,20 @@ static void named_pipe_auth_request(struct tevent_req *subreq)
 
 			DEBUG(10, ("named_pipe_auth: delegated credentials supplied by client\n"));
 
-			cred_token.value = pipe_request.info.info3.gssapi_delegated_creds;
-			cred_token.length = pipe_request.info.info3.gssapi_delegated_creds_length;
+			cred_token.value = req.info.info3.gssapi_delegated_creds;
+			cred_token.length = req.info.info3.gssapi_delegated_creds_length;
 
 			ret = gss_import_cred(&minor_status,
 					       &cred_token,
 					       &cred_handle);
 			if (ret != GSS_S_COMPLETE) {
-				pipe_reply.status = NT_STATUS_INTERNAL_ERROR;
+				rep.status = NT_STATUS_INTERNAL_ERROR;
 				goto reply;
 			}
 
 			conn->session_info->credentials = cli_credentials_init(conn->session_info);
-			if (conn->session_info->credentials == NULL) {
-				pipe_reply.status = NT_STATUS_NO_MEMORY;
+			if (!conn->session_info->credentials) {
+				rep.status = NT_STATUS_NO_MEMORY;
 				goto reply;
 			}
 
@@ -366,7 +294,7 @@ static void named_pipe_auth_request(struct tevent_req *subreq)
 								   cred_handle,
 								   CRED_SPECIFIED);
 			if (ret) {
-				pipe_reply.status = NT_STATUS_INTERNAL_ERROR;
+				rep.status = NT_STATUS_INTERNAL_ERROR;
 				goto reply;
 			}
 
@@ -375,112 +303,49 @@ static void named_pipe_auth_request(struct tevent_req *subreq)
 							   CRED_MUST_USE_KERBEROS);
 		}
 
-		conn->session_info->session_key = data_blob_const(pipe_request.info.info3.session_key,
-							pipe_request.info.info3.session_key_length);
-		talloc_steal(conn->session_info, pipe_request.info.info3.session_key);
+		conn->session_info->session_key = data_blob_const(req.info.info3.session_key,
+							req.info.info3.session_key_length);
+		talloc_steal(conn->session_info, req.info.info3.session_key);
 
 		break;
 	default:
-		DEBUG(0, ("named_pipe_auth_req: unknown level %u\n",
-			  pipe_request.level));
-		pipe_reply.level = 0;
-		pipe_reply.status = NT_STATUS_INVALID_LEVEL;
+		DEBUG(2, ("named_pipe_auth_req: unknown level %u\n",
+			  req.level));
+		rep.level = 0;
+		rep.status = NT_STATUS_INVALID_LEVEL;
 		goto reply;
 	}
 
 reply:
 	/* create the output */
-	ndr_err = ndr_push_struct_blob(&call->out, pipe_conn,
+	ndr_err = ndr_push_struct_blob(&rep_blob, pipe_conn,
 			lp_iconv_convenience(conn->lp_ctx),
-			&pipe_reply,
+			&rep,
 			(ndr_push_flags_fn_t)ndr_push_named_pipe_auth_rep);
 	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-		const char *reason;
 		status = ndr_map_error2ntstatus(ndr_err);
-
-		reason = talloc_asprintf(pipe_conn, "named_pipe_auth_request: could not marshall named_pipe_auth_rep: %s\n",
-					 nt_errstr(status));
-		if (reason == NULL) {
-			reason = "named_pipe_auth_request: could not marshall named_pipe_auth_rep";
-		}
-		named_pipe_terminate_connection(pipe_conn, reason);
-		return;
+		DEBUG(2, ("Could not marshall named_pipe_auth_rep: %s\n",
+			  nt_errstr(status)));
+		return status;
 	}
 
-	DEBUG(10,("named_pipe_auth_request: named_pipe_auth reply[%u]\n",
-		  (unsigned) call->out.length));
-	dump_data(11, call->out.data, call->out.length);
+	DEBUG(10,("named_pipe_auth reply[%u]\n", (unsigned)rep_blob.length));
+	dump_data(11, rep_blob.data, rep_blob.length);
 	if (DEBUGLVL(10)) {
-		NDR_PRINT_DEBUG(named_pipe_auth_rep, &pipe_reply);
+		NDR_PRINT_DEBUG(named_pipe_auth_rep, &rep);
 	}
 
-	call->status = pipe_reply.status;
-
-	call->out_iov[0].iov_base = call->out.data;
-	call->out_iov[0].iov_len = call->out.length;
-
-	subreq = tstream_writev_send(call,
-				     pipe_conn->connection->event.ctx,
-				     pipe_conn->tstream,
-				     call->out_iov, 1);
-	if (subreq == NULL) {
-		named_pipe_terminate_connection(pipe_conn, "named_pipe_auth_request: "
-				"no memory for tstream_writev_send");
-		return;
-	}
-
-	tevent_req_set_callback(subreq, named_pipe_handover_connection, call);
-}
-
-static void named_pipe_handover_connection(struct tevent_req *subreq)
-{
-	struct named_pipe_call *call = tevent_req_callback_data(subreq,
-			struct named_pipe_call);
-	struct named_pipe_connection *pipe_conn = call->pipe_conn;
-	struct stream_connection *conn = pipe_conn->connection;
-	int sys_errno;
-	int rc;
-
-	rc = tstream_writev_recv(subreq, &sys_errno);
-	TALLOC_FREE(subreq);
-	if (rc == -1) {
-		const char *reason;
-
-		reason = talloc_asprintf(call, "named_pipe_handover_connection: "
-					 "tstream_writev_recv() - %d:%s",
-					 sys_errno, strerror(sys_errno));
-		if (reason == NULL) {
-			reason = "named_pipe_handover_connection: "
-				 "tstream_writev_recv() failed";
-		}
-
-		named_pipe_terminate_connection(pipe_conn, reason);
-		return;
-	}
-
-	if (!NT_STATUS_IS_OK(call->status)) {
-		named_pipe_terminate_connection(pipe_conn,
-					    nt_errstr(call->status));
-		return;
+	pipe_conn->status = rep.status;
+	status = packet_send_callback(pipe_conn->packet, rep_blob,
+				      named_pipe_handover_connection,
+				      pipe_conn);
+	if (!NT_STATUS_IS_OK(status)) {
+		DEBUG(0, ("packet_send_callback returned %s\n",
+			  nt_errstr(status)));
+		return status;
 	}
 
-	/*
-	 * remove the named_pipe layer together with its packet layer
-	 */
-	conn->ops		= pipe_conn->pipe_sock->ops;
-	conn->private_data	= pipe_conn->pipe_sock->private_data;
-	talloc_unlink(conn, pipe_conn);
-
-	/*
-	 * hand over to the real pipe implementation,
-	 * now that we have setup the transport session_info
-	 */
-	conn->ops->accept_connection(conn);
-
-	DEBUG(10,("named_pipe_handover_connection[%s]: succeeded\n",
-	      conn->ops->name));
-
-	/* we don't have to free call here as the connection got closed */
+	return NT_STATUS_OK;
 }
 
 /*
@@ -491,8 +356,9 @@ static void named_pipe_recv(struct stream_connection *conn, uint16_t flags)
 	struct named_pipe_connection *pipe_conn = talloc_get_type(
 		conn->private_data, struct named_pipe_connection);
 
-	named_pipe_terminate_connection(pipe_conn,
-					"named_pipe_recv: called");
+	DEBUG(10,("named_pipe_recv\n"));
+
+	packet_recv(pipe_conn->packet);
 }
 
 /*
@@ -503,8 +369,74 @@ static void named_pipe_send(struct stream_connection *conn, uint16_t flags)
 	struct named_pipe_connection *pipe_conn = talloc_get_type(
 		conn->private_data, struct named_pipe_connection);
 
-	named_pipe_terminate_connection(pipe_conn,
-					"named_pipe_send: called");
+	packet_queue_run(pipe_conn->packet);
+}
+
+/*
+  handle socket recv errors
+*/
+static void named_pipe_recv_error(void *private_data, NTSTATUS status)
+{
+	struct named_pipe_connection *pipe_conn = talloc_get_type(
+		private_data, struct named_pipe_connection);
+
+	stream_terminate_connection(pipe_conn->connection, nt_errstr(status));
+}
+
+static NTSTATUS named_pipe_full_request(void *private_data, DATA_BLOB blob, size_t *size)
+{
+	if (blob.length < 8) {
+		return STATUS_MORE_ENTRIES;
+	}
+
+	if (memcmp(NAMED_PIPE_AUTH_MAGIC, &blob.data[4], 4) != 0) {
+		DEBUG(0,("named_pipe_full_request: wrong protocol\n"));
+		*size = blob.length;
+		/* the error will be handled in named_pipe_recv_auth_request */
+		return NT_STATUS_OK;
+	}
+
+	*size = 4 + RIVAL(blob.data, 0);
+	if (*size > blob.length) {
+		return STATUS_MORE_ENTRIES;
+	}
+
+	return NT_STATUS_OK;
+}
+
+static void named_pipe_accept(struct stream_connection *conn)
+{
+	struct named_pipe_socket *pipe_sock = talloc_get_type(
+		conn->private_data, struct named_pipe_socket);
+	struct named_pipe_connection *pipe_conn;
+
+	DEBUG(5,("named_pipe_accept\n"));
+
+	pipe_conn = talloc_zero(conn, struct named_pipe_connection);
+	if (!pipe_conn) {
+		stream_terminate_connection(conn, "out of memory");
+		return;
+	}
+
+	pipe_conn->packet = packet_init(pipe_conn);
+	if (!pipe_conn->packet) {
+		stream_terminate_connection(conn, "out of memory");
+		return;
+	}
+	packet_set_private(pipe_conn->packet, pipe_conn);
+	packet_set_socket(pipe_conn->packet, conn->socket);
+	packet_set_callback(pipe_conn->packet, named_pipe_recv_auth_request);
+	packet_set_full_request(pipe_conn->packet, named_pipe_full_request);
+	packet_set_error_handler(pipe_conn->packet, named_pipe_recv_error);
+	packet_set_event_context(pipe_conn->packet, conn->event.ctx);
+	packet_set_fde(pipe_conn->packet, conn->event.fde);
+	packet_set_serialise(pipe_conn->packet);
+	packet_set_initial_read(pipe_conn->packet, 8);
+
+	pipe_conn->pipe_sock = pipe_sock;
+
+	pipe_conn->connection = conn;
+	conn->private_data = pipe_conn;
 }
 
 static const struct stream_server_ops named_pipe_stream_ops = {