freebsd-dev/sys/contrib/ngatm/netnatm/api/cc_port.c

/*
 * Copyright (c) 2003-2004
 *	Hartmut Brandt
 *	All rights reserved.
 *
 * Copyright (c) 2001-2002
 *	Fraunhofer Institute for Open Communication Systems (FhG Fokus).
 *	All rights reserved.
 *
 * Author: Harti Brandt <harti@freebsd.org>
 *
 * Redistribution of this software and documentation and use in source and
 * binary forms, with or without modification, are permitted provided that
 * the following conditions are met:
 *
 * 1. Redistributions of source code or documentation must retain the above
 *    copyright notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE AUTHOR
 * AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * THE AUTHOR OR ITS CONTRIBUTORS  BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * $Begemot: libunimsg/netnatm/api/cc_port.c,v 1.1 2004/07/08 08:21:53 brandt Exp $
 *
 * ATM API as defined per af-saa-0108
 *
 * Port-global stuff (ILMI and Co.)
 */
#include <netnatm/unimsg.h>
#include <netnatm/msg/unistruct.h>
#include <netnatm/api/unisap.h>
#include <netnatm/sig/unidef.h>
#include <netnatm/api/atmapi.h>
#include <netnatm/api/ccatm.h>
#include <netnatm/api/ccpriv.h>

/*
 * Find a port with a given number
 */
static struct ccport *
find_port(struct ccdata *cc, u_int portno)
{
	struct ccport *port;

	TAILQ_FOREACH(port, &cc->port_list, node_link)
		if (port->param.port == portno)
			return (port);
	return (NULL);
}

/*
 * Create a new port structure, initialize it and link it to the node.
 * Returns 0 on success, an errno otherwise.
 */
struct ccport *
cc_port_create(struct ccdata *cc, void *uarg, u_int portno)
{
	struct ccport *port, *p1;

	if (portno == 0 || portno > 0xffffffff)
		return (NULL);

	TAILQ_FOREACH(port, &cc->port_list, node_link)
		if (port->param.port == portno)
			return (NULL);

	port = CCZALLOC(sizeof(*port));
	if (port == NULL)
		return (NULL);

	port->uarg = uarg;
	port->cc = cc;
	port->admin = CCPORT_STOPPED;
	LIST_INIT(&port->conn_list);
	TAILQ_INIT(&port->addr_list);
	port->param.port = portno;
	port->param.pcr = 350053;
	port->param.max_vpi_bits = 0;
	port->param.max_vci_bits = 8;
	port->param.max_svpc_vpi = 0;
	port->param.max_svcc_vpi = 0;
	port->param.min_svcc_vci = 32;
	port->param.num_addrs = 0;
	TAILQ_INIT(&port->cookies);

	TAILQ_FOREACH(p1, &cc->port_list, node_link)
		if (p1->param.port > portno) {
			TAILQ_INSERT_BEFORE(p1, port, node_link);
			break;
		}
	if (p1 == NULL)
		TAILQ_INSERT_TAIL(&cc->port_list, port, node_link);

	return (port);
}

/*
 * Destroy a port. This closes all connections and aborts all the users of
 * these connections.
 * This should be called only after work has returned so that no signals
 * are pending.
 */
void
cc_port_destroy(struct ccport *port, int shutdown)
{
	struct ccaddr *addr;
	struct ccreq *r;

	TAILQ_REMOVE(&port->cc->port_list, port, node_link);

	while ((r = TAILQ_FIRST(&port->cookies)) != NULL) {
		TAILQ_REMOVE(&port->cookies, r, link);
		CCFREE(r);
	}

	/*
	 * Abort all connections.
	 */
	while (!LIST_EMPTY(&port->conn_list))
		cc_conn_abort(LIST_FIRST(&port->conn_list), shutdown);

	/*
	 * Free addresses.
	 */
	while ((addr = TAILQ_FIRST(&port->addr_list)) != NULL) {
		TAILQ_REMOVE(&port->addr_list, addr, port_link);
		CCFREE(addr);
	}

	CCFREE(port);
}

/*
 * Management is given up on this node. Remove all addresses from the port.
 */
void
cc_unmanage(struct ccdata *cc)
{
	struct ccport *port;
	struct ccaddr *addr;

	TAILQ_FOREACH(port, &cc->port_list, node_link) {
		while ((addr = TAILQ_FIRST(&port->addr_list)) != NULL) {
			TAILQ_REMOVE(&port->addr_list, addr, port_link);
			CCFREE(addr);
		}
	}
}

/*
 * Compare two addresses
 */
static __inline int
addr_eq(const struct uni_addr *a1, const struct uni_addr *a2)
{
	return (a1->type == a2->type && a1->plan == a2->plan &&
	    a1->len == a2->len && memcmp(a1->addr, a2->addr, a1->len) == 0);
}


/*
 * retrieve addresses
 */
int
cc_get_addrs(struct ccdata *cc, u_int portno,
    struct uni_addr **pa, u_int **ports, u_int *count)
{
	struct ccport *port = NULL;
	struct ccaddr *addr;
	struct uni_addr *buf, *ptr;
	u_int *pports;

	/*
	 * If a port number is specified and the port does not exist,
	 * return an error.
	 */
	if (portno != 0)
		if ((port = find_port(cc, portno)) == NULL)
			return (ENOENT);

	/*
	 * Count the addresses
	 */
	*count = 0;
	if (portno != 0) {
		TAILQ_FOREACH(addr, &port->addr_list, port_link)
			(*count)++;
	} else {
		TAILQ_FOREACH(port, &cc->port_list, node_link)
			TAILQ_FOREACH(addr, &port->addr_list, port_link)
				(*count)++;
	}

	buf = CCMALLOC(*count * sizeof(struct uni_addr));
	if (buf == NULL)
		return (ENOMEM);
	ptr = buf;

	*ports = CCMALLOC(*count * sizeof(u_int));
	if (*ports == NULL) {
		CCFREE(buf);
		return (ENOMEM);
	}
	pports = *ports;

	if (portno != 0) {
		TAILQ_FOREACH(addr, &port->addr_list, port_link) {
			*ptr++ = addr->addr;
			*pports++ = portno;
		}
	} else {
		TAILQ_FOREACH(port, &cc->port_list, node_link)
			TAILQ_FOREACH(addr, &port->addr_list, port_link) {
				*ptr++ = addr->addr;
				*pports++ = port->param.port;
			}
	}

	*pa = buf;
	return (0);
}

/*
 * return port number
 */
u_int
cc_port_no(struct ccport *port)
{
	return (port->param.port);
}

/*
 * Address unregisterd.
 */
int
cc_addr_unregister(struct ccdata *cc, u_int portno, const struct uni_addr *arg)
{
	struct ccport *port;
	struct ccaddr *a;

	if ((port = find_port(cc, portno)) == NULL)
		return (ENOENT);

	/* Find the address */
	TAILQ_FOREACH(a, &port->addr_list, port_link)
		if (addr_eq(arg, &a->addr)) {
			TAILQ_REMOVE(&port->addr_list, a, port_link);
			CCFREE(a);
			return (0);
		}

	return (ENOENT);
}

/*
 * Address registerd.
 */
int
cc_addr_register(struct ccdata *cc, u_int portno, const struct uni_addr *arg)
{
	struct ccport *port, *p1;
	struct ccaddr *a;

	if ((port = find_port(cc, portno)) == NULL)
		return (ENOENT);

	/* maybe we know it already? */
	TAILQ_FOREACH(p1, &port->cc->port_list, node_link)
		TAILQ_FOREACH(a, &p1->addr_list, port_link)
			if (addr_eq(arg, &a->addr))
				return (EISCONN);

	a = CCZALLOC(sizeof(*a));
	if (a == NULL)
		return (ENOMEM);
	a->addr = *arg;

	TAILQ_INSERT_TAIL(&port->addr_list, a, port_link);

	return (0);
}

/*
 * Set/get port parameters.
 */
int
cc_port_get_param(struct ccdata *cc, u_int portno,
    struct atm_port_info *param)
{
	struct ccport *port;

	if ((port = find_port(cc, portno)) == NULL)
		return (ENOENT);

	*param = port->param;
	return (0);
}

/* XXX maybe allow only in stopped. */
int
cc_port_set_param(struct ccdata *cc, const struct atm_port_info *param)
{
	struct ccport *port;
	struct ccaddr *addr;

	if ((port = find_port(cc, param->port)) == NULL)
		return (ENOENT);

	port->param = *param;

	port->param.num_addrs = 0;
	TAILQ_FOREACH(addr, &port->addr_list, port_link)
		port->param.num_addrs++;

	return (0);
}

/*
 * get port list
 */
int
cc_port_getlist(struct ccdata *cc, u_int *cnt, u_int **ports)
{
	struct ccport *p;
	u_int n;

	n = 0;
	TAILQ_FOREACH(p, &cc->port_list, node_link)
		n++;

	*ports = CCMALLOC(n * sizeof(u_int));
	if (*ports == NULL)
		return (ENOMEM);

	n = 0;
	TAILQ_FOREACH(p, &cc->port_list, node_link)
		(*ports)[n++] = p->param.port;
	*cnt = n;

	return (0);
}

/*
 * START and STOP signalling
 */
int
cc_port_start(struct ccdata *cc, u_int portno)
{
	struct ccport *port;

	if ((port = find_port(cc, portno)) == NULL)
		return (ENOENT);
	if (port->admin != CCPORT_STOPPED)
		return (EISCONN);

	cc->funcs->send_uni_glob(port, port->uarg,
	    UNIAPI_LINK_ESTABLISH_request, 0, NULL);
	port->admin = CCPORT_RUNNING;

	return (0);
}

int
cc_port_stop(struct ccdata *cc, u_int portno)
{
	struct ccport *port;

	if ((port = find_port(cc, portno)) == NULL)
		return (ENOENT);
	if (port->admin != CCPORT_RUNNING)
		return (ENOTCONN);

	port->admin = CCPORT_STOPPED;

	/*
	 * Abort all connections.
	 */
	while (!LIST_EMPTY(&port->conn_list))
		cc_conn_destroy(LIST_FIRST(&port->conn_list));

	return (0);
}

/*
 * is port running?
 */
int
cc_port_isrunning(struct ccdata *cc, u_int portno, int *state)
{
	struct ccport *port;

	if ((port = find_port(cc, portno)) == NULL)
		return (ENOENT);
	if (port->admin == CCPORT_RUNNING)
		*state = 1;
	else
		*state = 0;
	return (0);
}

/*
 * Clear address and prefix information from the named port.
 */
int
cc_port_clear(struct ccdata *cc, u_int portno)
{
	struct ccaddr *addr;
	struct ccport *port;

	if ((port = find_port(cc, portno)) == NULL)
		return (ENOENT);

	while ((addr = TAILQ_FIRST(&port->addr_list)) != NULL) {
		TAILQ_REMOVE(&port->addr_list, addr, port_link);
		CCFREE(addr);
	}
	return (0);
}

/*
 * retrieve info on local ports
 */
struct atm_port_list *
cc_get_local_port_info(struct ccdata *cc, u_int portno, size_t *lenp)
{
	struct atm_port_list *list;
	struct atm_port_info *pp;
	struct uni_addr *aa;
	struct ccaddr *addr;
	struct ccport *port;
	u_int nports, naddrs;

	/*
	 * Count ports and addresses.
	 */
	nports = 0;
	naddrs = 0;
	TAILQ_FOREACH(port, &cc->port_list, node_link) {
		if (portno == 0 || port->param.port == portno) {
			nports++;
			TAILQ_FOREACH(addr, &port->addr_list, port_link)
				naddrs++;
		}
	}

	/*
	 * Size and allocate message
	 */
	*lenp = sizeof(*list) + nports * sizeof(*pp) + naddrs * sizeof(*aa);

	list = CCZALLOC(*lenp);
	if (list == NULL)
		return (NULL);

	/*
	 * Fill the message.
	 */
	list->num_ports = nports;
	list->num_addrs = naddrs;

	pp = (void *)((u_char *)list + sizeof(*list));
	aa = (void *)((u_char *)list + sizeof(*list) + nports * sizeof(*pp));

	TAILQ_FOREACH(port, &cc->port_list, node_link) {
		if (portno == 0 || port->param.port == portno) {
			*pp = port->param;
			pp->num_addrs = 0;
			TAILQ_FOREACH(addr, &port->addr_list, port_link) {
				*aa++ = addr->addr;
				pp->num_addrs++;
			}
			pp++;
		}
	}

	return (list);
}

static struct ccreq *
find_cookie(struct ccport *port, u_int cookie)
{
	struct ccreq *r;

	TAILQ_FOREACH(r, &port->cookies, link)
		if (r->cookie == cookie)
			return (r);
	return (NULL);
}

/*
 * input a response from the UNI layer to CC
 */
int
cc_uni_response(struct ccport *port, u_int cookie, u_int reason, u_int state)
{
	struct ccconn *conn;
	struct ccreq *req;

	if (cookie == 0)
		return (EINVAL);

	if (port->admin != CCPORT_RUNNING)
		return (ENOTCONN);

	if ((req = find_cookie(port, cookie)) == NULL) {
		cc_port_log(port, "UNI response for unknown cookie %u", cookie);
		return (EINVAL);
	}
	conn = req->conn;

	TAILQ_REMOVE(&port->cookies, req, link);
	CCFREE(req);

	if (reason == UNIAPI_OK)
		return (cc_conn_resp(conn, CONN_SIG_OK,
		    cookie, reason, state));
	else
		return (cc_conn_resp(conn, CONN_SIG_ERROR,
		    cookie, reason, state));
}

static struct ccconn *
find_cref(const struct ccport *port, const struct uni_cref *cref)
{
	struct ccconn *conn;

	LIST_FOREACH(conn, &port->conn_list, port_link)
		if (conn->cref.cref == cref->cref &&
		    conn->cref.flag == cref->flag)
			return (conn);
	return (NULL);
}

/*
 * Signal from UNI on this port
 */
int
cc_uni_signal(struct ccport *port, u_int cookie, u_int sig, struct uni_msg *msg)
{
	int error = 0;
	size_t len, ilen = 0;
	struct uni_cref *cref;
	struct ccconn *conn;

	if (port->admin != CCPORT_RUNNING) {
		error = ENOTCONN;
		goto out;
	}
	len = (msg != NULL) ? uni_msg_len(msg) : 0;

	switch ((enum uni_sig)sig) {

	  case UNIAPI_ERROR:
		/* handled above */
		cc_port_log(port, "bad UNIAPI_ERROR cookie=%u", cookie);
		error = EINVAL;
		break;

	  case UNIAPI_CALL_CREATED:
		ilen = sizeof(struct uniapi_call_created);
		if (len != ilen)
			goto bad_len;

		if (cookie != 0) {
			/* outgoing call */
			struct ccreq *req;

			if ((req = find_cookie(port, cookie)) == NULL) {
				cc_port_log(port, "bad cookie %u in CREATE",
				    cookie);
				error = EINVAL;
				goto out;
			}
			conn = req->conn;

		} else {
			if ((conn = cc_conn_create(port->cc)) == NULL) {
				error = ENOMEM;
				goto out;
			}
			cc_conn_ins_port(conn, port);
		}

		cc_conn_sig_msg_nodef(conn, CONN_SIG_CREATED, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_CALL_DESTROYED:
		ilen = sizeof(struct uniapi_call_destroyed);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg, struct uniapi_call_destroyed *)->cref;
		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig(conn, CONN_SIG_DESTROYED, NULL);
		goto out;

	  case UNIAPI_LINK_ESTABLISH_confirm:
		goto out;

	  case UNIAPI_LINK_RELEASE_confirm:
		/* Ups. If we administratively up, restart the link */
		if (port->admin == CCPORT_RUNNING)
			port->cc->funcs->send_uni_glob(port, port->uarg,
			    UNIAPI_LINK_ESTABLISH_request, 0, NULL);
		goto out;

	  case UNIAPI_PARTY_CREATED:
		ilen = sizeof(struct uniapi_party_created);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg, struct uniapi_party_created *)->cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg_nodef(conn,
		     CONN_SIG_PARTY_CREATED, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_PARTY_DESTROYED:
		ilen = sizeof(struct uniapi_party_destroyed);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg,
		    struct uniapi_party_destroyed *)->cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_PARTY_DESTROYED, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_DROP_PARTY_ACK_indication:	/* UNI -> API */
		ilen = sizeof(struct uniapi_drop_party_ack_indication);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg,
		    struct uniapi_drop_party_ack_indication *)->drop.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_DROP_PARTY_ACK_IND, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_RESET_indication:			/* UNI -> API */
	    {
		/*
		 * XXX - do the right thing
		 */
		struct uniapi_reset_indication *ind = uni_msg_rptr(msg,
		    struct uniapi_reset_indication *);
		struct uniapi_reset_response *resp;
		struct uni_msg *u;
		
		/*
		 * Construct message to UNI.
		 */
		if ((u = uni_msg_alloc(sizeof(*resp))) == NULL)
			return (ENOMEM);

		resp = uni_msg_wptr(u, struct uniapi_reset_response *);
		memset(resp, 0, sizeof(*resp));
		u->b_wptr += sizeof(*resp);

		resp->restart = ind->restart;
		resp->connid = ind->connid;

		port->cc->funcs->send_uni_glob(port, port->uarg,
		    UNIAPI_RESET_response, 0, u);

		goto out;
	    }

	  case UNIAPI_RELEASE_indication:		/* UNI -> API */
		ilen = sizeof(struct uniapi_release_indication);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg, struct uniapi_release_indication *)
		    ->release.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_REL_IND, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_RELEASE_confirm:			/* UNI -> API */
		ilen = sizeof(struct uniapi_release_confirm);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg, struct uniapi_release_confirm *)
		    ->release.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_REL_CONF, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_SETUP_confirm:			/* UNI -> API */
		ilen = sizeof(struct uniapi_setup_confirm);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg, struct uniapi_setup_confirm *)
		    ->connect.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_SETUP_CONFIRM, msg);
		msg = NULL;
		goto out;


	  case UNIAPI_ALERTING_indication:		/* UNI -> API */
		ilen = sizeof(struct uniapi_alerting_indication);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg, struct uniapi_alerting_indication *)
		    ->alerting.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_ALERTING_IND, msg);
		msg = NULL;
		goto out;


	  case UNIAPI_PROCEEDING_indication:		/* UNI -> API */
		ilen = sizeof(struct uniapi_proceeding_indication);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg, struct uniapi_proceeding_indication *)
		    ->call_proc.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_PROC_IND, msg);
		msg = NULL;
		goto out;


	  case UNIAPI_SETUP_indication:			/* UNI -> API */
		ilen = sizeof(struct uniapi_setup_indication);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg, struct uniapi_setup_indication *)
		    ->setup.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_SETUP_IND, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_SETUP_COMPLETE_indication:	/* UNI -> API */
		ilen = sizeof(struct uniapi_setup_complete_indication);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg,
		    struct uniapi_setup_complete_indication *)
		    ->connect_ack.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_SETUP_COMPL, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_PARTY_ALERTING_indication:	/* UNI -> API */
		ilen = sizeof(struct uniapi_party_alerting_indication);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg,
		    struct uniapi_party_alerting_indication *)->alert.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_PARTY_ALERTING_IND, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_ADD_PARTY_ACK_indication:		/* UNI -> API */
		ilen = sizeof(struct uniapi_add_party_ack_indication);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg,
		    struct uniapi_add_party_ack_indication *)->ack.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_PARTY_ADD_ACK_IND, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_ADD_PARTY_REJ_indication:		/* UNI -> API */
		ilen = sizeof(struct uniapi_add_party_rej_indication);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg,
		    struct uniapi_add_party_rej_indication *)->rej.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_PARTY_ADD_REJ_IND, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_DROP_PARTY_indication:		/* UNI -> API */
		ilen = sizeof(struct uniapi_drop_party_indication);
		if (len != ilen)
			goto bad_len;

		cref = &uni_msg_rptr(msg, struct uniapi_drop_party_indication *)
		    ->drop.hdr.cref;

		if ((conn = find_cref(port, cref)) == NULL)
			goto unk_call;

		error = cc_conn_sig_msg(conn, CONN_SIG_DROP_PARTY_IND, msg);
		msg = NULL;
		goto out;

	  case UNIAPI_RESET_confirm:			/* UNI -> API */
	  case UNIAPI_RESET_ERROR_indication:		/* UNI -> API */
	  case UNIAPI_RESET_STATUS_indication:		/* UNI -> API */
		/* XXX */
		goto out;

	  case UNIAPI_NOTIFY_indication:		/* UNI -> API */
	  case UNIAPI_STATUS_indication:		/* UNI -> API */
		break;

	  case UNIAPI_ADD_PARTY_indication:		/* UNI -> API */
		/* not supported by the API */
		break;

	/*
	 * All these are illegal in this direction
	 */
	  case UNIAPI_LINK_ESTABLISH_request:		/* API -> UNI */
	  case UNIAPI_LINK_RELEASE_request:		/* API -> UNI */
	  case UNIAPI_RESET_request:			/* API -> UNI */
	  case UNIAPI_RESET_response:			/* API -> UNI */
	  case UNIAPI_RESET_ERROR_response:		/* API -> UNI */
	  case UNIAPI_SETUP_request:			/* API -> UNI */
	  case UNIAPI_SETUP_response:			/* API -> UNI */
	  case UNIAPI_ALERTING_request:			/* API -> UNI */
	  case UNIAPI_PROCEEDING_request:		/* API -> UNI */
	  case UNIAPI_RELEASE_request:			/* API -> UNI */
	  case UNIAPI_RELEASE_response:			/* API -> UNI */
	  case UNIAPI_NOTIFY_request:			/* API -> UNI */
	  case UNIAPI_STATUS_ENQUIRY_request:		/* API -> UNI */
	  case UNIAPI_ADD_PARTY_request:		/* API -> UNI */
	  case UNIAPI_PARTY_ALERTING_request:		/* API -> UNI */
	  case UNIAPI_ADD_PARTY_ACK_request:		/* API -> UNI */
	  case UNIAPI_ADD_PARTY_REJ_request:		/* API -> UNI */
	  case UNIAPI_DROP_PARTY_request:		/* API -> UNI */
	  case UNIAPI_DROP_PARTY_ACK_request:		/* API -> UNI */
	  case UNIAPI_ABORT_CALL_request:		/* API -> UNI */
	  case UNIAPI_SETUP_COMPLETE_request:		/* API -> UNI */
	  case UNIAPI_MAXSIG:
		break;
	}
	cc_port_log(port, "bad signal %u", sig);
	error = EINVAL;
	goto out;

  bad_len:
	cc_port_log(port, "signal %u bad length: %zu, need %zu", len, ilen);
	error = EINVAL;
	goto out;

  unk_call:
	cc_port_log(port, "unknown call %u/%u", cref->cref, cref->flag);
	error = EINVAL;

  out:
	if (msg != NULL)
		uni_msg_destroy(msg);
	return (error);
}