ipc.c - trusty/app/storage - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <assert.h>
 #include <lk/list.h>
 #include <stdlib.h>
 #include <trusty_ipc.h>
 #include <trusty_log.h>
 #include <uapi/err.h>

 #include "ipc.h"

 #define MSG_BUF_MAX_SIZE 4096

 #define TLOG_TAG "ss-ipc"

 /* Start logging response waits after this many milliseconds. */
 #define RESPONSE_TIMEOUT 1000

 /*
  * Don't wait more than this many ms between logging statements (currently
  * 1000s)
  */
 #define RESPONSE_TIMEOUT_MAX (RESPONSE_TIMEOUT * 1000 * 1000)

 static void* msg_buf;
 static size_t msg_buf_size;

 static void handle_channel(struct ipc_context* ctx, const struct uevent* ev);
 static void handle_port(struct ipc_context* ctx, const struct uevent* ev);

 static int maybe_grow_msg_buf(size_t new_max_size) {
     if (new_max_size > msg_buf_size) {
         uint8_t* tmp = realloc(msg_buf, new_max_size);
         if (tmp == NULL) {
             return ERR_NO_MEMORY;
         }
         msg_buf = tmp;
         msg_buf_size = new_max_size;
     }
     return NO_ERROR;
 }

 static inline void handle_port_errors(const uevent_t* ev) {
     if ((ev->event & IPC_HANDLE_POLL_ERROR) ||
         (ev->event & IPC_HANDLE_POLL_HUP) ||
         (ev->event & IPC_HANDLE_POLL_MSG) ||
         (ev->event & IPC_HANDLE_POLL_SEND_UNBLOCKED)) {
         /* should never happen with port handles */
         TLOGE("error event (0x%x) for port (%d)\n", ev->event, ev->handle);
         abort();
     }
 }

 static inline void handle_chan_errors(const uevent_t* ev) {
     if ((ev->event & IPC_HANDLE_POLL_ERROR) ||
         (ev->event & IPC_HANDLE_POLL_READY)) {
         TLOGE("error event (0x%x) for chan (%d)\n", ev->event, ev->handle);
         abort();
     }
 }

 static int is_valid_port_ops(struct ipc_port_ops* ops) {
     return (ops->on_connect != NULL);
 }

 static bool is_valid_chan_ops(struct ipc_channel_ops* ops) {
     return (ops->on_disconnect != NULL);
 }

 static struct ipc_port_context* to_port_context(struct ipc_context* context) {
     assert(context);
     return containerof(context, struct ipc_port_context, common);
 }

 static struct ipc_channel_context* to_channel_context(
         struct ipc_context* context) {
     assert(context);
     return containerof(context, struct ipc_channel_context, common);
 }

 static int do_connect(struct ipc_port_context* ctx, const uevent_t* ev) {
     int rc;
     handle_t chan_handle;
     struct ipc_channel_context* chan_ctx;

     if (ev->event & IPC_HANDLE_POLL_READY) {
         /* incoming connection: accept it */
         uuid_t peer_uuid;
         rc = accept(ev->handle, &peer_uuid);
         if (rc < 0) {
             TLOGE("failed (%d) to accept on port %d\n", rc, ev->handle);
             return rc;
         }

         chan_handle = (handle_t)rc;

         chan_ctx = ctx->ops.on_connect(ctx, &peer_uuid, chan_handle);
         if (chan_ctx == NULL) {
             TLOGE("%s: failure initializing channel state (%d)\n", __func__,
                   rc);
             rc = ERR_GENERIC;
             goto err_on_connect;
         }

         assert(is_valid_chan_ops(&chan_ctx->ops));

         chan_ctx->common.evt_handler = handle_channel;
         chan_ctx->common.handle = chan_handle;

         rc = set_cookie(chan_handle, chan_ctx);
         if (rc < 0) {
             TLOGE("failed (%d) to set_cookie on chan %d\n", rc, chan_handle);
             goto err_set_cookie;
         }
         list_add_tail(&ctx->channels, &chan_ctx->node);
     }

     return NO_ERROR;

 err_set_cookie:
     chan_ctx->ops.on_disconnect(chan_ctx);
 err_on_connect:
     close(chan_handle);
     return rc;
 }

 static int do_handle_msg(struct ipc_channel_context* ctx, const uevent_t* ev) {
     handle_t chan = ev->handle;

     /* get message info */
     ipc_msg_info_t msg_inf;
     int rc = get_msg(chan, &msg_inf);
     if (rc == ERR_NO_MSG)
         return NO_ERROR; /* no new messages */

     if (rc != NO_ERROR) {
         TLOGE("failed (%d) to get_msg for chan (%d), closing connection\n", rc,
               chan);
         return rc;
     }

     if (msg_inf.len > MSG_BUF_MAX_SIZE) {
         TLOGE("%s: message too large %zu\n", __func__, msg_inf.len);
         put_msg(chan, msg_inf.id);
         return ERR_NOT_ENOUGH_BUFFER;
     }

     /* read msg content */
     struct iovec iov = {
             .iov_base = msg_buf,
             .iov_len = msg_inf.len,
     };
     ipc_msg_t msg = {
             .iov = &iov,
             .num_iov = 1,
     };

     rc = read_msg(chan, msg_inf.id, 0, &msg);
     put_msg(chan, msg_inf.id);
     if (rc < 0) {
         TLOGE("failed to read msg (%d, %d)\n", rc, chan);
         return rc;
     }

     if (((size_t)rc) < msg_inf.len) {
         TLOGE("invalid message of size (%d, %d)\n", rc, chan);
         return ERR_NOT_VALID;
     }

     rc = ctx->ops.on_handle_msg(ctx, msg_buf, msg_inf.len);

 err_handle_msg:
 err_read_msg:
     return rc;
 }

 static void do_disconnect(struct ipc_channel_context* context,
                           const uevent_t* ev) {
     list_delete(&context->node);
     context->ops.on_disconnect(context);
     close(ev->handle);
 }

 static void handle_port(struct ipc_context* ctx, const struct uevent* ev) {
     struct ipc_port_context* port_ctx = to_port_context(ctx);
     assert(is_valid_port_ops(&port_ctx->ops));

     handle_port_errors(ev);

     do_connect(port_ctx, ev);
 }

 static void handle_channel(struct ipc_context* ctx, const struct uevent* ev) {
     struct ipc_channel_context* channel_ctx = to_channel_context(ctx);
     assert(is_valid_chan_ops(&channel_ctx->ops));

     handle_chan_errors(ev);

     if (ev->event & IPC_HANDLE_POLL_MSG) {
         if (channel_ctx->ops.on_handle_msg != NULL) {
             int rc = do_handle_msg(channel_ctx, ev);
             if (rc < 0) {
                 TLOGE("error (%d) in channel, disconnecting "
                       "peer\n",
                       rc);
                 do_disconnect(channel_ctx, ev);
                 return;
             }
         } else {
             TLOGE("error: unexpected message in channel (%d). closing...\n",
                   ev->handle);
             do_disconnect(channel_ctx, ev);
             return;
         }
     }

     if (ev->event & IPC_HANDLE_POLL_HUP) {
         do_disconnect(channel_ctx, ev);
     }
 }

 static int read_response(handle_t session,
                          uint32_t msg_id,
                          struct iovec* iovecs,
                          size_t iovec_count) {
     struct ipc_msg rx_msg = {
             .iov = iovecs,
             .num_iov = iovec_count,
     };

     long rc = read_msg(session, msg_id, 0, &rx_msg);
     put_msg(session, msg_id);
     if (rc < 0) {
         TLOGE("%s: failed to read msg (%ld)\n", __func__, rc);
         return rc;
     }

     size_t read_size = (size_t)rc;
     return read_size;
 }

 static int await_response(handle_t session, struct ipc_msg_info* inf) {
     uevent_t uevt;
     unsigned long wait_timeout = RESPONSE_TIMEOUT;
     long rc;
     while (true) {
         rc = wait(session, &uevt, wait_timeout);
         if (rc != ERR_TIMED_OUT) {
             break;
         }
         TLOGE("%s: storage response wait timed out after %ldx ms\n", __func__,
               wait_timeout);
         wait_timeout *= 2;
         if (wait_timeout > RESPONSE_TIMEOUT_MAX) {
             wait_timeout = RESPONSE_TIMEOUT_MAX;
         }
     }
     if (rc != NO_ERROR) {
         TLOGE("%s: error while waiting for response (%ld)\n", __func__, rc);
         return rc;
     }

     rc = get_msg(session, inf);
     if (rc != NO_ERROR) {
         TLOGE("%s: failed to get_msg (%ld)\n", __func__, rc);
     }

     return rc;
 }

 static int wait_to_send(handle_t session, struct ipc_msg* msg) {
     int rc;
     struct uevent ev = UEVENT_INITIAL_VALUE(ev);

     rc = wait(session, &ev, INFINITE_TIME);
     if (rc < 0) {
         TLOGE("failed to wait for outgoing queue to free up\n");
         return rc;
     }

     if (ev.event & IPC_HANDLE_POLL_SEND_UNBLOCKED) {
         return send_msg(session, msg);
     }

     if (ev.event & IPC_HANDLE_POLL_MSG) {
         return ERR_BUSY;
     }

     if (ev.event & IPC_HANDLE_POLL_HUP) {
         return ERR_CHANNEL_CLOSED;
     }

     return rc;
 }

 int sync_ipc_send_msg(handle_t session,
                       struct iovec* tx_iovecs,
                       unsigned int tx_iovec_count,
                       struct iovec* rx_iovecs,
                       unsigned int rx_iovec_count) {
     struct ipc_msg tx_msg = {
             .iov = tx_iovecs,
             .num_iov = tx_iovec_count,
     };

     long rc = send_msg(session, &tx_msg);
     if (rc == ERR_NOT_ENOUGH_BUFFER) {
         rc = wait_to_send(session, &tx_msg);
     }

     if (rc < 0) {
         TLOGE("%s: failed (%ld) to send_msg\n", __func__, rc);
         return rc;
     }

     if (rx_iovecs == NULL || rx_iovec_count == 0) {
         assert(rx_iovec_count == 0);
         assert(rx_iovecs == NULL);
         return NO_ERROR;
     }

     struct ipc_msg_info inf;
     rc = await_response(session, &inf);
     if (rc < 0) {
         TLOGE("%s: failed (%ld) to await response\n", __func__, rc);
         return rc;
     }

     size_t min_len = rx_iovecs[0].iov_len;
     if (inf.len < min_len) {
         TLOGE("%s: invalid response length (%zu)\n", __func__, inf.len);
         put_msg(session, inf.id);
         return ERR_NOT_VALID;
     }

     /* calculate total message size */
     size_t resp_size = 0;
     for (size_t i = 0; i < rx_iovec_count; ++i) {
         resp_size += rx_iovecs[i].iov_len;
     }

     if (resp_size < inf.len) {
         TLOGE("%s: response buffer too short (%zu < %zu) \n", __func__,
               resp_size, inf.len);
         put_msg(session, inf.id);
         return ERR_BAD_LEN;
     }

     rc = read_response(session, inf.id, rx_iovecs, rx_iovec_count);
     put_msg(session, inf.id);
     if (rc < 0) {
         TLOGE("%s: response has error (%ld)\n", __func__, rc);
         return rc;
     }

     size_t read_len = (size_t)rc;
     if (read_len != inf.len) {
         // data read in does not match message length
         TLOGE("%s: invalid response length (%zu)\n", __func__, read_len);
         return ERR_IO;
     }

     return read_len;
 }

 static void dispatch_event(const uevent_t* ev) {
     assert(ev);

     if (ev->event == IPC_HANDLE_POLL_NONE) {
         return;
     }

     struct ipc_context* context = ev->cookie;
     assert(context);
     assert(context->evt_handler);
     assert(context->handle == ev->handle);

     context->evt_handler(context, ev);
 }

 int ipc_port_create(struct ipc_port_context* ctxp,
                     const char* port_name,
                     size_t queue_size,
                     size_t max_buffer_size,
                     uint32_t flags) {
     int rc;
     assert(ctxp);
     assert(is_valid_port_ops(&ctxp->ops));

     rc = port_create(port_name, queue_size, max_buffer_size, flags);

     if (rc < 0) {
         TLOGE("Failed to create port %s %d\n", port_name, rc);
         return rc;
     }

     handle_t port_handle = (handle_t)rc;
     rc = set_cookie(port_handle, ctxp);
     if (rc < 0) {
         TLOGE("Failed to set cookie on port %s (%d)\n", port_name, rc);
         goto err_set_cookie;
     }

     rc = maybe_grow_msg_buf(max_buffer_size);
     if (rc < 0) {
         TLOGE("Failed to create msg buffer of size %zu (%d)\n", max_buffer_size,
               rc);
         goto err_grow_msg;
     }

     ctxp->common.handle = port_handle;
     ctxp->common.evt_handler = handle_port;
     list_initialize(&ctxp->channels);
     return NO_ERROR;

 err_set_cookie:
 err_grow_msg:
     close(port_handle);
     return rc;
 }

 int ipc_port_destroy(struct ipc_port_context* ctx) {
     close(ctx->common.handle);
     while (!list_is_empty(&ctx->channels)) {
         struct ipc_channel_context* chan_ctx = list_remove_head_type(
                 &ctx->channels, struct ipc_channel_context, node);
         assert(chan_ctx);
         handle_t chan_handle = chan_ctx->common.handle;
         TLOGE("client still connected, handle %d\n", chan_handle);
         chan_ctx->ops.on_disconnect(chan_ctx);
         close(chan_handle);
     }
     return NO_ERROR;
 }

 void ipc_loop(void) {
     int rc;
     uevent_t event;

     while (true) {
         event.handle = INVALID_IPC_HANDLE;
         event.event = 0;
         event.cookie = NULL;
         rc = wait_any(&event, INFINITE_TIME);
         if (rc < 0) {
             TLOGE("wait_any failed (%d)\n", rc);
             break;
         }

         if (rc == NO_ERROR) { /* got an event */
             dispatch_event(&event);
         }
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <assert.h>
	#include <lk/list.h>
	#include <stdlib.h>
	#include <trusty_ipc.h>
	#include <trusty_log.h>
	#include <uapi/err.h>

	#include "ipc.h"

	#define MSG_BUF_MAX_SIZE 4096

	#define TLOG_TAG "ss-ipc"

	/* Start logging response waits after this many milliseconds. */
	#define RESPONSE_TIMEOUT 1000

	/*
	* Don't wait more than this many ms between logging statements (currently
	* 1000s)
	*/
	#define RESPONSE_TIMEOUT_MAX (RESPONSE_TIMEOUT * 1000 * 1000)

	static void* msg_buf;
	static size_t msg_buf_size;

	static void handle_channel(struct ipc_context* ctx, const struct uevent* ev);
	static void handle_port(struct ipc_context* ctx, const struct uevent* ev);

	static int maybe_grow_msg_buf(size_t new_max_size) {
	if (new_max_size > msg_buf_size) {
	uint8_t* tmp = realloc(msg_buf, new_max_size);
	if (tmp == NULL) {
	return ERR_NO_MEMORY;
	}
	msg_buf = tmp;
	msg_buf_size = new_max_size;
	}
	return NO_ERROR;
	}

	static inline void handle_port_errors(const uevent_t* ev) {
	if ((ev->event & IPC_HANDLE_POLL_ERROR) \|\|
	(ev->event & IPC_HANDLE_POLL_HUP) \|\|
	(ev->event & IPC_HANDLE_POLL_MSG) \|\|
	(ev->event & IPC_HANDLE_POLL_SEND_UNBLOCKED)) {
	/* should never happen with port handles */
	TLOGE("error event (0x%x) for port (%d)\n", ev->event, ev->handle);
	abort();
	}
	}

	static inline void handle_chan_errors(const uevent_t* ev) {
	if ((ev->event & IPC_HANDLE_POLL_ERROR) \|\|
	(ev->event & IPC_HANDLE_POLL_READY)) {
	TLOGE("error event (0x%x) for chan (%d)\n", ev->event, ev->handle);
	abort();
	}
	}

	static int is_valid_port_ops(struct ipc_port_ops* ops) {
	return (ops->on_connect != NULL);
	}

	static bool is_valid_chan_ops(struct ipc_channel_ops* ops) {
	return (ops->on_disconnect != NULL);
	}

	static struct ipc_port_context* to_port_context(struct ipc_context* context) {
	assert(context);
	return containerof(context, struct ipc_port_context, common);
	}

	static struct ipc_channel_context* to_channel_context(
	struct ipc_context* context) {
	assert(context);
	return containerof(context, struct ipc_channel_context, common);
	}

	static int do_connect(struct ipc_port_context* ctx, const uevent_t* ev) {
	int rc;
	handle_t chan_handle;
	struct ipc_channel_context* chan_ctx;

	if (ev->event & IPC_HANDLE_POLL_READY) {
	/* incoming connection: accept it */
	uuid_t peer_uuid;
	rc = accept(ev->handle, &peer_uuid);
	if (rc < 0) {
	TLOGE("failed (%d) to accept on port %d\n", rc, ev->handle);
	return rc;
	}

	chan_handle = (handle_t)rc;

	chan_ctx = ctx->ops.on_connect(ctx, &peer_uuid, chan_handle);
	if (chan_ctx == NULL) {
	TLOGE("%s: failure initializing channel state (%d)\n", __func__,
	rc);
	rc = ERR_GENERIC;
	goto err_on_connect;
	}

	assert(is_valid_chan_ops(&chan_ctx->ops));

	chan_ctx->common.evt_handler = handle_channel;
	chan_ctx->common.handle = chan_handle;

	rc = set_cookie(chan_handle, chan_ctx);
	if (rc < 0) {
	TLOGE("failed (%d) to set_cookie on chan %d\n", rc, chan_handle);
	goto err_set_cookie;
	}
	list_add_tail(&ctx->channels, &chan_ctx->node);
	}

	return NO_ERROR;

	err_set_cookie:
	chan_ctx->ops.on_disconnect(chan_ctx);
	err_on_connect:
	close(chan_handle);
	return rc;
	}

	static int do_handle_msg(struct ipc_channel_context* ctx, const uevent_t* ev) {
	handle_t chan = ev->handle;

	/* get message info */
	ipc_msg_info_t msg_inf;
	int rc = get_msg(chan, &msg_inf);
	if (rc == ERR_NO_MSG)
	return NO_ERROR; /* no new messages */

	if (rc != NO_ERROR) {
	TLOGE("failed (%d) to get_msg for chan (%d), closing connection\n", rc,
	chan);
	return rc;
	}

	if (msg_inf.len > MSG_BUF_MAX_SIZE) {
	TLOGE("%s: message too large %zu\n", __func__, msg_inf.len);
	put_msg(chan, msg_inf.id);
	return ERR_NOT_ENOUGH_BUFFER;
	}

	/* read msg content */
	struct iovec iov = {
	.iov_base = msg_buf,
	.iov_len = msg_inf.len,
	};
	ipc_msg_t msg = {
	.iov = &iov,
	.num_iov = 1,
	};

	rc = read_msg(chan, msg_inf.id, 0, &msg);
	put_msg(chan, msg_inf.id);
	if (rc < 0) {
	TLOGE("failed to read msg (%d, %d)\n", rc, chan);
	return rc;
	}

	if (((size_t)rc) < msg_inf.len) {
	TLOGE("invalid message of size (%d, %d)\n", rc, chan);
	return ERR_NOT_VALID;
	}

	rc = ctx->ops.on_handle_msg(ctx, msg_buf, msg_inf.len);

	err_handle_msg:
	err_read_msg:
	return rc;
	}

	static void do_disconnect(struct ipc_channel_context* context,
	const uevent_t* ev) {
	list_delete(&context->node);
	context->ops.on_disconnect(context);
	close(ev->handle);
	}

	static void handle_port(struct ipc_context* ctx, const struct uevent* ev) {
	struct ipc_port_context* port_ctx = to_port_context(ctx);
	assert(is_valid_port_ops(&port_ctx->ops));

	handle_port_errors(ev);

	do_connect(port_ctx, ev);
	}

	static void handle_channel(struct ipc_context* ctx, const struct uevent* ev) {
	struct ipc_channel_context* channel_ctx = to_channel_context(ctx);
	assert(is_valid_chan_ops(&channel_ctx->ops));

	handle_chan_errors(ev);

	if (ev->event & IPC_HANDLE_POLL_MSG) {
	if (channel_ctx->ops.on_handle_msg != NULL) {
	int rc = do_handle_msg(channel_ctx, ev);
	if (rc < 0) {
	TLOGE("error (%d) in channel, disconnecting "
	"peer\n",
	rc);
	do_disconnect(channel_ctx, ev);
	return;
	}
	} else {
	TLOGE("error: unexpected message in channel (%d). closing...\n",
	ev->handle);
	do_disconnect(channel_ctx, ev);
	return;
	}
	}

	if (ev->event & IPC_HANDLE_POLL_HUP) {
	do_disconnect(channel_ctx, ev);
	}
	}

	static int read_response(handle_t session,
	uint32_t msg_id,
	struct iovec* iovecs,
	size_t iovec_count) {
	struct ipc_msg rx_msg = {
	.iov = iovecs,
	.num_iov = iovec_count,
	};

	long rc = read_msg(session, msg_id, 0, &rx_msg);
	put_msg(session, msg_id);
	if (rc < 0) {
	TLOGE("%s: failed to read msg (%ld)\n", __func__, rc);
	return rc;
	}

	size_t read_size = (size_t)rc;
	return read_size;
	}

	static int await_response(handle_t session, struct ipc_msg_info* inf) {
	uevent_t uevt;
	unsigned long wait_timeout = RESPONSE_TIMEOUT;
	long rc;
	while (true) {
	rc = wait(session, &uevt, wait_timeout);
	if (rc != ERR_TIMED_OUT) {
	break;
	}
	TLOGE("%s: storage response wait timed out after %ldx ms\n", __func__,
	wait_timeout);
	wait_timeout *= 2;
	if (wait_timeout > RESPONSE_TIMEOUT_MAX) {
	wait_timeout = RESPONSE_TIMEOUT_MAX;
	}
	}
	if (rc != NO_ERROR) {
	TLOGE("%s: error while waiting for response (%ld)\n", __func__, rc);
	return rc;
	}

	rc = get_msg(session, inf);
	if (rc != NO_ERROR) {
	TLOGE("%s: failed to get_msg (%ld)\n", __func__, rc);
	}

	return rc;
	}

	static int wait_to_send(handle_t session, struct ipc_msg* msg) {
	int rc;
	struct uevent ev = UEVENT_INITIAL_VALUE(ev);

	rc = wait(session, &ev, INFINITE_TIME);
	if (rc < 0) {
	TLOGE("failed to wait for outgoing queue to free up\n");
	return rc;
	}

	if (ev.event & IPC_HANDLE_POLL_SEND_UNBLOCKED) {
	return send_msg(session, msg);
	}

	if (ev.event & IPC_HANDLE_POLL_MSG) {
	return ERR_BUSY;
	}

	if (ev.event & IPC_HANDLE_POLL_HUP) {
	return ERR_CHANNEL_CLOSED;
	}

	return rc;
	}

	int sync_ipc_send_msg(handle_t session,
	struct iovec* tx_iovecs,
	unsigned int tx_iovec_count,
	struct iovec* rx_iovecs,
	unsigned int rx_iovec_count) {
	struct ipc_msg tx_msg = {
	.iov = tx_iovecs,
	.num_iov = tx_iovec_count,
	};

	long rc = send_msg(session, &tx_msg);
	if (rc == ERR_NOT_ENOUGH_BUFFER) {
	rc = wait_to_send(session, &tx_msg);
	}

	if (rc < 0) {
	TLOGE("%s: failed (%ld) to send_msg\n", __func__, rc);
	return rc;
	}

	if (rx_iovecs == NULL \|\| rx_iovec_count == 0) {
	assert(rx_iovec_count == 0);
	assert(rx_iovecs == NULL);
	return NO_ERROR;
	}

	struct ipc_msg_info inf;
	rc = await_response(session, &inf);
	if (rc < 0) {
	TLOGE("%s: failed (%ld) to await response\n", __func__, rc);
	return rc;
	}

	size_t min_len = rx_iovecs[0].iov_len;
	if (inf.len < min_len) {
	TLOGE("%s: invalid response length (%zu)\n", __func__, inf.len);
	put_msg(session, inf.id);
	return ERR_NOT_VALID;
	}

	/* calculate total message size */
	size_t resp_size = 0;
	for (size_t i = 0; i < rx_iovec_count; ++i) {
	resp_size += rx_iovecs[i].iov_len;
	}

	if (resp_size < inf.len) {
	TLOGE("%s: response buffer too short (%zu < %zu) \n", __func__,
	resp_size, inf.len);
	put_msg(session, inf.id);
	return ERR_BAD_LEN;
	}

	rc = read_response(session, inf.id, rx_iovecs, rx_iovec_count);
	put_msg(session, inf.id);
	if (rc < 0) {
	TLOGE("%s: response has error (%ld)\n", __func__, rc);
	return rc;
	}

	size_t read_len = (size_t)rc;
	if (read_len != inf.len) {
	// data read in does not match message length
	TLOGE("%s: invalid response length (%zu)\n", __func__, read_len);
	return ERR_IO;
	}

	return read_len;
	}

	static void dispatch_event(const uevent_t* ev) {
	assert(ev);

	if (ev->event == IPC_HANDLE_POLL_NONE) {
	return;
	}

	struct ipc_context* context = ev->cookie;
	assert(context);
	assert(context->evt_handler);
	assert(context->handle == ev->handle);

	context->evt_handler(context, ev);
	}

	int ipc_port_create(struct ipc_port_context* ctxp,
	const char* port_name,
	size_t queue_size,
	size_t max_buffer_size,
	uint32_t flags) {
	int rc;
	assert(ctxp);
	assert(is_valid_port_ops(&ctxp->ops));

	rc = port_create(port_name, queue_size, max_buffer_size, flags);

	if (rc < 0) {
	TLOGE("Failed to create port %s %d\n", port_name, rc);
	return rc;
	}

	handle_t port_handle = (handle_t)rc;
	rc = set_cookie(port_handle, ctxp);
	if (rc < 0) {
	TLOGE("Failed to set cookie on port %s (%d)\n", port_name, rc);
	goto err_set_cookie;
	}

	rc = maybe_grow_msg_buf(max_buffer_size);
	if (rc < 0) {
	TLOGE("Failed to create msg buffer of size %zu (%d)\n", max_buffer_size,
	rc);
	goto err_grow_msg;
	}

	ctxp->common.handle = port_handle;
	ctxp->common.evt_handler = handle_port;
	list_initialize(&ctxp->channels);
	return NO_ERROR;

	err_set_cookie:
	err_grow_msg:
	close(port_handle);
	return rc;
	}

	int ipc_port_destroy(struct ipc_port_context* ctx) {
	close(ctx->common.handle);
	while (!list_is_empty(&ctx->channels)) {
	struct ipc_channel_context* chan_ctx = list_remove_head_type(
	&ctx->channels, struct ipc_channel_context, node);
	assert(chan_ctx);
	handle_t chan_handle = chan_ctx->common.handle;
	TLOGE("client still connected, handle %d\n", chan_handle);
	chan_ctx->ops.on_disconnect(chan_ctx);
	close(chan_handle);
	}
	return NO_ERROR;
	}

	void ipc_loop(void) {
	int rc;
	uevent_t event;

	while (true) {
	event.handle = INVALID_IPC_HANDLE;
	event.event = 0;
	event.cookie = NULL;
	rc = wait_any(&event, INFINITE_TIME);
	if (rc < 0) {
	TLOGE("wait_any failed (%d)\n", rc);
	break;
	}

	if (rc == NO_ERROR) { /* got an event */
	dispatch_event(&event);
	}
	}
	}