| Current Path : /sys/amd64/compile/hs32/modules/usr/src/sys/modules/ste/@/contrib/ngatm/netnatm/sig/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //sys/amd64/compile/hs32/modules/usr/src/sys/modules/ste/@/contrib/ngatm/netnatm/sig/sig_coord.c |
/*
* Copyright (c) 1996-2003
* Fraunhofer Institute for Open Communication Systems (FhG Fokus).
* All rights reserved.
*
* Redistribution 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 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 IS PROVIDED BY THE AUTHOR AND 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 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.
*
* Author: Hartmut Brandt <harti@freebsd.org>
*
* $Begemot: libunimsg/netnatm/sig/sig_coord.c,v 1.12 2004/08/05 07:11:01 brandt Exp $
*
* Coordinator
*/
#include <netnatm/unimsg.h>
#include <netnatm/saal/sscfudef.h>
#include <netnatm/msg/unistruct.h>
#include <netnatm/msg/unimsglib.h>
#include <netnatm/sig/uni.h>
#include <netnatm/sig/unipriv.h>
#include <netnatm/sig/unimkmsg.h>
#define STR(S) [S] = #S
static const char *const cunames[] = {
STR(CU_STAT0),
STR(CU_STAT1),
STR(CU_STAT2),
STR(CU_STAT3),
};
#define DEF_PRIV_SIG(NAME, FROM) [SIG##NAME] = "SIG"#NAME,
static const char *const coord_sigs[] = {
DEF_COORD_SIGS
};
#undef DEF_PRIV_SIG
static void sig_all_calls(struct uni *, u_int sig);
static void set_custat(struct uni *, enum cu_stat);
static void input_dummy(struct uni *uni, struct uni_msg *m, struct uni_all *u);
static void input_global(struct uni *uni, struct uni_msg *m, struct uni_all *u);
static void input_unknown(struct uni *uni, struct uni_msg *m, struct uni_all *u);
static void input_cobi(struct call *c, struct uni_msg *m, struct uni_all *u);
static void input_call(struct call *c, struct uni_msg *m, struct uni_all *u);
TIMER_FUNC_UNI(t309, t309_func)
/*
* All those 'bogus signal' printouts are not specified in the SDLs.
*/
/*
* SAAL-ESTABLISH.indication
*
* This means either a resynchronisation or error-recovery or
* an incoming SSCOP connection.
*/
static void
coord_saal_establish_indication(struct uni *uni)
{
switch (uni->custat) {
case CU_STAT0: /* Q.2931:Coord-U 4/10 */
case CU_STAT3: /* Q.2931:Coord-U 5/10 */
sig_all_calls(uni, SIGC_LINK_ESTABLISH_indication);
set_custat(uni, CU_STAT3);
break;
case CU_STAT1:
case CU_STAT2:
VERBOSE0(uni, UNI_FAC_COORD,
"signal saal_establish.indication in CU%u", uni->custat);
break;
default:
ASSERT(0, ("CU_STAT*"));
}
}
/*
* SAAL-ESTABLISH.confirm
*/
static void
coord_saal_establish_confirm(struct uni *uni)
{
switch (uni->custat) {
case CU_STAT0:
case CU_STAT2:
VERBOSE0(uni, UNI_FAC_COORD,
"signal saal_establish.confirm in CU%u", uni->custat);
break;
case CU_STAT1:
/*
* Q.2931:Co-ord-U 4/10
*/
TIMER_STOP_UNI(uni, t309);
sig_all_calls(uni, SIGC_LINK_ESTABLISH_confirm);
uni->funcs->uni_output(uni, uni->arg,
UNIAPI_LINK_ESTABLISH_confirm, 0, NULL);
set_custat(uni, CU_STAT3);
break;
case CU_STAT3:
/*
* Q.2931:Coord-U 5/10
*/
sig_all_calls(uni, SIGC_LINK_ESTABLISH_confirm);
uni->funcs->uni_output(uni, uni->arg,
UNIAPI_LINK_ESTABLISH_confirm, 0, NULL);
break;
default:
ASSERT(0, ("CU_STAT*"));
}
}
/*
* SAAL-RELEASE.confirm
*/
static void
coord_saal_release_confirm(struct uni *uni)
{
switch (uni->custat) {
case CU_STAT0:
case CU_STAT1:
case CU_STAT3:
VERBOSE0(uni, UNI_FAC_COORD,
"signal saal_release.confirm in CU%u", uni->custat);
break;
case CU_STAT2:
/*
* Q.2931:Coord-U 5/10
*/
uni->funcs->uni_output(uni, uni->arg,
UNIAPI_LINK_RELEASE_confirm, 0, NULL);
set_custat(uni, CU_STAT0);
break;
default:
ASSERT(0, ("CU_STAT*"));
}
}
/*
* SAAL failure.
*/
static void
coord_saal_release_indication(struct uni *uni)
{
switch (uni->custat) {
case CU_STAT0:
case CU_STAT2:
VERBOSE0(uni, UNI_FAC_COORD,
"signal saal_release.indication in CU%u", uni->custat);
break;
case CU_STAT1:
case CU_STAT3:
/*
* Q.2931:Coord-U 4/10
* Q.2931:Coord-U 5/10
*/
sig_all_calls(uni, SIGC_LINK_RELEASE_indication);
set_custat(uni, CU_STAT0);
break;
default:
ASSERT(0, ("CU_STAT*"));
}
}
/*
* Link-establish.request from USER. This can also come from
* a call instance. In this case 'cookie' is zero.
*/
static void
coord_link_establish_request(struct uni *uni, uint32_t cookie)
{
switch (uni->custat) {
case CU_STAT0:
/*
* Q.2931:Coord-U 4/10
*/
uni->funcs->saal_output(uni, uni->arg,
SAAL_ESTABLISH_request, NULL);
if (!TIMER_ISACT(uni, t309))
TIMER_START_UNI(uni, t309, uni->timer309);
set_custat(uni, CU_STAT1);
if (cookie)
uniapi_uni_error(uni, UNIAPI_OK, cookie, 0);
break;
case CU_STAT1:
/*
* Q.2931:Coord-U 4/10
* This is probably missing from the delay field.
*/
uni_delenq_coord(uni, SIGO_LINK_ESTABLISH_request,
cookie, NULL);
break;
case CU_STAT2:
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALLSTATE, cookie, 0);
if (cookie == 0)
VERBOSE0(uni, UNI_FAC_COORD,
"signal link-establish.request in CU%u",
uni->custat);
break;
case CU_STAT3:
/*
* Q.2931:Coord-U 5/10
*/
uni->funcs->uni_output(uni, uni->arg,
UNIAPI_LINK_ESTABLISH_confirm, 0, NULL);
uniapi_uni_error(uni, UNIAPI_OK, cookie, 0);
break;
default:
ASSERT(0, ("CU_STAT*"));
}
}
/*
* Link-release.request from user
*/
static void
coord_link_release_request(struct uni *uni, u_int cookie)
{
switch (uni->custat) {
case CU_STAT0:
case CU_STAT1:
case CU_STAT2:
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALLSTATE, cookie, 0);
break;
case CU_STAT3:
/*
* Q.2931:Coord-U 5/10
*/
uni->funcs->saal_output(uni, uni->arg,
SAAL_RELEASE_request, NULL);
set_custat(uni, CU_STAT2);
uniapi_uni_error(uni, UNIAPI_OK, cookie, 0);
break;
default:
ASSERT(0, ("CU_STAT*"));
}
}
/*
* T309 timeout signal
*/
static void
coord_t309(struct uni *uni)
{
switch (uni->custat) {
case CU_STAT0:
case CU_STAT1:
/*
* Q.2931:Coord-U 4/10
*/
sig_all_calls(uni, SIGC_LINK_ESTABLISH_ERROR_indication);
set_custat(uni, CU_STAT0);
/* this is not in the SDLs, but how will the call control
* know, that starting the LINK has failed otherwise? */
uni->funcs->uni_output(uni, uni->arg,
UNIAPI_LINK_RELEASE_confirm, 0, NULL);
break;
case CU_STAT2:
case CU_STAT3:
VERBOSE0(uni, UNI_FAC_COORD,
"signal T309 in CU%u", uni->custat);
break;
default:
ASSERT(0, ("CU_STAT*"));
}
}
/*
* Message from SAAL
*/
static void
coord_saal_data_indication(struct uni *uni, struct uni_msg *m)
{
struct uni_all *u;
struct call *c;
memset(&uni->cause, 0, sizeof(uni->cause));
if ((u = UNI_ALLOC()) == NULL) {
uni_msg_destroy(m);
return;
}
if (uni_decode_head(m, u, &uni->cx)) {
VERBOSE(uni, UNI_FAC_COORD, 2, "bogus message - ignored");
uni_msg_destroy(m);
UNI_FREE(u);
return;
}
if (u->u.hdr.cref.cref == CREF_DUMMY) {
if (uni->cx.q2932) {
input_dummy(uni, m, u);
} else {
VERBOSE(uni, UNI_FAC_COORD, 2, "dummy cref - ignored");
UNI_FREE(u);
uni_msg_destroy(m);
}
return;
}
if (u->u.hdr.cref.cref == CREF_GLOBAL)
input_global(uni, m, u);
else if ((c = uni_find_call(uni, &u->u.hdr.cref)) == NULL)
input_unknown(uni, m, u);
else if (c->type == CALL_COBI)
input_cobi(c, m, u);
else
input_call(c, m, u);
}
/*
* Message with global call reference
*
* Q.2931:Coord-U (X) 7/10
*/
static void
input_global(struct uni *uni, struct uni_msg *m, struct uni_all *u)
{
VERBOSE(uni, UNI_FAC_COORD, 2, "GLOB MTYPE = %x", u->mtype);
switch (u->mtype) {
default:
/*
* Q.2931:Coord-U 7/10
* Q.2931: 5.6.3.2e
* Amd4: 29e
*/
uni_respond_status(uni, &u->u.hdr.cref,
u->u.hdr.cref.flag ? uni->glob_start : uni->glob_respond,
UNI_CAUSE_CREF_INV);
break;
case UNI_RESTART:
if (u->u.hdr.cref.flag) {
/*
* Q.2931:Coord-U 7/10 (5.6.3.2h)
*/
uni_respond_status(uni, &u->u.hdr.cref,
uni->glob_start, UNI_CAUSE_CREF_INV);
break;
}
uni_enq_resp(uni, SIGR_RESTART, 0, m, u);
return;
case UNI_RESTART_ACK:
if (!u->u.hdr.cref.flag) {
/*
* Q.2931:Coord-U 7/10 (5.6.3.2h)
* Note, that the SDL diagram contains an error.
* The error with the 'YES' label should go to the
* box below 'OTHER'.
*/
uni_respond_status(uni, &u->u.hdr.cref,
uni->glob_respond, UNI_CAUSE_CREF_INV);
break;
}
uni_enq_start(uni, SIGS_RESTART_ACK, 0, m, u);
return;
case UNI_STATUS:
if (u->u.hdr.cref.flag)
uni_enq_start(uni, SIGS_STATUS, 0, m, u);
else
uni_enq_resp(uni, SIGR_STATUS, 0, m, u);
return;
}
uni_msg_destroy(m);
UNI_FREE(u);
}
/*
* Q.2931:Coord-U 8/10
*
* Message for an unknown call reference
*/
static void
input_unknown(struct uni *uni, struct uni_msg *m, struct uni_all *u)
{
struct uni_all *resp;
struct call *c;
u_int cause = UNI_CAUSE_CREF_INV;
VERBOSE(uni, UNI_FAC_COORD, 2, "UNKNOWN MTYPE = %x", u->mtype);
switch (u->mtype) {
default:
/*
* This message type is entirly unknown
*
* 5.6.4 and 5.7.1 are only when the call is not in the
* NULL state. This means, 5.6.3.2a takes over.
*/
break;
case UNI_SETUP:
if (u->u.hdr.cref.flag)
/*
* 5.6.3.2c
*/
goto drop;
if ((c = uni_create_call(uni, u->u.hdr.cref.cref, 0, 0)) != NULL) {
uni_enq_call(c, SIGC_SETUP, 0, m, u);
return;
}
goto drop;
case UNI_RELEASE_COMPL:
/*
* 5.6.3.2c
*/
goto drop;
case UNI_STATUS:
/*
* 5.6.12
*
* The SDLs don't use the verify procedure and don't
* handle the case of an invalid callstate - we
* ignore the message, if the callstate is not good.
*/
(void)uni_decode_body(m, u, &uni->cx);
if (!IE_ISGOOD(u->u.status.callstate))
goto drop;
if (u->u.status.callstate.state == UNI_CALLSTATE_U0)
goto drop;
cause = UNI_CAUSE_MSG_INCOMP;
break;
case UNI_STATUS_ENQ:
if ((resp = UNI_ALLOC()) == NULL)
goto drop;
(void)uni_decode_body(m, u, &uni->cx);
MK_MSG_RESP(resp, UNI_STATUS, &u->u.hdr.cref);
MK_IE_CALLSTATE(resp->u.status.callstate, UNI_CALLSTATE_U0);
MK_IE_CAUSE(resp->u.status.cause, UNI_CAUSE_LOC_USER,
UNI_CAUSE_STATUS);
if (IE_ISGOOD(u->u.status_enq.epref)) {
/* reflect epref as required by L3MU_PO */
resp->u.status.epref = u->u.status_enq.epref;
MK_IE_EPREF(resp->u.status.epref,
u->u.status_enq.epref.epref,
!u->u.status_enq.epref.flag);
MK_IE_EPSTATE(resp->u.status.epstate, UNI_EPSTATE_NULL);
}
(void)uni_send_output(resp, uni);
UNI_FREE(resp);
goto drop;
case UNI_COBISETUP:
if (u->u.hdr.cref.flag)
/*
* 5.6.3.2c (probably)
*/
goto drop;
if ((c = uni_create_call(uni, u->u.hdr.cref.cref, 0, 0)) != NULL) {
uni_enq_call(c, SIGC_COBISETUP, 0, m, u);
return;
}
goto drop;
}
/*
* 5.6.3.2a)
*
* Respond with a RELEASE COMPLETE
*/
if ((resp = UNI_ALLOC()) == NULL)
goto drop;
MK_MSG_RESP(resp, UNI_RELEASE_COMPL, &u->u.hdr.cref);
MK_IE_CAUSE(resp->u.release_compl.cause[0], UNI_CAUSE_LOC_USER, cause);
if (uni_diag(cause, UNI_CODING_ITU) == UNI_DIAG_MTYPE)
ADD_CAUSE_MTYPE(resp->u.release_compl.cause[0], u->mtype);
(void)uni_send_output(resp, uni);
UNI_FREE(resp);
drop:
UNI_FREE(u);
uni_msg_destroy(m);
}
static void
input_cobi(struct call *c __unused, struct uni_msg *m, struct uni_all *u)
{
/* XXX */
UNI_FREE(u);
uni_msg_destroy(m);
}
static void
input_dummy(struct uni *uni __unused, struct uni_msg *m, struct uni_all *u)
{
/* XXX */
UNI_FREE(u);
uni_msg_destroy(m);
}
static void
input_call(struct call *c, struct uni_msg *m, struct uni_all *u)
{
VERBOSE(c->uni, UNI_FAC_COORD, 2, "CALL MTYPE = %x %d/%s",
u->mtype, c->cref, c->mine ? "mine":"his");
switch (u->mtype) {
case UNI_SETUP:
/*
* Ignored
*/
break;
case UNI_CALL_PROC:
uni_enq_call(c, SIGC_CALL_PROC, 0, m, u);
return;
case UNI_ALERTING:
uni_enq_call(c, SIGC_ALERTING, 0, m, u);
return;
case UNI_RELEASE:
uni_enq_call(c, SIGC_RELEASE, 0, m, u);
return;
case UNI_RELEASE_COMPL:
uni_enq_call(c, SIGC_RELEASE_COMPL, 0, m, u);
return;
case UNI_CONNECT:
uni_enq_call(c, SIGC_CONNECT, 0, m, u);
return;
case UNI_CONNECT_ACK:
uni_enq_call(c, SIGC_CONNECT_ACK, 0, m, u);
return;
case UNI_NOTIFY:
uni_enq_call(c, SIGC_NOTIFY, 0, m, u);
return;
case UNI_STATUS:
uni_enq_call(c, SIGC_STATUS, 0, m, u);
return;
case UNI_STATUS_ENQ:
uni_enq_call(c, SIGC_STATUS_ENQ, 0, m, u);
return;
case UNI_ADD_PARTY:
uni_enq_call(c, SIGC_ADD_PARTY, 0, m, u);
return;
case UNI_PARTY_ALERTING:
uni_enq_call(c, SIGC_PARTY_ALERTING, 0, m, u);
return;
case UNI_ADD_PARTY_ACK:
uni_enq_call(c, SIGC_ADD_PARTY_ACK, 0, m, u);
return;
case UNI_ADD_PARTY_REJ:
uni_enq_call(c, SIGC_ADD_PARTY_REJ, 0, m, u);
return;
case UNI_DROP_PARTY:
uni_enq_call(c, SIGC_DROP_PARTY, 0, m, u);
return;
case UNI_DROP_PARTY_ACK:
uni_enq_call(c, SIGC_DROP_PARTY_ACK, 0, m, u);
return;
default:
uni_enq_call(c, SIGC_UNKNOWN, 0, m, u);
return;
}
UNI_FREE(u);
uni_msg_destroy(m);
}
/*
* This macro tries to implement the delaying behaviour for
* message from the API when we are in the Awaiting-Establish state.
* In this state, the message is delayed. If we drop back to CU 0,
* everything gets unqueued and errors are returned for all that stuff.
* If we progess to CUSTAT2 we process the requests.
*/
#define COMMON_DELAY(SIG, COOKIE) \
if (uni->custat == CU_STAT0 || uni->custat == CU_STAT2) {\
uniapi_uni_error(uni, UNIAPI_ERROR_BADCU, \
COOKIE, 0); \
break; \
} \
if (uni->custat == CU_STAT1) { \
uni_delenq_coord(uni, SIG, COOKIE, msg); \
break; \
}
/*
* Signal handler of the coordinator
*/
void
uni_sig_coord(struct uni *uni, enum coord_sig sig, uint32_t cookie,
struct uni_msg *msg)
{
struct call *c;
if (sig >= SIGO_END) {
VERBOSE(uni, UNI_FAC_ERR, 1, "Signal %d outside of range to "
"Coord", sig);
if (msg)
uni_msg_destroy(msg);
return;
}
VERBOSE(uni, UNI_FAC_COORD, 1, "Signal %s in state %s",
coord_sigs[sig], cunames[uni->custat]);
switch (sig) {
case SIGO_END:
break;
case SIGO_DATA: /* delayed output */
if (uni->custat == CU_STAT0 || uni->custat == CU_STAT1)
break; /* drop */
if (uni->custat == CU_STAT1)
uni_delenq_coord(uni, SIGO_DATA, cookie, msg);/* ??? */
else
uni->funcs->saal_output(uni, uni->arg,
SAAL_DATA_request, msg);
msg = NULL;
break;
/*
* SAAL signals
*/
case SIGO_SAAL_ESTABLISH_indication:
coord_saal_establish_indication(uni);
break;
case SIGO_SAAL_ESTABLISH_confirm:
coord_saal_establish_confirm(uni);
break;
case SIGO_SAAL_RELEASE_confirm:
coord_saal_release_confirm(uni);
break;
case SIGO_SAAL_RELEASE_indication:
coord_saal_release_indication(uni);
break;
case SIGO_SAAL_DATA_indication:
coord_saal_data_indication(uni, msg);
msg = NULL;
break;
case SIGO_SAAL_UDATA_indication:
VERBOSE0(uni, UNI_FAC_ERR, "SAAL_UDATA_indication");
break;
/*
* Signals from USER
*/
case SIGO_LINK_ESTABLISH_request:
coord_link_establish_request(uni, cookie);
break;
case SIGO_LINK_RELEASE_request:
coord_link_release_request(uni, cookie);
break;
case SIGO_RESET_request:
uni_enq_start(uni, SIGS_RESET_request, cookie, msg, NULL);
msg = NULL;
if (uni->custat == CU_STAT0) {
uni->funcs->saal_output(uni, uni->arg,
SAAL_ESTABLISH_request, NULL);
if (!TIMER_ISACT(uni, t309))
TIMER_START_UNI(uni, t309, uni->timer309);
set_custat(uni, CU_STAT1);
}
break;
case SIGO_RESET_ERROR_response:
COMMON_DELAY(SIGO_RESET_ERROR_response, cookie);
uni_enq_resp(uni, SIGR_RESET_ERROR_response, cookie, msg, NULL);
msg = NULL;
break;
case SIGO_RESET_response:
COMMON_DELAY(SIGO_RESET_response, cookie);
uni_enq_resp(uni, SIGR_RESET_response, cookie, msg, NULL);
msg = NULL;
break;
case SIGO_SETUP_request:
if ((c = uni_create_new_call(uni, cookie)) != NULL) {
uni_enq_call(c, SIGC_SETUP_request, cookie, msg, NULL);
msg = NULL;
if (uni->custat == CU_STAT0) {
uni->funcs->saal_output(uni, uni->arg,
SAAL_ESTABLISH_request, NULL);
if (!TIMER_ISACT(uni, t309))
TIMER_START_UNI(uni, t309, uni->timer309);
set_custat(uni, CU_STAT1);
}
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_NOMEM, cookie,
UNI_CALLSTATE_U0);
}
break;
case SIGO_PROCEEDING_request:
{
struct uniapi_proceeding_request *arg =
uni_msg_rptr(msg, struct uniapi_proceeding_request *);
COMMON_DELAY(SIGO_PROCEEDING_request, cookie);
if ((c = uni_find_call(uni, &arg->call_proc.hdr.cref)) != NULL) {
uni_enq_call(c, SIGC_PROCEEDING_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_ALERTING_request:
{
struct uniapi_alerting_request *arg =
uni_msg_rptr(msg, struct uniapi_alerting_request *);
COMMON_DELAY(SIGO_ALERTING_request, cookie);
if ((c = uni_find_call(uni, &arg->alerting.hdr.cref)) != NULL) {
uni_enq_call(c, SIGC_ALERTING_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_SETUP_response:
{
struct uniapi_setup_response *arg =
uni_msg_rptr(msg, struct uniapi_setup_response *);
COMMON_DELAY(SIGO_SETUP_response, cookie);
if ((c = uni_find_call(uni, &arg->connect.hdr.cref)) != NULL) {
uni_enq_call(c, SIGC_SETUP_response, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_SETUP_COMPLETE_request:
{
struct uniapi_setup_complete_request *arg =
uni_msg_rptr(msg, struct uniapi_setup_complete_request *);
COMMON_DELAY(SIGO_SETUP_COMPLETE_request, cookie);
if ((c = uni_find_call(uni, &arg->connect_ack.hdr.cref)) != NULL) {
uni_enq_call(c, SIGC_SETUP_COMPLETE_request,
cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_RELEASE_request:
{
struct uniapi_release_request *arg =
uni_msg_rptr(msg, struct uniapi_release_request *);
COMMON_DELAY(SIGO_RELEASE_request, cookie);
if ((c = uni_find_call(uni, &arg->release.hdr.cref)) != NULL) {
uni_enq_call(c, SIGC_RELEASE_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_RELEASE_response:
{
struct uniapi_release_response *arg =
uni_msg_rptr(msg, struct uniapi_release_response *);
COMMON_DELAY(SIGO_RELEASE_response, cookie);
if ((c = uni_find_call(uni, &arg->release_compl.hdr.cref)) != NULL) {
uni_enq_call(c, SIGC_RELEASE_response, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_NOTIFY_request:
{
struct uniapi_notify_request *arg =
uni_msg_rptr(msg, struct uniapi_notify_request *);
COMMON_DELAY(SIGO_NOTIFY_request, cookie);
if ((c = uni_find_call(uni, &arg->notify.hdr.cref)) != NULL) {
uni_enq_call(c, SIGC_NOTIFY_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_STATUS_ENQUIRY_request:
{
struct uniapi_status_enquiry_request *arg =
uni_msg_rptr(msg, struct uniapi_status_enquiry_request *);
COMMON_DELAY(SIGO_STATUS_ENQUIRY_request, cookie);
if ((c = uni_find_call(uni, &arg->cref)) != NULL) {
uni_enq_call(c, SIGC_STATUS_ENQUIRY_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_ADD_PARTY_request:
{
struct uniapi_add_party_request *arg =
uni_msg_rptr(msg, struct uniapi_add_party_request *);
COMMON_DELAY(SIGO_ADD_PARTY_request, cookie);
if ((c = uni_find_call(uni, &arg->add.hdr.cref)) != NULL) {
if (c->type != CALL_ROOT) {
uniapi_call_error(c, UNIAPI_ERROR_BAD_CTYPE,
cookie);
break;
}
uni_enq_call(c, SIGC_ADD_PARTY_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_PARTY_ALERTING_request:
{
struct uniapi_party_alerting_request *arg =
uni_msg_rptr(msg, struct uniapi_party_alerting_request *);
COMMON_DELAY(SIGO_PARTY_ALERTING_request, cookie);
if ((c = uni_find_call(uni, &arg->alert.hdr.cref)) != NULL) {
if (c->type != CALL_LEAF) {
uniapi_call_error(c, UNIAPI_ERROR_BAD_CTYPE,
cookie);
break;
}
uni_enq_call(c, SIGC_PARTY_ALERTING_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_ADD_PARTY_ACK_request:
{
struct uniapi_add_party_ack_request *arg =
uni_msg_rptr(msg, struct uniapi_add_party_ack_request *);
COMMON_DELAY(SIGO_ADD_PARTY_ACK_request, cookie);
if ((c = uni_find_call(uni, &arg->ack.hdr.cref)) != NULL) {
if (c->type != CALL_LEAF) {
uniapi_call_error(c, UNIAPI_ERROR_BAD_CTYPE,
cookie);
break;
}
uni_enq_call(c, SIGC_ADD_PARTY_ACK_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_ADD_PARTY_REJ_request:
{
struct uniapi_add_party_rej_request *arg =
uni_msg_rptr(msg, struct uniapi_add_party_rej_request *);
COMMON_DELAY(SIGO_ADD_PARTY_REJ_request, cookie);
if ((c = uni_find_call(uni, &arg->rej.hdr.cref)) != NULL) {
if (c->type != CALL_LEAF) {
uniapi_call_error(c, UNIAPI_ERROR_BAD_CTYPE,
cookie);
break;
}
uni_enq_call(c, SIGC_ADD_PARTY_REJ_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_DROP_PARTY_request:
{
struct uniapi_drop_party_request *arg =
uni_msg_rptr(msg, struct uniapi_drop_party_request *);
COMMON_DELAY(SIGO_DROP_PARTY_request, cookie);
if ((c = uni_find_call(uni, &arg->drop.hdr.cref)) != NULL) {
if (c->type != CALL_ROOT && c->type != CALL_LEAF) {
uniapi_call_error(c, UNIAPI_ERROR_BAD_CTYPE,
cookie);
break;
}
uni_enq_call(c, SIGC_DROP_PARTY_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_DROP_PARTY_ACK_request:
{
struct uniapi_drop_party_ack_request *arg =
uni_msg_rptr(msg, struct uniapi_drop_party_ack_request *);
COMMON_DELAY(SIGO_DROP_PARTY_ACK_request, cookie);
if ((c = uni_find_call(uni, &arg->ack.hdr.cref)) != NULL) {
if (c->type != CALL_ROOT && c->type != CALL_LEAF) {
uniapi_call_error(c, UNIAPI_ERROR_BAD_CTYPE,
cookie);
break;
}
uni_enq_call(c, SIGC_DROP_PARTY_ACK_request, cookie, msg, NULL);
msg = NULL;
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
case SIGO_ABORT_CALL_request:
{
struct uniapi_abort_call_request *arg =
uni_msg_rptr(msg, struct uniapi_abort_call_request *);
if ((c = uni_find_call(uni, &arg->cref)) != NULL) {
uni_enq_call(c, SIGC_ABORT_CALL_request, cookie, NULL, NULL);
} else {
uniapi_uni_error(uni, UNIAPI_ERROR_BAD_CALL, cookie,
UNI_CALLSTATE_U0);
}
break;
}
/*
* Call-Control
*/
case SIGO_CALL_DESTROYED:
uni->funcs->uni_output(uni, uni->arg,
UNIAPI_CALL_DESTROYED, 0, msg);
msg = NULL;
break;
/*
* ResetRespond
*/
case SIGO_RESET_indication:
uni->funcs->uni_output(uni, uni->arg,
UNIAPI_RESET_indication, 0, msg);
msg = NULL;
break;
/*
* Timeouts
*/
case SIGO_T309:
coord_t309(uni);
break;
}
if (msg != NULL)
uni_msg_destroy(msg);
}
/*
* Send a signal to all call instances
*/
static void
sig_all_calls(struct uni *uni, u_int sig)
{
struct call *call;
TAILQ_FOREACH(call, &uni->calls, link)
uni_enq_call(call, sig, 0, NULL, NULL);
}
/*
* Set a new coordinator state - this moves all delayed coordinator
* signals from the delayed queue to the signal queue.
*/
static int
cufilt(struct sig *s, void *arg __unused)
{
return (s->type == SIG_COORD);
}
static void
set_custat(struct uni *uni, enum cu_stat nstate)
{
if (uni->custat != nstate) {
uni->custat = nstate;
uni_undel(uni, cufilt, NULL);
}
}
/*
* T309 timeout function
*/
static void
t309_func(struct uni *uni)
{
uni_enq_coord(uni, SIGO_T309, 0, NULL);
}
/*
* Respond with a status message
*/
void
uni_respond_status(struct uni *uni, struct uni_cref *cref,
enum uni_callstate cs, enum uni_cause c1)
{
struct uni_all *resp;
if ((resp = UNI_ALLOC()) == NULL)
return;
MK_MSG_RESP(resp, UNI_STATUS, cref);
MK_IE_CALLSTATE(resp->u.status.callstate, cs);
MK_IE_CAUSE(resp->u.status.cause, UNI_CAUSE_LOC_USER, c1);
(void)uni_send_output(resp, uni);
UNI_FREE(resp);
}
/*
* Respond with a status message
*/
void
uni_respond_status_mtype(struct uni *uni, struct uni_cref *cref,
enum uni_callstate cs, enum uni_cause c1, u_int mtype)
{
struct uni_all *resp;
if((resp = UNI_ALLOC()) == NULL)
return;
MK_MSG_RESP(resp, UNI_STATUS, cref);
MK_IE_CALLSTATE(resp->u.status.callstate, cs);
MK_IE_CAUSE(resp->u.status.cause, UNI_CAUSE_LOC_USER, c1);
ADD_CAUSE_MTYPE(resp->u.status.cause, mtype);
(void)uni_send_output(resp, uni);
UNI_FREE(resp);
}
/*
* Send a message. If we are in CUSTAT1, delay the message if we
* are in CUSTAT3 send it, else drop it.
*/
int
uni_send_output(struct uni_all *u, struct uni *uni)
{
struct uni_msg *m;
int err;
if (uni->custat == CU_STAT0 || uni->custat == CU_STAT2)
return (0);
m = uni_msg_alloc(1024);
if ((err = uni_encode(m, u, &uni->cx)) != 0) {
VERBOSE0(uni, UNI_FAC_ERR, "uni_encode failed: %08x", err);
uni_msg_destroy(m);
return (-1);
}
if (uni->custat == CU_STAT1)
uni_delenq_coord(uni, SIGO_DATA, 0, m);
else
uni->funcs->saal_output(uni, uni->arg, SAAL_DATA_request, m);
return (0);
}