cmhi
/
f-stack
mirror of https://github.com/F-Stack/f-stack.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
f-stack/freebsd/contrib/ngatm/netnatm/api/cc_user.c

1923 lines
42 KiB
C
Raw Permalink Blame History

/*
* 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_user.c,v 1.3 2004/07/16 18:46:55 brandt Exp $
*
* ATM API as defined per af-saa-0108
*
* User side (upper half)
*/
#include <netnatm/unimsg.h>
#include <netnatm/msg/unistruct.h>
#include <netnatm/msg/unimsglib.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>
/*
* This file handles messages to a USER.
*/
static const char *stab[] = {
#define DEF(N) [N] = #N,
USER_STATES
#undef DEF
};
const char *
cc_user_state2str(u_int s)
{
if (s >= sizeof(stab) / sizeof(stab[0]) || stab[s] == NULL)
return ("?");
return (stab[s]);
}
static __inline void
set_state(struct ccuser *user, enum user_state ns)
{
if (user->state != ns) {
if (user->cc->log & CCLOG_USER_STATE)
cc_user_log(user, "%s -> %s",
stab[user->state], stab[ns]);
user->state = ns;
}
}
static __inline void
cc_user_send(struct ccuser *user, u_int op, void *arg, size_t len)
{
user->cc->funcs->send_user(user, user->uarg, op, arg, len);
}
static __inline void
cc_user_ok(struct ccuser *user, u_int data, void *arg, size_t len)
{
user->cc->funcs->respond_user(user, user->uarg,
ATMERR_OK, data, arg, len);
}
static __inline void
cc_user_err(struct ccuser *user, int err)
{
user->cc->funcs->respond_user(user, user->uarg,
err, ATMRESP_NONE, NULL, 0);
}
/**********************************************************************
*
* INSTANCE MANAGEMENT
*/
/*
* New endpoint created
*/
struct ccuser *
cc_user_create(struct ccdata *cc, void *uarg, const char *name)
{
struct ccuser *user;
user = CCZALLOC(sizeof(*user));
if (user == NULL)
return (NULL);
user->cc = cc;
user->state = USER_NULL;
user->uarg = uarg;
strncpy(user->name, name, sizeof(user->name));
user->name[sizeof(user->name) - 1] = '\0';
TAILQ_INIT(&user->connq);
LIST_INSERT_HEAD(&cc->user_list, user, node_link);
if (user->cc->log & CCLOG_USER_INST)
cc_user_log(user, "created with name '%s'", name);
return (user);
}
/*
* Reset a user instance
*/
static void
cc_user_reset(struct ccuser *user)
{
CCASSERT(TAILQ_EMPTY(&user->connq), ("connq not empty"));
if (user->sap != NULL) {
CCFREE(user->sap);
user->sap = NULL;
}
if (user->accepted != NULL) {
user->accepted->acceptor = NULL;
user->accepted = NULL;
}
user->config = USER_P2P;
user->queue_act = 0;
user->queue_max = 0;
user->aborted = 0;
set_state(user, USER_NULL);
cc_user_sig_flush(user);
}
static void
cc_user_abort(struct ccuser *user, const struct uni_ie_cause *cause)
{
struct ccconn *conn;
/*
* Although the standard state that 'all connections
* associated with this endpoint are aborted' we only
* have to abort the head one, because in state A6
* (call present) the endpoint is only associated to the
* head connection - the others are 'somewhere else' and
* need to be redispatched.
*
* First bring user into a state that the connections
* are not dispatched back to it.
*/
set_state(user, USER_NULL);
if (!user->aborted) {
if ((conn = TAILQ_FIRST(&user->connq)) != NULL) {
memset(conn->cause, 0, sizeof(conn->cause));
if (cause != NULL)
conn->cause[0] = *cause;
cc_conn_reset_acceptor(conn);
cc_disconnect_from_user(conn);
cc_conn_sig(conn, CONN_SIG_USER_ABORT, NULL);
}
}
while ((conn = TAILQ_FIRST(&user->connq)) != NULL) {
/* these should be in C21 */
cc_disconnect_from_user(conn);
cc_conn_dispatch(conn);
}
cc_user_reset(user);
}
/*
* Application has closed this endpoint. Clean up all user resources and
* abort all connections. This can be called in any state.
*/
void
cc_user_destroy(struct ccuser *user)
{
if (user->cc->log & CCLOG_USER_INST)
cc_user_log(user, "destroy '%s'", user->name);
cc_user_abort(user, NULL);
if (user->sap != NULL)
CCFREE(user->sap);
cc_user_sig_flush(user);
LIST_REMOVE(user, node_link);
CCFREE(user);
}
/**********************************************************************
*
* OUTGOING CALLS
*/
/*
* Return true when the calling address of the connection matches the address.
*/
static int
addr_matches(const struct ccaddr *addr, const struct ccconn *conn)
{
if (!IE_ISPRESENT(conn->calling))
return (0);
return (addr->addr.type == conn->calling.addr.type &&
addr->addr.plan == conn->calling.addr.plan &&
addr->addr.len == conn->calling.addr.len &&
memcmp(addr->addr.addr, conn->calling.addr.addr,
addr->addr.len) == 0);
}
/*
* Check if the user's SAP (given he is in the right state) and
* the given SAP overlap
*/
static int
check_overlap(struct ccuser *user, struct uni_sap *sap)
{
return ((user->state == USER_IN_PREPARING ||
user->state == USER_IN_WAITING) &&
unisve_overlap_sap(user->sap, sap));
}
/*
* Send arrival notification to user
*/
static void
do_arrival(struct ccuser *user)
{
struct ccconn *conn;
user->aborted = 0;
if ((conn = TAILQ_FIRST(&user->connq)) != NULL) {
set_state(user, USER_IN_ARRIVED);
cc_user_send(user, ATMOP_ARRIVAL_OF_INCOMING_CALL, NULL, 0);
cc_conn_sig(conn, CONN_SIG_ARRIVAL, NULL);
}
}
/**********************************************************************
*
* ATTRIBUTES
*/
/*
* Query an attribute. This is possible only in some states: preparation
* of an outgoing call, after an incoming call was offered to the application
* and in the three active states (P2P, P2PLeaf, P2PRoot).
*/
static struct ccconn *
cc_query_check(struct ccuser *user)
{
switch (user->state) {
case USER_OUT_PREPARING:
case USER_IN_ARRIVED:
case USER_ACTIVE:
return (TAILQ_FIRST(&user->connq));
case USER_NULL:
/* if we are waiting for the SETUP_confirm, we are in
* the NULL state still (we are the new endpoint), but
* have a connection in 'accepted' that is in the
* CONN_IN_WAIT_ACCEPT_OK state.
*/
if (user->accepted != NULL &&
user->accepted->state == CONN_IN_WAIT_ACCEPT_OK)
return (user->accepted);
/* FALLTHRU */
default:
return (NULL);
}
}
/*
* Query attributes
*/
static void
cc_attr_query(struct ccuser *user, struct ccconn *conn,
uint32_t *attr, u_int count)
{
void *val, *ptr;
size_t total, len;
u_int i;
uint32_t *atab;
/* determine the length of the total attribute buffer */
total = sizeof(uint32_t) + count * sizeof(uint32_t);
for (i = 0; i < count; i++) {
len = 0;
switch ((enum atm_attribute)attr[i]) {
case ATM_ATTR_NONE:
break;
case ATM_ATTR_BLLI_SELECTOR:
len = sizeof(uint32_t);
break;
case ATM_ATTR_BLLI:
len = sizeof(struct uni_ie_blli);
break;
case ATM_ATTR_BEARER:
len = sizeof(struct uni_ie_bearer);
break;
case ATM_ATTR_TRAFFIC:
len = sizeof(struct uni_ie_traffic);
break;
case ATM_ATTR_QOS:
len = sizeof(struct uni_ie_qos);
break;
case ATM_ATTR_EXQOS:
len = sizeof(struct uni_ie_exqos);
break;
case ATM_ATTR_CALLED:
len = sizeof(struct uni_ie_called);
break;
case ATM_ATTR_CALLEDSUB:
len = sizeof(struct uni_ie_calledsub);
break;
case ATM_ATTR_CALLING:
len = sizeof(struct uni_ie_calling);
break;
case ATM_ATTR_CALLINGSUB:
len = sizeof(struct uni_ie_callingsub);
break;
case ATM_ATTR_AAL:
len = sizeof(struct uni_ie_aal);
break;
case ATM_ATTR_EPREF:
len = sizeof(struct uni_ie_epref);
break;
case ATM_ATTR_CONNED:
len = sizeof(struct uni_ie_conned);
break;
case ATM_ATTR_CONNEDSUB:
len = sizeof(struct uni_ie_connedsub);
break;
case ATM_ATTR_EETD:
len = sizeof(struct uni_ie_eetd);
break;
case ATM_ATTR_ABRSETUP:
len = sizeof(struct uni_ie_abrsetup);
break;
case ATM_ATTR_ABRADD:
len = sizeof(struct uni_ie_abradd);
break;
case ATM_ATTR_CONNID:
len = sizeof(struct uni_ie_connid);
break;
case ATM_ATTR_MDCR:
len = sizeof(struct uni_ie_mdcr);
break;
}
if (len == 0) {
cc_user_err(user, ATMERR_BAD_ATTR);
return;
}
total += len;
}
/* allocate buffer */
val = CCMALLOC(total);
if (val == NULL)
return;
atab = val;
atab[0] = count;
/* fill */
ptr = (u_char *)val + (sizeof(uint32_t) + count * sizeof(uint32_t));
for (i = 0; i < count; i++) {
len = 0;
atab[i + 1] = attr[i];
switch (attr[i]) {
case ATM_ATTR_NONE:
break;
case ATM_ATTR_BLLI_SELECTOR:
len = sizeof(uint32_t);
memcpy(ptr, &conn->blli_selector, len);
break;
case ATM_ATTR_BLLI:
/* in A6 the blli_selector may be 0 when
* there was no blli in the SETUP.
*/
len = sizeof(struct uni_ie_blli);
if (conn->blli_selector == 0)
memset(ptr, 0, len);
else
memcpy(ptr, &conn->blli[conn->blli_selector -
1], len);
break;
case ATM_ATTR_BEARER:
len = sizeof(struct uni_ie_bearer);
memcpy(ptr, &conn->bearer, len);
break;
case ATM_ATTR_TRAFFIC:
len = sizeof(struct uni_ie_traffic);
memcpy(ptr, &conn->traffic, len);
break;
case ATM_ATTR_QOS:
len = sizeof(struct uni_ie_qos);
memcpy(ptr, &conn->qos, len);
break;
case ATM_ATTR_EXQOS:
len = sizeof(struct uni_ie_exqos);
memcpy(ptr, &conn->exqos, len);
break;
case ATM_ATTR_CALLED:
len = sizeof(struct uni_ie_called);
memcpy(ptr, &conn->called, len);
break;
case ATM_ATTR_CALLEDSUB:
len = sizeof(struct uni_ie_calledsub);
memcpy(ptr, &conn->calledsub, len);
break;
case ATM_ATTR_CALLING:
len = sizeof(struct uni_ie_calling);
memcpy(ptr, &conn->calling, len);
break;
case ATM_ATTR_CALLINGSUB:
len = sizeof(struct uni_ie_callingsub);
memcpy(ptr, &conn->callingsub, len);
break;
case ATM_ATTR_AAL:
len = sizeof(struct uni_ie_aal);
memcpy(ptr, &conn->aal, len);
break;
case ATM_ATTR_EPREF:
len = sizeof(struct uni_ie_epref);
memcpy(ptr, &conn->epref, len);
break;
case ATM_ATTR_CONNED:
len = sizeof(struct uni_ie_conned);
memcpy(ptr, &conn->conned, len);
break;
case ATM_ATTR_CONNEDSUB:
len = sizeof(struct uni_ie_connedsub);
memcpy(ptr, &conn->connedsub, len);
break;
case ATM_ATTR_EETD:
len = sizeof(struct uni_ie_eetd);
memcpy(ptr, &conn->eetd, len);
break;
case ATM_ATTR_ABRSETUP:
len = sizeof(struct uni_ie_abrsetup);
memcpy(ptr, &conn->abrsetup, len);
break;
case ATM_ATTR_ABRADD:
len = sizeof(struct uni_ie_abradd);
memcpy(ptr, &conn->abradd, len);
break;
case ATM_ATTR_CONNID:
len = sizeof(struct uni_ie_connid);
memcpy(ptr, &conn->connid, len);
break;
case ATM_ATTR_MDCR:
len = sizeof(struct uni_ie_mdcr);
memcpy(ptr, &conn->mdcr, len);
break;
}
ptr = (u_char *)ptr + len;
}
cc_user_ok(user, ATMRESP_ATTRS, val, total);
CCFREE(val);
}
/*
* Check whether the state is ok and return the connection
*/
static struct ccconn *
cc_set_check(struct ccuser *user)
{
switch(user->state) {
case USER_OUT_PREPARING:
case USER_IN_ARRIVED:
return (TAILQ_FIRST(&user->connq));
default:
return (NULL);
}
}
/*
* Set connection attribute(s)
*/
static void
cc_attr_set(struct ccuser *user, struct ccconn *conn, uint32_t *attr,
u_int count, u_char *val, size_t vallen)
{
size_t total, len;
u_int i;
u_char *ptr;
/* determine the length of the total attribute buffer */
total = 0;
ptr = val;
for (i = 0; i < count; i++) {
len = 0;
switch ((enum atm_attribute)attr[i]) {
case ATM_ATTR_NONE:
break;
case ATM_ATTR_BLLI_SELECTOR:
{
uint32_t sel;
if (conn->state != CONN_OUT_PREPARING)
goto rdonly;
memcpy(&sel, ptr, sizeof(sel));
if (sel == 0 || sel > UNI_NUM_IE_BLLI)
goto bad_val;
len = sizeof(uint32_t);
break;
}
case ATM_ATTR_BLLI:
len = sizeof(struct uni_ie_blli);
break;
case ATM_ATTR_BEARER:
if (conn->state != CONN_OUT_PREPARING)
goto rdonly;
len = sizeof(struct uni_ie_bearer);
break;
case ATM_ATTR_TRAFFIC:
len = sizeof(struct uni_ie_traffic);
break;
case ATM_ATTR_QOS:
if (conn->state != CONN_OUT_PREPARING)
goto rdonly;
len = sizeof(struct uni_ie_qos);
break;
case ATM_ATTR_EXQOS:
len = sizeof(struct uni_ie_exqos);
break;
case ATM_ATTR_CALLED:
goto rdonly;
case ATM_ATTR_CALLEDSUB:
if (conn->state != CONN_OUT_PREPARING)
goto rdonly;
len = sizeof(struct uni_ie_calledsub);
break;
case ATM_ATTR_CALLING:
if (conn->state != CONN_OUT_PREPARING)
goto rdonly;
len = sizeof(struct uni_ie_calling);
break;
case ATM_ATTR_CALLINGSUB:
if (conn->state != CONN_OUT_PREPARING)
goto rdonly;
len = sizeof(struct uni_ie_callingsub);
break;
case ATM_ATTR_AAL:
len = sizeof(struct uni_ie_aal);
break;
case ATM_ATTR_EPREF:
goto rdonly;
case ATM_ATTR_CONNED:
goto rdonly;
case ATM_ATTR_CONNEDSUB:
goto rdonly;
case ATM_ATTR_EETD:
len = sizeof(struct uni_ie_eetd);
break;
case ATM_ATTR_ABRSETUP:
len = sizeof(struct uni_ie_abrsetup);
break;
case ATM_ATTR_ABRADD:
len = sizeof(struct uni_ie_abradd);
break;
case ATM_ATTR_CONNID:
len = sizeof(struct uni_ie_connid);
break;
case ATM_ATTR_MDCR:
if (conn->state != CONN_OUT_PREPARING)
goto rdonly;
len = sizeof(struct uni_ie_mdcr);
break;
}
if (len == 0) {
cc_user_err(user, ATMERR_BAD_ATTR);
return;
}
total += len;
ptr += len;
}
/* check the length */
if (vallen != total) {
cc_user_err(user, ATMERR_BAD_ARGS);
return;
}
ptr = val;
for (i = 0; i < count; i++) {
len = 0;
switch ((enum atm_attribute)attr[i]) {
case ATM_ATTR_NONE:
break;
case ATM_ATTR_BLLI_SELECTOR:
{
uint32_t sel;
memcpy(&sel, ptr, sizeof(sel));
conn->blli_selector = sel;
len = sizeof(uint32_t);
break;
}
case ATM_ATTR_BLLI:
len = sizeof(struct uni_ie_blli);
memcpy(&conn->blli[conn->blli_selector - 1], ptr, len);
conn->dirty_attr |= CCDIRTY_BLLI;
break;
case ATM_ATTR_BEARER:
len = sizeof(struct uni_ie_bearer);
memcpy(&conn->bearer, ptr, len);
break;
case ATM_ATTR_TRAFFIC:
len = sizeof(struct uni_ie_traffic);
memcpy(&conn->traffic, ptr, len);
conn->dirty_attr |= CCDIRTY_TRAFFIC;
break;
case ATM_ATTR_QOS:
len = sizeof(struct uni_ie_qos);
memcpy(&conn->qos, ptr, len);
break;
case ATM_ATTR_EXQOS:
len = sizeof(struct uni_ie_exqos);
memcpy(&conn->exqos, ptr, len);
conn->dirty_attr |= CCDIRTY_EXQOS;
break;
case ATM_ATTR_CALLED:
len = sizeof(struct uni_ie_called);
break;
case ATM_ATTR_CALLEDSUB:
len = sizeof(struct uni_ie_calledsub);
memcpy(&conn->calledsub, ptr, len);
break;
case ATM_ATTR_CALLING:
len = sizeof(struct uni_ie_calling);
memcpy(&conn->calling, ptr, len);
break;
case ATM_ATTR_CALLINGSUB:
len = sizeof(struct uni_ie_callingsub);
memcpy(&conn->callingsub, ptr, len);
break;
case ATM_ATTR_AAL:
len = sizeof(struct uni_ie_aal);
memcpy(&conn->aal, ptr, len);
conn->dirty_attr |= CCDIRTY_AAL;
break;
case ATM_ATTR_EPREF:
len = sizeof(struct uni_ie_epref);
break;
case ATM_ATTR_CONNED:
len = sizeof(struct uni_ie_conned);
break;
case ATM_ATTR_CONNEDSUB:
len = sizeof(struct uni_ie_connedsub);
break;
case ATM_ATTR_EETD:
len = sizeof(struct uni_ie_eetd);
memcpy(&conn->eetd, ptr, len);
conn->dirty_attr |= CCDIRTY_EETD;
break;
case ATM_ATTR_ABRSETUP:
len = sizeof(struct uni_ie_abrsetup);
memcpy(&conn->abrsetup, ptr, len);
conn->dirty_attr |= CCDIRTY_ABRSETUP;
break;
case ATM_ATTR_ABRADD:
len = sizeof(struct uni_ie_abradd);
memcpy(&conn->abradd, ptr, len);
conn->dirty_attr |= CCDIRTY_ABRADD;
break;
case ATM_ATTR_CONNID:
len = sizeof(struct uni_ie_connid);
memcpy(&conn->connid, ptr, len);
conn->dirty_attr |= CCDIRTY_CONNID;
break;
case ATM_ATTR_MDCR:
len = sizeof(struct uni_ie_mdcr);
memcpy(&conn->mdcr, ptr, len);
break;
}
ptr += len;
}
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
return;
bad_val:
cc_user_err(user, ATMERR_BAD_VALUE);
return;
rdonly:
cc_user_err(user, ATMERR_RDONLY);
return;
}
#ifdef CCATM_DEBUG
static const char *op_names[] = {
#define S(OP) [ATMOP_##OP] = #OP
S(RESP),
S(ABORT_CONNECTION),
S(ACCEPT_INCOMING_CALL),
S(ADD_PARTY),
S(ADD_PARTY_REJECT),
S(ADD_PARTY_SUCCESS),
S(ARRIVAL_OF_INCOMING_CALL),
S(CALL_RELEASE),
S(CONNECT_OUTGOING_CALL),
S(DROP_PARTY),
S(GET_LOCAL_PORT_INFO),
S(P2MP_CALL_ACTIVE),
S(P2P_CALL_ACTIVE),
S(PREPARE_INCOMING_CALL),
S(PREPARE_OUTGOING_CALL),
S(QUERY_CONNECTION_ATTRIBUTES),
S(REJECT_INCOMING_CALL),
S(SET_CONNECTION_ATTRIBUTES),
S(WAIT_ON_INCOMING_CALL),
S(SET_CONNECTION_ATTRIBUTES_X),
S(QUERY_CONNECTION_ATTRIBUTES_X),
S(QUERY_STATE),
#undef S
};
#endif
/*
* Signal from user - map this to our internal signals and queue
* the mapped signal.
*/
int
cc_user_signal(struct ccuser *user, enum atmop sig, struct uni_msg *msg)
{
size_t len = uni_msg_len(msg);
int err = EINVAL;
if (user->cc->log & CCLOG_USER_SIG)
cc_user_log(user, "signal %s to user", op_names[sig]);
if ((u_int)sig > ATMOP_QUERY_STATE)
goto bad_signal;
switch (sig) {
case ATMOP_ABORT_CONNECTION:
if (len != sizeof(struct atm_abort_connection))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_ABORT_CONNECTION, msg);
break;
case ATMOP_ACCEPT_INCOMING_CALL:
if (len != sizeof(struct atm_accept_incoming_call))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_ACCEPT_INCOMING, msg);
break;
case ATMOP_ADD_PARTY:
if (len != sizeof(struct atm_add_party))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_ADD_PARTY, msg);
break;
case ATMOP_CALL_RELEASE:
if (len != sizeof(struct atm_call_release))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_CALL_RELEASE, msg);
break;
case ATMOP_CONNECT_OUTGOING_CALL:
if (len != sizeof(struct atm_connect_outgoing_call))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_CONNECT_OUTGOING, msg);
break;
case ATMOP_DROP_PARTY:
if (len != sizeof(struct atm_drop_party))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_DROP_PARTY, msg);
break;
case ATMOP_GET_LOCAL_PORT_INFO:
if (len != sizeof(struct atm_get_local_port_info))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_GET_LOCAL_PORT_INFO, msg);
break;
case ATMOP_PREPARE_INCOMING_CALL:
if (len != sizeof(struct atm_prepare_incoming_call))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_PREPARE_INCOMING, msg);
break;
case ATMOP_PREPARE_OUTGOING_CALL:
if (len != 0)
goto bad_len;
uni_msg_destroy(msg);
err = cc_user_sig(user, USER_SIG_PREPARE_OUTGOING, NULL, 0);
break;
case ATMOP_QUERY_CONNECTION_ATTRIBUTES:
if (len != sizeof(struct atm_query_connection_attributes))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_QUERY_ATTR, msg);
break;
case ATMOP_REJECT_INCOMING_CALL:
if (len != sizeof(struct atm_reject_incoming_call))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_REJECT_INCOMING, msg);
break;
case ATMOP_SET_CONNECTION_ATTRIBUTES:
if (len < sizeof(struct atm_set_connection_attributes))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_SET_ATTR, msg);
break;
case ATMOP_WAIT_ON_INCOMING_CALL:
if (len != 0)
goto bad_len;
uni_msg_destroy(msg);
err = cc_user_sig(user, USER_SIG_WAIT_ON_INCOMING, NULL, 0);
break;
case ATMOP_QUERY_CONNECTION_ATTRIBUTES_X:
if (len < sizeof(struct atm_set_connection_attributes_x) ||
len != offsetof(struct atm_set_connection_attributes_x,
attr) + uni_msg_rptr(msg,
struct atm_set_connection_attributes_x *)->count *
sizeof(uint32_t))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_QUERY_ATTR_X, msg);
break;
case ATMOP_SET_CONNECTION_ATTRIBUTES_X:
if (len < sizeof(struct atm_set_connection_attributes_x))
goto bad_len;
err = cc_user_sig_msg(user, USER_SIG_SET_ATTR_X, msg);
break;
case ATMOP_QUERY_STATE:
if (len != 0)
goto bad_len;
uni_msg_destroy(msg);
err = cc_user_sig(user, USER_SIG_QUERY_STATE, NULL, 0);
break;
case ATMOP_RESP:
case ATMOP_ADD_PARTY_REJECT:
case ATMOP_ADD_PARTY_SUCCESS:
case ATMOP_ARRIVAL_OF_INCOMING_CALL:
case ATMOP_P2MP_CALL_ACTIVE:
case ATMOP_P2P_CALL_ACTIVE:
bad_signal:
/* bad signal */
if (user->cc->log & CCLOG_USER_SIG)
cc_user_log(user, "bad signal %u", sig);
cc_user_err(user, ATMERR_BAD_OP);
uni_msg_destroy(msg);
break;
}
return (err);
bad_len:
/* bad argument length */
if (user->cc->log & CCLOG_USER_SIG)
cc_user_log(user, "signal %s had bad len=%zu",
op_names[sig], len);
cc_user_err(user, ATMERR_BAD_ARGS);
uni_msg_destroy(msg);
return (EINVAL);
}
/*
* Send active signal to user
*/
static void
cc_user_active(struct ccuser *user)
{
struct ccconn *conn = TAILQ_FIRST(&user->connq);
set_state(user, USER_ACTIVE);
if (conn->bearer.cfg == UNI_BEARER_P2P) {
struct atm_p2p_call_active *act;
user->config = USER_P2P;
act = CCZALLOC(sizeof(*act));
if (act == NULL)
return;
act->connid = conn->connid;
cc_user_send(user, ATMOP_P2P_CALL_ACTIVE, act, sizeof(*act));
CCFREE(act);
} else {
struct atm_p2mp_call_active *act;
user->config = USER_ROOT;
act = CCZALLOC(sizeof(*act));
if (act == NULL)
return;
act->connid = conn->connid;
cc_user_send(user, ATMOP_P2MP_CALL_ACTIVE, act, sizeof(*act));
CCFREE(act);
}
}
/*
* Handle a signal to this user
*/
void
cc_user_sig_handle(struct ccuser *user, enum user_sig sig,
void *arg, u_int arg2)
{
if (user->cc->log & CCLOG_USER_SIG)
cc_user_log(user, "signal %s to user state %s",
cc_user_sigtab[sig], stab[user->state]);
switch (sig) {
case USER_SIG_PREPARE_OUTGOING:
{
/*
* Here we create a connection for the call we soon will make.
* We put this call on the list of orphaned connections,
* because we don't know yet, which port will get the
* connection. It is assigned, when the user issues the call
* to connect.
*/
struct ccconn *conn;
if (user->state != USER_NULL) {
cc_user_err(user, ATMERR_BAD_STATE);
goto bad_state;
}
conn = cc_conn_create(user->cc);
if (conn == NULL) {
cc_user_err(user, ATMERR_NOMEM);
return;
}
set_state(user, USER_OUT_PREPARING);
cc_conn_set_state(conn, CONN_OUT_PREPARING);
conn->blli_selector = 1;
cc_connect_to_user(conn, user);
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
return;
}
case USER_SIG_CONNECT_OUTGOING:
{
/*
* Request to connect that call
*
* Here we assign the connection to a port.
*/
struct uni_msg *msg = arg;
struct atm_connect_outgoing_call *req = uni_msg_rptr(msg,
struct atm_connect_outgoing_call *);
struct ccdata *priv = user->cc;
struct ccport *port;
struct ccaddr *addr;
struct ccconn *conn = TAILQ_FIRST(&user->connq);
if (user->state != USER_OUT_PREPARING) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_STATE);
goto bad_state;
}
if (!IE_ISPRESENT(req->called)) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_ARGS);
return;
}
CCASSERT(conn->port == NULL, ("connection still on port"));
if (TAILQ_EMPTY(&priv->port_list)) {
/*
* We have no ports - reject
*/
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_PORT);
return;
}
/*
* Find the correct port
* Routing of outgoing calls goes to the lowest numbered port
* with a matching address or, if no address match is found to
* the lowest numbered port.
*/
TAILQ_FOREACH(port, &priv->port_list, node_link)
TAILQ_FOREACH(addr, &port->addr_list, port_link)
if (addr_matches(addr, conn))
break;
if (port == NULL)
port = TAILQ_FIRST(&priv->port_list);
cc_conn_ins_port(conn, port);
conn->called = req->called;
uni_msg_destroy(msg);
/*
* Now move the state
*/
set_state(user, USER_OUT_WAIT_OK);
cc_conn_sig(conn, CONN_SIG_CONNECT_OUTGOING, NULL);
return;
}
case USER_SIG_CONNECT_OUTGOING_ERR:
switch (user->state) {
case USER_OUT_WAIT_OK:
set_state(user, USER_OUT_PREPARING);
cc_user_err(user, arg2);
break;
case USER_REL_WAIT_CONN:
{
struct ccconn *conn;
conn = TAILQ_FIRST(&user->connq);
if (conn != NULL) {
cc_disconnect_from_user(conn);
cc_conn_destroy(conn);
}
cc_user_reset(user);
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
break;
}
default:
goto bad_state;
}
return;
case USER_SIG_CONNECT_OUTGOING_OK:
switch (user->state) {
case USER_OUT_WAIT_OK:
set_state(user, USER_OUT_WAIT_CONF);
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
break;
case USER_REL_WAIT_CONN:
set_state(user, USER_REL_WAIT_SCONF);
break;
default:
goto bad_state;
}
return;
case USER_SIG_SETUP_CONFIRM:
/*
* SETUP.confirm from UNI stack.
*/
switch (user->state) {
case USER_OUT_WAIT_CONF:
cc_user_active(user);
break;
case USER_REL_WAIT_SCONF:
/* now try to release */
set_state(user, USER_REL_WAIT_CONF);
cc_conn_sig(TAILQ_FIRST(&user->connq),
CONN_SIG_RELEASE, NULL);
break;
default:
goto bad_state;
}
return;
case USER_SIG_PREPARE_INCOMING:
{
struct uni_msg *msg = arg;
struct ccuser *ptr;
struct atm_prepare_incoming_call *prep = uni_msg_rptr(msg,
struct atm_prepare_incoming_call *);
if (user->state != USER_NULL) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_STATE);
goto bad_state;
}
/*
* Check the SAP
*/
if (unisve_check_sap(&prep->sap) != UNISVE_OK) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_SAP);
return;
}
/*
* Loop through all incoming calls and check whether there
* is an overlap in SAP space.
*/
LIST_FOREACH(ptr, &user->cc->user_list, node_link) {
if (check_overlap(ptr, &prep->sap)) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_OVERLAP);
return;
}
}
/*
* Save info and set state
*/
user->sap = CCZALLOC(sizeof(struct uni_sap));
if (user->sap == NULL) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_NOMEM);
return;
}
*user->sap = prep->sap;
user->queue_max = prep->queue_size;
user->queue_act = 0;
uni_msg_destroy(msg);
set_state(user, USER_IN_PREPARING);
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
return;
}
case USER_SIG_WAIT_ON_INCOMING:
if (user->state != USER_IN_PREPARING) {
cc_user_err(user, ATMERR_BAD_STATE);
goto bad_state;
}
set_state(user, USER_IN_WAITING);
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
return;
case USER_SIG_SETUP_IND:
/*
* New connection queued up in the queue. If this is the
* first one, inform the application of the arrival.
*/
switch (user->state) {
case USER_IN_WAITING:
do_arrival(user);
break;
case USER_IN_ARRIVED:
case USER_IN_WAIT_REJ:
case USER_IN_WAIT_ACC:
break;
default:
goto bad_state;
}
return;
case USER_SIG_REJECT_INCOMING:
{
/*
* User rejects call. This is done on the OLD user
* (i.e. the one sending the arrival).
*/
struct uni_msg *msg = arg;
struct atm_reject_incoming_call *rej = uni_msg_rptr(msg,
struct atm_reject_incoming_call *);
struct ccconn *conn = TAILQ_FIRST(&user->connq);
if (user->state != USER_IN_ARRIVED) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_STATE);
goto bad_state;
}
if (user->aborted) {
/* connection has disappeared. Send an ok
* to the user and lock whether there is another
* connection at this endpoint */
uni_msg_destroy(msg);
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
set_state(user, USER_IN_WAITING);
do_arrival(user);
return;
}
conn->cause[0] = rej->cause;
memset(&conn->cause[1], 0, sizeof(conn->cause[1]));
uni_msg_destroy(msg);
set_state(user, USER_IN_WAIT_REJ);
cc_conn_sig(conn, CONN_SIG_REJECT, NULL);
return;
}
case USER_SIG_REJECT_OK:
if (user->state != USER_IN_WAIT_REJ)
goto bad_state;
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
set_state(user, USER_IN_WAITING);
do_arrival(user);
return;
case USER_SIG_REJECT_ERR:
if (user->state != USER_IN_WAIT_REJ)
goto bad_state;
cc_user_err(user, arg2);
if (arg == NULL)
set_state(user, USER_IN_ARRIVED);
else {
set_state(user, USER_IN_WAITING);
do_arrival(user);
}
return;
case USER_SIG_ACCEPT_INCOMING:
{
/*
* User accepts call. This is done on the OLD user (i.e. the one
* sending the arrival), the message contains a pointer to the
* new endpoint.
*/
struct uni_msg *msg = arg;
struct atm_accept_incoming_call *acc =
uni_msg_rptr(msg, struct atm_accept_incoming_call *);
struct ccuser *newep;
if (user->state != USER_IN_ARRIVED) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_STATE);
return;
}
if (user->aborted) {
/* connection has disappeared. Send an error
* to the user and lock whether there is another
* connection at this endpoint */
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_PREVIOUSLY_ABORTED);
set_state(user, USER_IN_WAITING);
do_arrival(user);
return;
}
acc->newep[sizeof(acc->newep) - 1] = '\0';
LIST_FOREACH(newep, &user->cc->user_list, node_link)
if (strcmp(acc->newep, newep->name) == 0)
break;
uni_msg_destroy(msg);
if (newep == NULL) {
cc_user_err(user, ATMERR_BAD_ENDPOINT);
return;
}
if (newep->state != USER_NULL || newep->accepted != NULL) {
cc_user_err(user, ATMERR_BAD_STATE);
return;
}
set_state(user, USER_IN_WAIT_ACC);
cc_conn_sig(TAILQ_FIRST(&user->connq), CONN_SIG_ACCEPT, newep);
return;
}
case USER_SIG_ACCEPT_OK:
if (user->state != USER_IN_WAIT_ACC)
goto bad_state;
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
set_state(user, USER_IN_WAITING);
do_arrival(user);
return;
case USER_SIG_ACCEPT_ERR:
if (user->state != USER_IN_WAIT_ACC)
goto bad_state;
cc_user_err(user, arg2);
if (arg == NULL) {
/* arg used as flag! */
set_state(user, USER_IN_ARRIVED);
} else {
set_state(user, USER_IN_WAITING);
do_arrival(user);
}
return;
case USER_SIG_ACCEPTING:
if (user->state != USER_NULL)
goto bad_state;
set_state(user, USER_IN_ACCEPTING);
return;
case USER_SIG_SETUP_COMPL:
{
struct ccconn *conn = TAILQ_FIRST(&user->connq);
if (user->state != USER_IN_ACCEPTING)
goto bad_state;
user->state = USER_ACTIVE;
if (conn->bearer.cfg == UNI_BEARER_P2P) {
struct atm_p2p_call_active *act;
user->config = USER_P2P;
act = CCZALLOC(sizeof(*act));
if (act == NULL)
return;
act->connid = conn->connid;
cc_user_send(user, ATMOP_P2P_CALL_ACTIVE,
act, sizeof(*act));
CCFREE(act);
} else {
struct atm_p2mp_call_active *act;
user->config = USER_LEAF;
act = CCZALLOC(sizeof(*act));
if (act == NULL)
return;
act->connid = conn->connid;
cc_user_send(user, ATMOP_P2MP_CALL_ACTIVE,
act, sizeof(*act));
CCFREE(act);
}
return;
}
case USER_SIG_CALL_RELEASE:
{
struct uni_msg *msg = arg;
struct atm_call_release *api = uni_msg_rptr(msg,
struct atm_call_release *);
struct ccconn *conn;
conn = TAILQ_FIRST(&user->connq);
switch (user->state) {
case USER_OUT_WAIT_OK: /* U2/A3 */
/* wait for CONN_OK first */
conn->cause[0] = api->cause[0];
conn->cause[1] = api->cause[1];
set_state(user, USER_REL_WAIT_CONN);
break;
case USER_OUT_WAIT_CONF: /* U3/A3 */
/* wait for SETUP.confirm first */
conn->cause[0] = api->cause[0];
conn->cause[1] = api->cause[1];
set_state(user, USER_REL_WAIT_SCONF);
break;
case USER_IN_ACCEPTING: /* U11/A7 */
conn->cause[0] = api->cause[0];
conn->cause[1] = api->cause[1];
set_state(user, USER_REL_WAIT_SCOMP);
cc_conn_sig(conn, CONN_SIG_RELEASE, NULL);
break;
case USER_ACTIVE: /* U4/A8,A9,A10 */
conn->cause[0] = api->cause[0];
conn->cause[1] = api->cause[1];
set_state(user, USER_REL_WAIT);
cc_conn_sig(conn, CONN_SIG_RELEASE, NULL);
break;
default:
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_STATE);
goto bad_state;
}
uni_msg_destroy(msg);
return;
}
case USER_SIG_RELEASE_CONFIRM:
{
struct atm_call_release *ind;
switch (user->state) {
case USER_OUT_WAIT_CONF: /* U3/A3 */
case USER_ACTIVE: /* U4/A8,A9,A10 */
cc_user_reset(user);
break;
case USER_REL_WAIT: /* U5 /A8,A9,A10 */
case USER_REL_WAIT_SCOMP: /* U12/A7 */
case USER_REL_WAIT_SCONF: /* U13/A3 */
case USER_REL_WAIT_CONF: /* U14/A3 */
cc_user_reset(user);
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
return;
case USER_IN_ACCEPTING: /* U11/A7 */
cc_user_reset(user);
break;
default:
goto bad_state;
}
ind = CCZALLOC(sizeof(*ind));
if (ind == NULL)
return;
memcpy(ind->cause, user->cause, sizeof(ind->cause));
cc_user_send(user, ATMOP_CALL_RELEASE, ind, sizeof(*ind));
CCFREE(ind);
return;
}
case USER_SIG_RELEASE_ERR:
switch (user->state) {
case USER_REL_WAIT: /* U5/A8,A9,A10 */
set_state(user, USER_ACTIVE);
cc_user_err(user, ATM_MKUNIERR(arg2));
break;
case USER_REL_WAIT_CONF: /* U14/A3 */
cc_user_err(user, ATM_MKUNIERR(arg2));
cc_user_active(user);
break;
case USER_REL_WAIT_SCOMP: /* U12/A7 */
set_state(user, USER_IN_ACCEPTING);
cc_user_err(user, ATM_MKUNIERR(arg2));
break;
default:
goto bad_state;
}
return;
case USER_SIG_ADD_PARTY:
{
struct uni_msg *msg = arg;
struct atm_add_party *add = uni_msg_rptr(msg,
struct atm_add_party *);
struct ccconn *conn;
if (user->state != USER_ACTIVE || user->config != USER_ROOT) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_STATE);
return;
}
if (add->leaf_ident == 0 || add->leaf_ident >= 32786) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_LEAF_IDENT);
return;
}
conn = TAILQ_FIRST(&user->connq);
conn->called = add->called;
cc_conn_sig(conn, CONN_SIG_ADD_PARTY,
(void *)(uintptr_t)add->leaf_ident);
uni_msg_destroy(msg);
return;
}
case USER_SIG_ADD_PARTY_ERR:
if (user->state != USER_ACTIVE)
goto bad_state;
cc_user_err(user, arg2);
return;
case USER_SIG_ADD_PARTY_OK:
if (user->state != USER_ACTIVE)
goto bad_state;
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
return;
case USER_SIG_ADD_PARTY_ACK:
{
u_int leaf_ident = arg2;
struct atm_add_party_success *succ;
if (user->state != USER_ACTIVE)
goto bad_state;
succ = CCZALLOC(sizeof(*succ));
if (succ == NULL)
return;
succ->leaf_ident = leaf_ident;
cc_user_send(user, ATMOP_ADD_PARTY_SUCCESS,
succ, sizeof(*succ));
CCFREE(succ);
return;
}
case USER_SIG_ADD_PARTY_REJ:
{
u_int leaf_ident = arg2;
struct atm_add_party_reject *reject;
if (user->state != USER_ACTIVE)
goto bad_state;
reject = CCZALLOC(sizeof(*reject));
if (reject == NULL)
return;
reject->leaf_ident = leaf_ident;
reject->cause = user->cause[0];
cc_user_send(user, ATMOP_ADD_PARTY_REJECT,
reject, sizeof(*reject));
CCFREE(reject);
return;
}
case USER_SIG_DROP_PARTY:
{
struct uni_msg *msg = arg;
struct atm_drop_party *drop = uni_msg_rptr(msg,
struct atm_drop_party *);
struct ccconn *conn;
if (user->state != USER_ACTIVE || user->config != USER_ROOT) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_STATE);
return;
}
if (drop->leaf_ident >= 32786) {
uni_msg_destroy(msg);
cc_user_err(user, ATMERR_BAD_LEAF_IDENT);
return;
}
conn = TAILQ_FIRST(&user->connq);
conn->cause[0] = drop->cause;
memset(&conn->cause[1], 0, sizeof(conn->cause[1]));
cc_conn_sig(conn, CONN_SIG_DROP_PARTY,
(void *)(uintptr_t)drop->leaf_ident);
uni_msg_destroy(msg);
return;
}
case USER_SIG_DROP_PARTY_ERR:
if (user->state != USER_ACTIVE)
goto bad_state;
cc_user_err(user, arg2);
return;
case USER_SIG_DROP_PARTY_OK:
if (user->state != USER_ACTIVE)
goto bad_state;
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
return;
case USER_SIG_DROP_PARTY_IND:
{
u_int leaf_ident = arg2;
struct atm_drop_party *drop;
if (user->state != USER_ACTIVE)
goto bad_state;
drop = CCZALLOC(sizeof(*drop));
if (drop == NULL)
return;
drop->leaf_ident = leaf_ident;
drop->cause = user->cause[0];
cc_user_send(user, ATMOP_DROP_PARTY, drop, sizeof(*drop));
CCFREE(drop);
return;
}
case USER_SIG_QUERY_ATTR:
{
struct uni_msg *msg = arg;
struct atm_query_connection_attributes *req;
struct ccconn *conn;
if (user->aborted) {
cc_user_err(user, ATMERR_PREVIOUSLY_ABORTED);
uni_msg_destroy(msg);
return;
}
conn = cc_query_check(user);
if (conn == NULL) {
cc_user_err(user, ATMERR_BAD_STATE);
uni_msg_destroy(msg);
return;
}
req = uni_msg_rptr(msg,
struct atm_query_connection_attributes *);
cc_attr_query(user, conn, &req->attr, 1);
uni_msg_destroy(msg);
return;
}
case USER_SIG_QUERY_ATTR_X:
{
struct uni_msg *msg = arg;
struct atm_query_connection_attributes_x *req;
struct ccconn *conn;
conn = cc_query_check(user);
if (conn == NULL) {
cc_user_err(user, ATMERR_BAD_STATE);
uni_msg_destroy(msg);
return;
}
req = uni_msg_rptr(msg,
struct atm_query_connection_attributes_x *);
cc_attr_query(user, conn, req->attr, req->count);
uni_msg_destroy(msg);
return;
}
case USER_SIG_SET_ATTR:
{
struct uni_msg *msg = arg;
struct atm_set_connection_attributes *req;
struct ccconn *conn;
if (user->aborted) {
cc_user_err(user, ATMERR_PREVIOUSLY_ABORTED);
uni_msg_destroy(msg);
return;
}
conn = cc_set_check(user);
if (conn == NULL) {
cc_user_err(user, ATMERR_BAD_STATE);
uni_msg_destroy(msg);
return;
}
req = uni_msg_rptr(msg, struct atm_set_connection_attributes *);
cc_attr_set(user, conn, &req->attr, 1, (u_char *)(req + 1),
uni_msg_len(msg) - sizeof(*req));
uni_msg_destroy(msg);
return;
}
case USER_SIG_SET_ATTR_X:
{
struct uni_msg *msg = arg;
struct atm_set_connection_attributes_x *req;
struct ccconn *conn;
conn = cc_set_check(user);
if (conn == NULL) {
cc_user_err(user, ATMERR_BAD_STATE);
uni_msg_destroy(msg);
return;
}
req = uni_msg_rptr(msg,
struct atm_set_connection_attributes_x *);
cc_attr_set(user, conn, req->attr, req->count,
(u_char *)req->attr + req->count * sizeof(req->attr[0]),
uni_msg_len(msg) -
offsetof(struct atm_set_connection_attributes_x, attr) -
req->count * sizeof(req->attr[0]));
uni_msg_destroy(msg);
return;
}
case USER_SIG_QUERY_STATE:
{
struct atm_epstate state;
strcpy(state.name, user->name);
switch (user->state) {
case USER_NULL:
if (user->accepted != NULL)
state.state = ATM_A7;
else
state.state = ATM_A1;
break;
case USER_OUT_PREPARING:
state.state = ATM_A2;
break;
case USER_OUT_WAIT_OK:
case USER_OUT_WAIT_CONF:
case USER_REL_WAIT_SCONF:
case USER_REL_WAIT_CONF:
case USER_REL_WAIT_CONN:
state.state = ATM_A3;
break;
case USER_ACTIVE:
case USER_REL_WAIT:
switch (user->config) {
case USER_P2P:
state.state = ATM_A8;
break;
case USER_ROOT:
state.state = ATM_A9;
break;
case USER_LEAF:
state.state = ATM_A10;
break;
}
break;
case USER_IN_PREPARING:
state.state = ATM_A4;
break;
case USER_IN_WAITING:
state.state = ATM_A5;
break;
case USER_IN_ARRIVED:
case USER_IN_WAIT_REJ:
case USER_IN_WAIT_ACC:
state.state = ATM_A6;
break;
case USER_IN_ACCEPTING:
case USER_REL_WAIT_SCOMP:
state.state = ATM_A7;
break;
}
cc_user_ok(user, ATMRESP_STATE, &state, sizeof(state));
return;
}
case USER_SIG_GET_LOCAL_PORT_INFO:
{
struct uni_msg *msg = arg;
struct atm_port_list *list;
size_t list_len;
list = cc_get_local_port_info(user->cc,
uni_msg_rptr(msg, struct atm_get_local_port_info *)->port,
&list_len);
uni_msg_destroy(msg);
if (list == NULL) {
cc_user_err(user, ATMERR_NOMEM);
return;
}
cc_user_ok(user, ATMRESP_PORTS, list, list_len);
CCFREE(list);
return;
}
case USER_SIG_ABORT_CONNECTION:
{
struct uni_msg *msg = arg;
struct atm_abort_connection *abo = uni_msg_rptr(msg,
struct atm_abort_connection *);
cc_user_abort(user, &abo->cause);
uni_msg_destroy(msg);
cc_user_ok(user, ATMRESP_NONE, NULL, 0);
return;
}
}
if (user->cc->log & CCLOG_USER_SIG)
cc_user_log(user, "bad signal=%u in state=%u",
sig, user->state);
return;
bad_state:
if (user->cc->log & CCLOG_USER_SIG)
cc_user_log(user, "bad state=%u for signal=%u",
user->state, sig);
return;
}
Reference in New Issue View Git Blame Copy Permalink