d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
82a67a70a2
freebsd-dev/sys/contrib/ngatm/netnatm/msg/uni_ie.c
Hartmut Brandt d32729f62c Virgin import of NgATM kernel part 1.2
2005-05-23 13:08:32 +00:00

7165 lines
145 KiB
C
Raw Blame History

/*
* Copyright (c) 2001-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/msg/uni_ie.c,v 1.16 2005/05/23 12:06:30 brandt_h Exp $
*
* Private definitions for the IE code file.
*
* This file includes the table generated automatically.
*/
#include <sys/types.h>
#include <sys/param.h>
#ifdef _KERNEL
#include <sys/libkern.h>
#else
#include <string.h>
#endif
#include <netnatm/unimsg.h>
#include <netnatm/msg/unistruct.h>
#include <netnatm/msg/unimsglib.h>
#include <netnatm/msg/uniprint.h>
#include <netnatm/msg/priv.h>
/*
* Define internal functions.
*/
#define DEF_IE_PRINT(Coding, IE) \
void uni_ie_print_##Coding##_##IE(struct uni_ie_##IE *ie, struct unicx *cx)
#define DEF_IE_CHECK(Coding, IE) \
int uni_ie_check_##Coding##_##IE(struct uni_ie_##IE *ie, struct unicx *cx)
#define DEF_IE_ENCODE(Coding, IE) \
int uni_ie_encode_##Coding##_##IE(struct uni_msg *msg, struct uni_ie_##IE *ie, struct unicx *cx)
#define DEF_IE_DECODE(Coding, IE) \
int uni_ie_decode_##Coding##_##IE(struct uni_ie_##IE *ie, struct uni_msg *msg, u_int ielen, struct unicx *cx)
/*
* This structure is used to define value->string mappings. MKT() is used
* to generate a table entry. EOT() to end the table.
*/
#define MKT(V,N) { #N, V }
#define EOT() { NULL, 0 }
/* library internal functions */
static void uni_entry(const char *, struct unicx *);
static int uni_print_iehdr(const char *, struct uni_iehdr *h, struct unicx *);
static void uni_print_ieend(struct unicx *);
static void uni_putc(int, struct unicx *);
/*
* Encoding
*/
#define APP_BYTE(M, B) do { \
*(M)->b_wptr++ = (B); \
} while (0)
#define APP_16BIT(M, B) do { \
u_int _v = (B); \
*(M)->b_wptr++ = _v >> 8; \
*(M)->b_wptr++ = _v; \
} while (0)
#define APP_24BIT(M, B) do { \
u_int _v = (B); \
*(M)->b_wptr++ = _v >> 16; \
*(M)->b_wptr++ = _v >> 8; \
*(M)->b_wptr++ = _v; \
} while (0)
#define APP_32BIT(M, B) do { \
u_int _v = (B); \
*(M)->b_wptr++ = _v >> 24; \
*(M)->b_wptr++ = _v >> 16; \
*(M)->b_wptr++ = _v >> 8; \
*(M)->b_wptr++ = _v; \
} while (0)
#define APP_BUF(M, B, L) do { \
(void)memcpy((M)->b_wptr, (B), (L)); \
(M)->b_wptr += (L); \
} while (0)
#define APP_SUB_BYTE(M, T, B) do { APP_BYTE(M, T); APP_BYTE(M, B); } while (0)
#define APP_SUB_16BIT(M, T, B) do { APP_BYTE(M, T); APP_16BIT(M, B); } while (0)
#define APP_SUB_24BIT(M, T, B) do { APP_BYTE(M, T); APP_24BIT(M, B); } while (0)
#define APP_SUB_32BIT(M, T, B) do { APP_BYTE(M, T); APP_32BIT(M, B); } while (0)
#define APP_OPT(M, F, P, T) do { \
if ((F) & (P)) \
APP_BYTE((M), (T)); \
} while (0)
#define APP_OPT_BYTE(M, F, P, T, B) do { \
if ((F) & (P)) \
APP_SUB_BYTE((M), (T), (B)); \
} while (0)
#define APP_OPT_16BIT(M, F, P, T, B) do { \
if ((F) & (P)) \
APP_SUB_16BIT((M), (T), (B)); \
} while (0)
#define APP_OPT_24BIT(M, F, P, T, B) do { \
if ((F) & (P)) \
APP_SUB_24BIT((M), (T), (B)); \
} while (0)
#define START_IE(TYPE,CODE,LEN) \
u_int ielen; \
\
if (uni_check_ie(CODE, (union uni_ieall *)ie, cx)) \
return (-1); \
if (uni_encode_ie_hdr(msg, CODE, &ie->h, (LEN), cx)) \
return (0); \
\
ielen = msg->b_wptr - msg->b_rptr - 2;
#define START_IE2(TYPE,CODE,LEN,REALCODE) \
u_int ielen; \
\
if (uni_check_ie(CODE, (union uni_ieall *)ie, cx)) \
return (-1); \
if (uni_encode_ie_hdr(msg, REALCODE, &ie->h, (LEN), cx)) \
return (0); \
\
ielen = msg->b_wptr - msg->b_rptr - 2;
#define SET_IE_LEN(M) do { \
(M)->b_buf[ielen + 0] = \
(((M)->b_wptr - (M)->b_rptr) - ielen - 2) >> 8; \
(M)->b_buf[ielen + 1] = \
(((M)->b_wptr - (M)->b_rptr) - ielen - 2) >> 0; \
} while (0)
/***********************************************************************/
/*
* Decoding
*/
#define IE_START(ERR) \
if (IE_ISPRESENT(*ie)) \
return (0); \
if (ielen == 0) { \
IE_SETEMPTY(*ie); \
return (0); \
}
#define IE_END(IE) \
IE_SETPRESENT(*ie); \
if (uni_check_ie(UNI_IE_##IE, (union uni_ieall *)ie, cx) == 0) \
return (0); \
rej: \
ie->h.present = UNI_IE_ERROR | UNI_IE_PRESENT; \
return (1);
#define DEC_GETF3(ID, F, P) \
case UNI_##ID##_ID: \
if (ielen < 3) \
goto rej; \
ielen -= 3; \
if (!(P & UNI_##ID##_P)) { \
P |= UNI_##ID##_P; \
ie->F = *msg->b_rptr++ << 16; \
ie->F |= *msg->b_rptr++ << 8; \
ie->F |= *msg->b_rptr++; \
} else \
msg->b_rptr += 3; \
break;
#define DEC_GETF1(ID, F, P) \
case UNI_##ID##_ID: \
if (ielen < 1) \
goto rej; \
ielen--; \
if (!(P & UNI_##ID##_P)) { \
P |= UNI_##ID##_P; \
ie->F = *msg->b_rptr++; \
} else \
msg->b_rptr++; \
break;
#define PRINT_NPREFIX (sizeof(((struct unicx *)0)->prefix) / \
sizeof(((struct unicx *)0)->prefix[0]))
/*
* This is rather here than in privmsg.c because we need the APP macros.
*/
int
uni_encode_msg_hdr(struct uni_msg *msg, struct uni_msghdr *h,
enum uni_msgtype type, struct unicx *cx, int *mlen)
{
u_char byte;
uni_msg_ensure(msg, 9);
APP_BYTE(msg, cx->pnni ? PNNI_PROTO : UNI_PROTO);
APP_BYTE(msg, 3);
if(h->cref.cref >= 1<<23)
return -1;
APP_24BIT(msg, h->cref.cref | (h->cref.flag ? 0x800000 : 0));
APP_BYTE(msg, type);
byte = 0x80;
if(h->act != UNI_MSGACT_DEFAULT)
byte |= 0x10 | (h->act & 3);
if(cx->pnni && h->pass)
byte |= 0x08;
APP_BYTE(msg, byte);
*mlen = msg->b_wptr - msg->b_rptr;
APP_16BIT(msg, 0);
return 0;
}
/*
* Initialize printing. This must be called by all printing routines
* that are exported to the user.
*/
void
uni_print_init(char *buf, size_t bufsiz, struct unicx *cx)
{
if (cx->dont_init)
return;
cx->indent = 0;
cx->nprefix = 0;
cx->doindent = 0;
if (cx->tabsiz == 0)
cx->tabsiz = 4;
cx->buf = buf;
cx->bufsiz = bufsiz;
}
/*
* Append a character to the buffer if there is still space
*/
static void
uni_putc(int c, struct unicx *cx)
{
if(cx->bufsiz > 1) {
*cx->buf++ = c;
cx->bufsiz--;
*cx->buf = '\0';
}
}
void
uni_printf(struct unicx *cx, const char *fmt, ...)
{
u_int n;
va_list ap;
if(cx->bufsiz > 1) {
va_start(ap, fmt);
n = vsnprintf(cx->buf, cx->bufsiz, fmt, ap);
va_end(ap);
if(n > 0) {
if(n < cx->bufsiz) {
cx->bufsiz -= n;
cx->buf += n;
} else {
cx->buf += cx->bufsiz - 1;
cx->bufsiz = 1;
}
}
*cx->buf = '\0';
}
}
/*
* Print mode:
* 0 - print all into one line, fully prefixed
* 1 - print on multiple lines, full prefixed, but equal level
* entries on one line
* 2 - like 2, but only partial prefixed
* 3 - like 1, but each entry onto a new line
* 4 - like 2 + 3
*/
/*
* If we are in multiline mode, end the current line and set the
* flag, that we need indentation. But prevent double new lines.
*/
void
uni_print_eol(struct unicx *cx)
{
if (cx->multiline) {
if (!cx->doindent) {
uni_putc('\n', cx);
cx->doindent = 1;
}
}
}
/*
* New entry. Do the prefixing, indentation and spacing.
*/
static void
doprefix(struct unicx *cx, const char *s)
{
u_int i;
if(cx->multiline == 0) {
uni_putc(' ', cx);
for(i = 0; i < cx->nprefix; i++)
if(cx->prefix[i])
uni_printf(cx, "%s.", cx->prefix[i]);
} else if(cx->multiline == 1) {
if(cx->doindent) {
uni_printf(cx, "%*s", cx->indent * cx->tabsiz, "");
cx->doindent = 0;
} else
uni_putc(' ', cx);
for(i = 0; i < cx->nprefix; i++)
if(cx->prefix[i])
uni_printf(cx, "%s.", cx->prefix[i]);
} else if(cx->multiline == 2) {
if(cx->doindent) {
uni_printf(cx, "%*s", cx->indent * cx->tabsiz, "");
cx->doindent = 0;
} else
uni_putc(' ', cx);
} else if(cx->multiline == 3) {
if(cx->doindent)
cx->doindent = 0;
else
uni_putc('\n', cx);
uni_printf(cx, "%*s", cx->indent * cx->tabsiz, "");
for(i = 0; i < cx->nprefix; i++)
if(cx->prefix[i])
uni_printf(cx, "%s.", cx->prefix[i]);
} else if(cx->multiline == 4) {
if(cx->doindent)
cx->doindent = 0;
else
uni_putc('\n', cx);
uni_printf(cx, "%*s", cx->indent * cx->tabsiz, "");
}
uni_printf(cx, "%s", s);
}
static void
uni_entry(const char *s, struct unicx *cx)
{
doprefix(cx, s);
uni_putc('=', cx);
}
void
uni_print_flag(const char *s, struct unicx *cx)
{
doprefix(cx, s);
}
/*
* Start a deeper level of indendation. If multiline is in effect,
* we end the current line.
*/
void
uni_print_push_prefix(const char *prefix, struct unicx *cx)
{
if (cx->nprefix < PRINT_NPREFIX)
cx->prefix[cx->nprefix++] = prefix;
}
void
uni_print_pop_prefix(struct unicx *cx)
{
if (cx->nprefix > 0)
cx->nprefix--;
}
void
uni_print_tbl(const char *entry, u_int val, const struct uni_print_tbl *tbl,
struct unicx *cx)
{
if (entry)
uni_entry(entry, cx);
while (tbl->name) {
if (tbl->val == val) {
uni_printf(cx, "%s", tbl->name);
return;
}
tbl++;
}
uni_printf(cx, "ERROR(0x%x)", val);
}
void
uni_print_entry(struct unicx *cx, const char *e, const char *fmt, ...)
{
u_int n;
va_list ap;
uni_entry(e, cx);
if (cx->bufsiz > 1) {
va_start(ap, fmt);
n = vsnprintf(cx->buf, cx->bufsiz, fmt, ap);
va_end(ap);
if (n > 0) {
if (n < cx->bufsiz) {
cx->bufsiz -= n;
cx->buf += n;
} else {
cx->buf += cx->bufsiz - 1;
cx->bufsiz = 1;
}
}
*cx->buf = '\0';
}
}
/**********************************************************************/
/*
* Printing information elements.
*/
static int
uni_print_iehdr(const char *name, struct uni_iehdr *h, struct unicx *cx)
{
static const struct uni_print_tbl act_tab[] = {
MKT(UNI_IEACT_CLEAR, clear),
MKT(UNI_IEACT_IGNORE, ignore),
MKT(UNI_IEACT_REPORT, report),
MKT(UNI_IEACT_MSG_IGNORE, ignore-msg),
MKT(UNI_IEACT_MSG_REPORT, report-msg),
MKT(UNI_IEACT_DEFAULT, default),
EOT()
};
static const struct uni_print_tbl cod_tab[] = {
MKT(UNI_CODING_ITU, itut),
MKT(UNI_CODING_NET, atmf),
EOT()
};
uni_print_entry(cx, name, "(");
uni_print_tbl(NULL, h->act, act_tab, cx);
uni_putc(',', cx);
uni_print_tbl(NULL, h->coding, cod_tab, cx);
if(cx->pnni && h->pass)
uni_printf(cx, ",pass");
if(IE_ISEMPTY(*(struct uni_ie_aal *)h)) {
uni_printf(cx, ",empty)");
uni_print_eol(cx);
return 1;
}
if(IE_ISERROR(*(struct uni_ie_aal *)h)) {
uni_printf(cx, ",error)");
uni_print_eol(cx);
return 1;
}
uni_putc(')', cx);
uni_print_push_prefix(name, cx);
uni_print_eol(cx);
cx->indent++;
return 0;
}
static void
uni_print_ieend(struct unicx *cx)
{
uni_print_pop_prefix(cx);
uni_print_eol(cx);
cx->indent--;
}
void
uni_print_ie_internal(enum uni_ietype code, const union uni_ieall *ie,
struct unicx *cx)
{
const struct iedecl *iedecl;
if((iedecl = GET_IEDECL(code, ie->h.coding)) != NULL)
(*iedecl->print)(ie, cx);
}
void
uni_print_ie(char *buf, size_t size, enum uni_ietype code,
const union uni_ieall *ie, struct unicx *cx)
{
uni_print_init(buf, size, cx);
uni_print_ie_internal(code, ie, cx);
}
int
uni_check_ie(enum uni_ietype code, union uni_ieall *ie, struct unicx *cx)
{
const struct iedecl *iedecl = GET_IEDECL(code, ie->h.coding);
if (iedecl != NULL)
return (iedecl->check(ie, cx));
else
return (-1);
}
/*
* Decode a information element header.
* Returns -1 if the message is too short.
* Strip the header from the message.
* The header is stripped, even if it is too short.
*/
int
uni_decode_ie_hdr(enum uni_ietype *ietype, struct uni_iehdr *hdr,
struct uni_msg *msg, struct unicx *cx, u_int *ielen)
{
u_int len;
*ietype = (enum uni_ietype)0;
*ielen = 0;
hdr->present = 0;
hdr->coding = UNI_CODING_ITU;
hdr->act = UNI_IEACT_DEFAULT;
if ((len = uni_msg_len(msg)) == 0)
return (-1);
*ietype = *msg->b_rptr++;
if (--len == 0)
return (-1);
hdr->coding = (*msg->b_rptr >> 5) & 3;
hdr->present = 0;
switch (*msg->b_rptr & 0x17) {
case 0x10: case 0x11: case 0x12:
case 0x15: case 0x16:
hdr->act = *msg->b_rptr & 0x7;
break;
case 0x00: case 0x01: case 0x02: case 0x03:
case 0x04: case 0x05: case 0x06: case 0x07:
hdr->act = UNI_IEACT_DEFAULT;
break;
default:
/* Q.2931 5.7.2 last sentence */
hdr->act = UNI_IEACT_REPORT;
break;
}
if (cx->pnni && (*msg->b_rptr & 0x08))
hdr->pass = 1;
else
hdr->pass = 0;
msg->b_rptr++;
if (--len == 0) {
hdr->present = UNI_IE_ERROR | UNI_IE_PRESENT;
return (-1);
}
if (len < 2) {
msg->b_rptr += len;
hdr->present = UNI_IE_ERROR | UNI_IE_PRESENT;
return (-1);
}
*ielen = *msg->b_rptr++ << 8;
*ielen |= *msg->b_rptr++;
return (0);
}
/*
* Decode the body of an information element.
*/
int
uni_decode_ie_body(enum uni_ietype ietype, union uni_ieall *ie,
struct uni_msg *msg, u_int ielen, struct unicx *cx)
{
const struct iedecl *iedecl;
u_char *end;
int ret;
if (ielen > uni_msg_len(msg)) {
/*
* Information element too long -> content error.
* Q.2931 5.6.8.2
*/
msg->b_rptr = msg->b_wptr;
ie->h.present = UNI_IE_ERROR | UNI_IE_PRESENT;
return (-1);
}
if ((iedecl = GET_IEDECL(ietype, ie->h.coding)) == NULL) {
/*
* entirly unknown IE.
* Q.2931 5.6.8.1
*/
msg->b_rptr += ielen;
ie->h.present = UNI_IE_ERROR | UNI_IE_PRESENT;
return (-1);
}
if (ielen > iedecl->maxlen) {
/*
* Information element too long -> content error.
* Q.2931 5.6.8.2
*/
msg->b_rptr += iedecl->maxlen;
ie->h.present = UNI_IE_ERROR | UNI_IE_PRESENT;
return (-1);
}
end = msg->b_rptr + ielen;
ret = (*iedecl->decode)(ie, msg, ielen, cx);
msg->b_rptr = end;
return (ret);
}
int
uni_encode_ie(enum uni_ietype code, struct uni_msg *msg, union uni_ieall *ie,
struct unicx *cx)
{
const struct iedecl *iedecl = GET_IEDECL(code, ie->h.coding);
if (iedecl == NULL)
return (-1);
return (iedecl->encode(msg, ie, cx));
}
int
uni_encode_ie_hdr(struct uni_msg *msg, enum uni_ietype type,
struct uni_iehdr *h, u_int len, struct unicx *cx)
{
u_char byte;
uni_msg_ensure(msg, 4 + len);
*msg->b_wptr++ = type;
byte = 0x80 | (h->coding << 5);
if(h->act != UNI_IEACT_DEFAULT)
byte |= 0x10 | (h->act & 7);
if(cx->pnni)
byte |= h->pass << 3;
*msg->b_wptr++ = byte;
if(h->present & UNI_IE_EMPTY) {
*msg->b_wptr++ = 0;
*msg->b_wptr++ = 4;
return -1;
}
*msg->b_wptr++ = 0;
*msg->b_wptr++ = 0;
return 0;
}
/*
* Printing messages.
*/
static void
uni_print_cref_internal(const struct uni_cref *cref, struct unicx *cx)
{
uni_print_entry(cx, "cref", "%d.", cref->flag);
if (cref->cref == CREF_GLOBAL)
uni_printf(cx, "GLOBAL");
else if (cref->cref == CREF_DUMMY)
uni_printf(cx, "DUMMY");
else
uni_printf(cx, "%d", cref->cref);
}
void
uni_print_cref(char *str, size_t len, const struct uni_cref *cref,
struct unicx *cx)
{
uni_print_init(str, len, cx);
uni_print_cref_internal(cref, cx);
}
static void
uni_print_msghdr_internal(const struct uni_msghdr *hdr, struct unicx *cx)
{
static const struct uni_print_tbl tab[] = {
MKT(UNI_MSGACT_CLEAR, clear),
MKT(UNI_MSGACT_IGNORE, ignore),
MKT(UNI_MSGACT_REPORT, report),
MKT(UNI_MSGACT_DEFAULT, default),
EOT()
};
uni_print_cref_internal(&hdr->cref, cx);
uni_print_tbl("act", hdr->act, tab, cx);
if (cx->pnni)
uni_print_entry(cx, "pass", "%s", hdr->pass ? "yes" : "no");
}
void
uni_print_msghdr(char *str, size_t len, const struct uni_msghdr *hdr,
struct unicx *cx)
{
uni_print_init(str, len, cx);
uni_print_msghdr_internal(hdr, cx);
}
static void
uni_print_internal(const struct uni_all *msg, struct unicx *cx)
{
uni_entry("mtype", cx);
if(msg->mtype >= 256 || uni_msgtable[msg->mtype] == NULL) {
uni_printf(cx, "0x%02x(ERROR)", msg->mtype);
} else {
uni_printf(cx, "%s", uni_msgtable[msg->mtype]->name);
uni_print_msghdr_internal(&msg->u.hdr, cx);
cx->indent++;
uni_print_eol(cx);
(*uni_msgtable[msg->mtype]->print)(&msg->u, cx);
cx->indent--;
}
if(cx->multiline == 0)
uni_printf(cx, "\n");
}
void
uni_print(char *buf, size_t size, const struct uni_all *all, struct unicx *cx)
{
uni_print_init(buf, size, cx);
uni_print_internal(all, cx);
}
static void
uni_print_msg_internal(u_int mtype, const union uni_msgall *msg,
struct unicx *cx)
{
uni_entry("mtype", cx);
if (mtype >= 256 || uni_msgtable[mtype] == NULL) {
uni_printf(cx, "0x%02x(ERROR)", mtype);
} else {
uni_printf(cx, "%s", uni_msgtable[mtype]->name);
uni_print_msghdr_internal(&msg->hdr, cx);
cx->indent++;
uni_print_eol(cx);
(*uni_msgtable[mtype]->print)(msg, cx);
cx->indent--;
}
if(cx->multiline == 0)
uni_printf(cx, "\n");
}
void
uni_print_msg(char *buf, size_t size, u_int mtype, const union uni_msgall *all,
struct unicx *cx)
{
uni_print_init(buf, size, cx);
uni_print_msg_internal(mtype, all, cx);
}
void
uni_print_cx(char *buf, size_t size, struct unicx *cx)
{
static const char *acttab[] = {
"clr", /* 0x00 */
"ign", /* 0x01 */
"rep", /* 0x02 */
"x03", /* 0x03 */
"x04", /* 0x04 */
"mig", /* 0x05 */
"mrp", /* 0x06 */
"x07", /* 0x07 */
"def", /* 0x08 */
};
static const char *errtab[] = {
[UNI_IERR_UNK] = "unk", /* unknown IE */
[UNI_IERR_LEN] = "len", /* length error */
[UNI_IERR_BAD] = "bad", /* content error */
[UNI_IERR_ACC] = "acc", /* access element discarded */
[UNI_IERR_MIS] = "mis", /* missing IE */
};
u_int i;
uni_print_init(buf, size, cx);
uni_printf(cx, "q2932 %d\n", cx->q2932);
uni_printf(cx, "pnni %d\n", cx->pnni);
uni_printf(cx, "git_hard %d\n", cx->git_hard);
uni_printf(cx, "bearer_hard %d\n", cx->bearer_hard);
uni_printf(cx, "cause_hard %d\n", cx->cause_hard);
uni_printf(cx, "multiline %d\n", cx->multiline);
uni_printf(cx, "tabsiz %d\n", cx->tabsiz);
uni_printf(cx, "errcnt %d (", cx->errcnt);
for(i = 0; i < cx->errcnt; i++) {
uni_printf(cx, "%02x[%s,%s%s]", cx->err[i].ie,
errtab[cx->err[i].err], acttab[cx->err[i].act],
cx->err[i].man ? ",M" : "");
if(i != cx->errcnt - 1)
uni_putc(' ', cx);
}
uni_printf(cx, ")\n");
}
#include <netnatm/msg/uni_ietab.h>
/*********************************************************************
*
* Cause
*
* References for this IE are:
*
* Q.2931 pp. 69 (just a pointer to Q.2610)
* Q.2610 (this is a small diff to Q.850)
* Q.850 !!
* UNI4.0 pp. 15
* PNNI1.0 p. 198
*
* ITU-T and NET coding for different values.
*/
static const struct causetab {
const char *str;
enum uni_diag diag;
} itu_causes[128] = {
#define D(NAME,VAL,DIAG,STD,STR) [UNI_CAUSE_##NAME] = { STR, UNI_DIAG_##DIAG },
#define N(NAME,VAL,DIAG,STD,STR)
UNI_DECLARE_CAUSE_VALUES
#undef D
#undef N
}, net_causes[128] = {
#define D(NAME,VAL,DIAG,STD,STR)
#define N(NAME,VAL,DIAG,STD,STR) [UNI_CAUSE_##NAME] = { STR, UNI_DIAG_##DIAG },
UNI_DECLARE_CAUSE_VALUES
#undef D
#undef N
};
enum uni_diag
uni_diag(enum uni_cause cause, enum uni_coding code)
{
if (cause >= 128)
return (UNI_DIAG_NONE);
if (code == UNI_CODING_NET)
if (net_causes[cause].str != NULL)
return (net_causes[cause].diag);
if (itu_causes[cause].str != NULL)
return (itu_causes[cause].diag);
return (UNI_DIAG_NONE);
}
/**********************************************************************/
static void
print_cause(struct unicx *cx, struct uni_ie_cause *ie,
const struct causetab *tab1, const struct causetab *tab2)
{
static const struct uni_print_tbl loc_tbl[] = {
MKT(UNI_CAUSE_LOC_USER, user),
MKT(UNI_CAUSE_LOC_PRIVLOC, priv-net:loc-user),
MKT(UNI_CAUSE_LOC_PUBLOC, pub-net:loc-user),
MKT(UNI_CAUSE_LOC_TRANSIT, transit-net),
MKT(UNI_CAUSE_LOC_PUBREM, pub-net:rem-user),
MKT(UNI_CAUSE_LOC_PRIVREM, priv-net:rem-user),
MKT(UNI_CAUSE_LOC_INTERNAT, int-net),
MKT(UNI_CAUSE_LOC_BEYOND, beyond),
EOT()
};
static const struct uni_print_tbl pu_tbl[] = {
MKT(UNI_CAUSE_PU_PROVIDER, provider),
MKT(UNI_CAUSE_PU_USER, user),
EOT()
};
static const struct uni_print_tbl na_tbl[] = {
MKT(UNI_CAUSE_NA_NORMAL, normal),
MKT(UNI_CAUSE_NA_ABNORMAL, abnormal),
EOT()
};
static const struct uni_print_tbl cond_tbl[] = {
MKT(UNI_CAUSE_COND_UNKNOWN, unknown),
MKT(UNI_CAUSE_COND_PERM, permanent),
MKT(UNI_CAUSE_COND_TRANS, transient),
EOT()
};
static const struct uni_print_tbl rej_tbl[] = {
MKT(UNI_CAUSE_REASON_USER, user),
MKT(UNI_CAUSE_REASON_IEMISS, ie-missing),
MKT(UNI_CAUSE_REASON_IESUFF, ie-not-suff),
EOT()
};
char buf[100], *s;
u_int i;
if (uni_print_iehdr("cause", &ie->h, cx))
return;
if (ie->cause < 128 && tab1[ie->cause].str)
strcpy(buf, tab1[ie->cause].str);
else if (ie->cause < 128 && tab2 != NULL && tab2[ie->cause].str != NULL)
strcpy(buf, tab2[ie->cause].str);
else {
sprintf(buf, "UNKNOWN-%u", ie->cause);
}
for (s = buf; *s != '\0'; s++)
if (*s == ' ')
*s = '_';
uni_print_entry(cx, "cause", "%s", buf);
uni_print_tbl("loc", ie->loc, loc_tbl, cx);
if (ie->h.present & UNI_CAUSE_COND_P) {
uni_print_tbl("pu", ie->u.cond.pu, pu_tbl, cx);
uni_print_tbl("na", ie->u.cond.na, na_tbl, cx);
uni_print_tbl("condition", ie->u.cond.cond, cond_tbl, cx);
}
if (ie->h.present & UNI_CAUSE_REJ_P) {
uni_print_tbl("reject", ie->u.rej.reason, rej_tbl, cx);
}
if (ie->h.present & UNI_CAUSE_REJ_USER_P) {
uni_print_entry(cx, "user", "%u", ie->u.rej.user);
}
if (ie->h.present & UNI_CAUSE_REJ_IE_P) {
uni_print_entry(cx, "ie", "%u", ie->u.rej.ie);
}
if (ie->h.present & UNI_CAUSE_IE_P) {
uni_print_entry(cx, "ie", "(");
for (i = 0; i < ie->u.ie.len; i++) {
if (i)
uni_putc(',', cx);
uni_printf(cx, "0x%02x", ie->u.ie.ie[i]);
}
uni_putc(')', cx);
}
if (ie->h.present & UNI_CAUSE_TRAFFIC_P) {
uni_print_entry(cx, "traffic", "(");
for (i = 0; i < ie->u.traffic.len; i++) {
if (i)
uni_putc(',', cx);
uni_printf(cx, "0x%02x", ie->u.traffic.traffic[i]);
}
uni_putc(')', cx);
}
if (ie->h.present & UNI_CAUSE_VPCI_P) {
uni_print_entry(cx, "vpci", "(%u,%u)", ie->u.vpci.vpci, ie->u.vpci.vci);
}
if (ie->h.present & UNI_CAUSE_MTYPE_P) {
uni_print_entry(cx, "mtype", "%u", ie->u.mtype);
}
if (ie->h.present & UNI_CAUSE_TIMER_P) {
for (i = 0, s = buf; i < 3; i++) {
if (ie->u.timer[i] < ' ') {
*s++ = '^';
*s++ = ie->u.timer[i] + '@';
} else if (ie->u.timer[i] <= '~')
*s++ = ie->u.timer[i];
else {
*s++ = '\\';
*s++ = ie->u.timer[i] / 0100 + '0';
*s++ = (ie->u.timer[i] % 0100) / 010 + '0';
*s++ = ie->u.timer[i] % 010 + '0';
}
}
*s++ = '\0';
uni_print_entry(cx, "timer", "\"%s\"", buf);
}
if (ie->h.present & UNI_CAUSE_TNS_P) {
uni_print_eol(cx);
uni_print_ie_internal(UNI_IE_TNS, (union uni_ieall *)&ie->u.tns, cx);
}
if (ie->h.present & UNI_CAUSE_NUMBER_P) {
uni_print_eol(cx);
uni_print_ie_internal(UNI_IE_CALLED, (union uni_ieall *)&ie->u.number, cx);
}
if (ie->h.present & UNI_CAUSE_ATTR_P) {
uni_print_entry(cx, "attr", "(");
for (i = 0; i < ie->u.attr.nattr; i++) {
uni_printf(cx, "(%u", ie->u.attr.attr[i][0]);
if (!(ie->u.attr.attr[i][0] & 0x80)) {
uni_printf(cx, ",%u", ie->u.attr.attr[i][1]);
if (!(ie->u.attr.attr[i][1] & 0x80))
uni_printf(cx, ",%u",
ie->u.attr.attr[i][2]);
}
uni_putc(')', cx);
}
}
uni_print_ieend(cx);
}
DEF_IE_PRINT(itu, cause)
{
print_cause(cx, ie, itu_causes, NULL);
}
DEF_IE_PRINT(net, cause)
{
print_cause(cx, ie, net_causes, itu_causes);
}
const char *
uni_ie_cause2str(enum uni_coding coding, u_int cause)
{
if (cause < 128) {
if (coding == UNI_CODING_ITU)
return (itu_causes[cause].str);
if (coding == UNI_CODING_NET) {
if (net_causes[cause].str != NULL)
return (net_causes[cause].str);
return (itu_causes[cause].str);
}
}
return (NULL);
}
/**********************************************************************/
static int
check_cause(struct uni_ie_cause *ie, struct unicx *cx,
const struct causetab *tab1, const struct causetab *tab2)
{
static const u_int mask =
UNI_CAUSE_COND_P | UNI_CAUSE_REJ_P | UNI_CAUSE_REJ_USER_P |
UNI_CAUSE_REJ_IE_P | UNI_CAUSE_IE_P | UNI_CAUSE_TRAFFIC_P |
UNI_CAUSE_VPCI_P | UNI_CAUSE_MTYPE_P | UNI_CAUSE_TIMER_P |
UNI_CAUSE_TNS_P | UNI_CAUSE_NUMBER_P | UNI_CAUSE_ATTR_P |
UNI_CAUSE_PARAM_P;
const struct causetab *ptr;
if (ie->cause >= 128)
return (-1);
switch (ie->loc) {
default:
return (-1);
case UNI_CAUSE_LOC_USER:
case UNI_CAUSE_LOC_PRIVLOC:
case UNI_CAUSE_LOC_PUBLOC:
case UNI_CAUSE_LOC_TRANSIT:
case UNI_CAUSE_LOC_PUBREM:
case UNI_CAUSE_LOC_PRIVREM:
case UNI_CAUSE_LOC_INTERNAT:
case UNI_CAUSE_LOC_BEYOND:
break;
}
if (tab1[ie->cause].str != NULL)
ptr = &tab1[ie->cause];
else if (tab2 != NULL && tab2[ie->cause].str != NULL)
ptr = &tab2[ie->cause];
else
return (cx->cause_hard ? -1 : 0);
switch (ptr->diag) {
case UNI_DIAG_NONE:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
break;
}
break;
case UNI_DIAG_COND:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_COND_P:
break;
}
break;
case UNI_DIAG_REJ:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_REJ_P:
case UNI_CAUSE_REJ_P | UNI_CAUSE_REJ_USER_P:
case UNI_CAUSE_REJ_P | UNI_CAUSE_REJ_IE_P:
break;
}
break;
case UNI_DIAG_CRATE:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_TRAFFIC_P:
break;
}
break;
case UNI_DIAG_IE:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_IE_P:
break;
}
break;
case UNI_DIAG_CHANID:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_VPCI_P:
break;
}
break;
case UNI_DIAG_MTYPE:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_MTYPE_P:
break;
}
break;
case UNI_DIAG_TIMER:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_TIMER_P:
break;
}
break;
case UNI_DIAG_TNS:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_TNS_P:
break;
}
break;
case UNI_DIAG_NUMBER:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_NUMBER_P:
break;
}
break;
case UNI_DIAG_ATTR:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_ATTR_P:
break;
}
break;
case UNI_DIAG_PARAM:
switch (ie->h.present & mask) {
default:
if (cx->cause_hard)
return (-1);
break;
case 0:
case UNI_CAUSE_PARAM_P:
break;
}
break;
}
if (ie->h.present & UNI_CAUSE_COND_P) {
switch (ie->u.cond.pu) {
default:
return (-1);
case UNI_CAUSE_PU_PROVIDER:
case UNI_CAUSE_PU_USER:
break;
}
switch (ie->u.cond.na) {
default:
return (-1);
case UNI_CAUSE_NA_NORMAL:
case UNI_CAUSE_NA_ABNORMAL:
break;
}
switch (ie->u.cond.cond) {
default:
return (-1);
case UNI_CAUSE_COND_UNKNOWN:
case UNI_CAUSE_COND_PERM:
case UNI_CAUSE_COND_TRANS:
break;
}
}
if (ie->h.present & UNI_CAUSE_REJ_P) {
switch (ie->u.rej.reason) {
default:
return (-1);
case UNI_CAUSE_REASON_USER:
switch (ie->h.present & mask) {
default:
return (-1);
case UNI_CAUSE_REJ_P:
case UNI_CAUSE_REJ_P | UNI_CAUSE_REJ_USER_P:
break;
}
break;
case UNI_CAUSE_REASON_IEMISS:
case UNI_CAUSE_REASON_IESUFF:
switch (ie->h.present & mask) {
default:
return (-1);
case UNI_CAUSE_REJ_P:
case UNI_CAUSE_REJ_P | UNI_CAUSE_REJ_IE_P:
break;
}
break;
}
}
if (ie->h.present & UNI_CAUSE_IE_P) {
if (ie->u.ie.len == 0 || ie->u.ie.len > UNI_CAUSE_IE_N)
return (-1);
}
if (ie->h.present & UNI_CAUSE_TRAFFIC_P) {
if (ie->u.traffic.len == 0 ||
ie->u.traffic.len > UNI_CAUSE_TRAFFIC_N)
return (-1);
}
if (ie->h.present & UNI_CAUSE_TNS_P) {
if (uni_check_ie(UNI_IE_TNS, (union uni_ieall *)&ie->u.tns, cx))
return (-1);
}
if (ie->h.present & UNI_CAUSE_NUMBER_P) {
if(uni_check_ie(UNI_IE_CALLED, (union uni_ieall *)&ie->u.number, cx))
return (-1);
}
if (ie->h.present & UNI_CAUSE_ATTR_P) {
if(ie->u.attr.nattr > UNI_CAUSE_ATTR_N || ie->u.attr.nattr == 0)
return (-1);
}
if (ie->h.present & UNI_CAUSE_PARAM_P) {
cx = cx;
}
return (0);
}
DEF_IE_CHECK(itu, cause)
{
return (check_cause(ie, cx, itu_causes, NULL));
}
DEF_IE_CHECK(net, cause)
{
return (check_cause(ie, cx, net_causes, itu_causes));
}
/**********************************************************************/
static int
encode_cause(struct uni_msg *msg, struct uni_ie_cause *ie, struct unicx *cx)
{
u_int i;
START_IE(cause, UNI_IE_CAUSE, 30);
if (IE_ISERROR(*ie)) {
APP_BYTE(msg, 0x00 | ie->loc);
} else {
APP_BYTE(msg, 0x80 | ie->loc);
}
APP_BYTE(msg, 0x80 | ie->cause);
if (ie->h.present & UNI_CAUSE_COND_P)
APP_BYTE(msg, 0x80 | (ie->u.cond.pu << 3) |
(ie->u.cond.na << 2) | ie->u.cond.cond);
else if (ie->h.present & UNI_CAUSE_REJ_P) {
APP_BYTE(msg, 0x80 | (ie->u.rej.reason << 2) | ie->u.rej.cond);
if (ie->h.present & UNI_CAUSE_REJ_USER_P)
APP_BYTE(msg, ie->u.rej.user);
else if (ie->h.present & UNI_CAUSE_REJ_IE_P)
APP_BYTE(msg, ie->u.rej.ie);
} else if(ie->h.present & UNI_CAUSE_IE_P)
APP_BUF(msg, ie->u.ie.ie, ie->u.ie.len);
else if (ie->h.present & UNI_CAUSE_TRAFFIC_P)
APP_BUF(msg, ie->u.traffic.traffic, ie->u.traffic.len);
else if (ie->h.present & UNI_CAUSE_VPCI_P) {
APP_BYTE(msg, (ie->u.vpci.vpci >> 8));
APP_BYTE(msg, (ie->u.vpci.vpci >> 0));
APP_BYTE(msg, (ie->u.vpci.vci >> 8));
APP_BYTE(msg, (ie->u.vpci.vci >> 0));
} else if (ie->h.present & UNI_CAUSE_MTYPE_P)
APP_BYTE(msg, ie->u.mtype);
else if (ie->h.present & UNI_CAUSE_TIMER_P) {
APP_BYTE(msg, ie->u.timer[0]);
APP_BYTE(msg, ie->u.timer[1]);
APP_BYTE(msg, ie->u.timer[2]);
} else if (ie->h.present & UNI_CAUSE_TNS_P)
uni_encode_ie(UNI_IE_TNS, msg,
(union uni_ieall *)&ie->u.tns, cx);
else if (ie->h.present & UNI_CAUSE_NUMBER_P)
uni_encode_ie(UNI_IE_CALLED, msg,
(union uni_ieall *)&ie->u.number, cx);
else if (ie->h.present & UNI_CAUSE_ATTR_P) {
for (i = 0; i < ie->u.attr.nattr; i++) {
APP_BYTE(msg, ie->u.attr.attr[i][0]);
if (!ie->u.attr.attr[i][0]) {
APP_BYTE(msg, ie->u.attr.attr[i][1]);
if (!ie->u.attr.attr[i][1])
APP_BYTE(msg, ie->u.attr.attr[i][2]);
}
}
} else if (ie->h.present & UNI_CAUSE_PARAM_P)
APP_BYTE(msg, ie->u.param);
SET_IE_LEN(msg);
return (0);
}
DEF_IE_ENCODE(itu, cause)
{
return encode_cause(msg, ie, cx);
}
DEF_IE_ENCODE(net, cause)
{
return encode_cause(msg, ie, cx);
}
/**********************************************************************/
static int
decode_cause(struct uni_ie_cause *ie, struct uni_msg *msg, u_int ielen,
struct unicx *cx, const struct causetab *tab1, const struct causetab *tab2)
{
u_char c;
const struct causetab *ptr;
enum uni_ietype ietype;
u_int xielen;
IE_START(;);
if(ielen < 2 || ielen > 30)
goto rej;
c = *msg->b_rptr++;
ielen--;
if(!(c & 0x80))
goto rej;
ie->loc = c & 0xf;
c = *msg->b_rptr++;
ielen--;
if(!(c & 0x80))
goto rej;
ie->cause = c & 0x7f;
if(tab1[ie->cause].str != NULL)
ptr = &tab1[ie->cause];
else if(tab2 != NULL && tab2[ie->cause].str != NULL)
ptr = &tab2[ie->cause];
else {
ptr = NULL;
ielen = 0; /* ignore diags */
}
if(ielen) {
switch(ptr->diag) {
case UNI_DIAG_NONE:
break;
case UNI_DIAG_COND:
if(ielen < 1)
goto rej;
c = *msg->b_rptr++;
ielen--;
ie->h.present |= UNI_CAUSE_COND_P;
ie->u.cond.pu = (c >> 3) & 1;
ie->u.cond.na = (c >> 2) & 1;
ie->u.cond.cond = c & 3;
if(!(c & 0x80))
goto rej;
break;
case UNI_DIAG_REJ:
if(ielen < 1)
goto rej;
c = *msg->b_rptr++;
ielen--;
ie->h.present |= UNI_CAUSE_REJ_P;
ie->u.rej.reason = (c >> 2) & 0x1f;
ie->u.rej.cond = c & 3;
if(!(c & 0x80))
goto rej;
if(ielen > 0) {
c = *msg->b_rptr++;
ielen--;
switch(ie->u.rej.reason) {
case UNI_CAUSE_REASON_USER:
ie->h.present |= UNI_CAUSE_REJ_USER_P;
ie->u.rej.user = c;
break;
case UNI_CAUSE_REASON_IEMISS:
case UNI_CAUSE_REASON_IESUFF:
ie->h.present |= UNI_CAUSE_REJ_IE_P;
ie->u.rej.ie = c;
break;
}
}
break;
case UNI_DIAG_CRATE:
ie->h.present |= UNI_CAUSE_TRAFFIC_P;
while(ielen && ie->u.traffic.len < UNI_CAUSE_TRAFFIC_N) {
ie->u.traffic.traffic[ie->u.traffic.len++] =
*msg->b_rptr++;
ielen--;
}
break;
case UNI_DIAG_IE:
ie->h.present |= UNI_CAUSE_IE_P;
while(ielen && ie->u.ie.len < UNI_CAUSE_IE_N) {
ie->u.ie.ie[ie->u.ie.len++] = *msg->b_rptr++;
ielen--;
}
break;
case UNI_DIAG_CHANID:
if(ielen < 4)
break;
ie->h.present |= UNI_CAUSE_VPCI_P;
ie->u.vpci.vpci = *msg->b_rptr++ << 8;
ie->u.vpci.vpci |= *msg->b_rptr++;
ie->u.vpci.vci = *msg->b_rptr++ << 8;
ie->u.vpci.vci |= *msg->b_rptr++;
ielen -= 4;
break;
case UNI_DIAG_MTYPE:
ie->h.present |= UNI_CAUSE_MTYPE_P;
ie->u.mtype = *msg->b_rptr++;
ielen--;
break;
case UNI_DIAG_TIMER:
if(ielen < 3)
break;
ie->h.present |= UNI_CAUSE_TIMER_P;
ie->u.timer[0] = *msg->b_rptr++;
ie->u.timer[1] = *msg->b_rptr++;
ie->u.timer[2] = *msg->b_rptr++;
ielen -= 3;
break;
case UNI_DIAG_TNS:
if(ielen < 4)
break;
if(uni_decode_ie_hdr(&ietype, &ie->u.tns.h, msg, cx, &xielen))
break;
if(ietype != UNI_IE_TNS)
break;
if(uni_decode_ie_body(ietype,
(union uni_ieall *)&ie->u.tns, msg, xielen, cx))
break;
ie->h.present |= UNI_CAUSE_TNS_P;
break;
case UNI_DIAG_NUMBER:
if(ielen < 4)
break;
if(uni_decode_ie_hdr(&ietype, &ie->u.number.h, msg, cx, &xielen))
break;
if(ietype != UNI_IE_CALLED)
break;
if(uni_decode_ie_body(ietype,
(union uni_ieall *)&ie->u.number, msg, xielen, cx))
break;
ie->h.present |= UNI_CAUSE_NUMBER_P;
break;
case UNI_DIAG_ATTR:
ie->h.present |= UNI_CAUSE_ATTR_P;
while(ielen > 0 && ie->u.attr.nattr < UNI_CAUSE_ATTR_N) {
c = *msg->b_rptr++;
ie->u.attr.attr[ie->u.attr.nattr][0] = c;
ielen--;
if(ielen > 0 && !(c & 0x80)) {
c = *msg->b_rptr++;
ie->u.attr.attr[ie->u.attr.nattr][1] = c;
ielen--;
if(ielen > 0 && !(c & 0x80)) {
c = *msg->b_rptr++;
ie->u.attr.attr[ie->u.attr.nattr][2] = c;
ielen--;
}
}
}
break;
case UNI_DIAG_PARAM:
ie->h.present |= UNI_CAUSE_PARAM_P;
ie->u.param = *msg->b_rptr++;
ielen--;
break;
}
}
IE_END(CAUSE);
}
DEF_IE_DECODE(itu, cause)
{
return decode_cause(ie, msg, ielen, cx, itu_causes, NULL);
}
DEF_IE_DECODE(net, cause)
{
return decode_cause(ie, msg, ielen, cx, net_causes, itu_causes);
}
/*********************************************************************
*
* Callstate
*
* References for this IE are:
*
* Q.2931 pp. 59...60
* UNI4.0 pp. 14
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, callstate)
{
static const struct uni_print_tbl tbl[] = {
MKT(UNI_CALLSTATE_U0, U0/N0/REST0),
MKT(UNI_CALLSTATE_U1, U1/N1),
MKT(UNI_CALLSTATE_U3, U3/N3),
MKT(UNI_CALLSTATE_U4, U4/N4),
MKT(UNI_CALLSTATE_U6, U6/N6),
MKT(UNI_CALLSTATE_U7, U7/N7),
MKT(UNI_CALLSTATE_U8, U8/N8),
MKT(UNI_CALLSTATE_U9, U9/N9),
MKT(UNI_CALLSTATE_U10, U10/N10),
MKT(UNI_CALLSTATE_U11, U11/N11),
MKT(UNI_CALLSTATE_U12, U12/N12),
MKT(UNI_CALLSTATE_REST1,REST1),
MKT(UNI_CALLSTATE_REST2,REST2),
MKT(UNI_CALLSTATE_U13, U13/N13),
MKT(UNI_CALLSTATE_U14, U14/N14),
EOT()
};
if(uni_print_iehdr("callstate", &ie->h, cx))
return;
uni_print_tbl("state", ie->state, tbl, cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, callstate)
{
cx = cx;
switch(ie->state) {
default:
return -1;
case UNI_CALLSTATE_U0:
case UNI_CALLSTATE_U1:
case UNI_CALLSTATE_U3:
case UNI_CALLSTATE_U4:
case UNI_CALLSTATE_U6:
case UNI_CALLSTATE_U7:
case UNI_CALLSTATE_U8:
case UNI_CALLSTATE_U9:
case UNI_CALLSTATE_U10:
case UNI_CALLSTATE_U11:
case UNI_CALLSTATE_U12:
case UNI_CALLSTATE_REST1:
case UNI_CALLSTATE_REST2:
case UNI_CALLSTATE_U13:
case UNI_CALLSTATE_U14:
break;
}
return 0;
}
DEF_IE_ENCODE(itu, callstate)
{
START_IE(callstate, UNI_IE_CALLSTATE, 1);
APP_BYTE(msg, ie->state);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, callstate)
{
IE_START(;);
if(ielen != 1)
goto rej;
ie->state = *msg->b_rptr++ & 0x3f;
ielen--;
IE_END(CALLSTATE);
}
/*********************************************************************
*
* Facility Information.
*
* References for this IE are:
*
* Q.2932.1
*
* The standard allows only ROSE as protocol. We allow everything up to the
* maximum size.
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, facility)
{
u_int i;
if(uni_print_iehdr("facility", &ie->h, cx))
return;
if(ie->proto == UNI_FACILITY_ROSE)
uni_print_entry(cx, "proto", "rose");
else
uni_print_entry(cx, "proto", "0x%02x", ie->proto);
uni_print_entry(cx, "len", "%u", ie->len);
uni_print_entry(cx, "info", "(");
for(i = 0; i < ie->len; i++)
uni_printf(cx, "%s0x%02x", i == 0 ? "" : " ", ie->apdu[i]);
uni_printf(cx, ")");
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, facility)
{
cx = cx;
if(ie->len > UNI_FACILITY_MAXAPDU)
return -1;
return 0;
}
DEF_IE_ENCODE(itu, facility)
{
START_IE(facility, UNI_IE_FACILITY, 1 + ie->len);
APP_BYTE(msg, ie->proto | 0x80);
APP_BUF(msg, ie->apdu, ie->len);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, facility)
{
u_char c;
IE_START(;);
if(ielen > UNI_FACILITY_MAXAPDU + 1 || ielen < 1)
goto rej;
ie->proto = (c = *msg->b_rptr++) & 0x1f;
ielen--;
if((c & 0xe0) != 0x80)
goto rej;
ie->len = ielen;
ielen = 0;
(void)memcpy(ie->apdu, msg->b_rptr, ie->len);
msg->b_rptr += ie->len;
IE_END(FACILITY);
}
/*********************************************************************
*
* Notification Indicator
*
* References for this IE are:
*
* Q.2931 p. 76
* UNI4.0 p. 17
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, notify)
{
u_int i;
if(uni_print_iehdr("notify", &ie->h, cx))
return;
uni_print_entry(cx, "len", "%u", ie->len);
uni_print_entry(cx, "info", "(");
for(i = 0; i < ie->len; i++)
uni_printf(cx, "%s0x%02x", i == 0 ? "" : " ", ie->notify[i]);
uni_printf(cx, ")");
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, notify)
{
cx = cx;
if(ie->len > UNI_NOTIFY_MAXLEN)
return -1;
return 0;
}
DEF_IE_ENCODE(itu, notify)
{
START_IE(notify, UNI_IE_NOTIFY, ie->len);
APP_BUF(msg, ie->notify, ie->len);
if (IE_ISERROR(*ie)) {
/* make it too long */
u_int i = ie->len;
while (i < UNI_NOTIFY_MAXLEN + 1) {
APP_BYTE(msg, 0x00);
i++;
}
}
SET_IE_LEN(msg);
return (0);
}
DEF_IE_DECODE(itu, notify)
{
IE_START(;);
if (ielen > UNI_NOTIFY_MAXLEN || ielen < 1)
goto rej;
ie->len = ielen;
ielen = 0;
(void)memcpy(ie->notify, msg->b_rptr, ie->len);
msg->b_rptr += ie->len;
IE_END(NOTIFY);
}
/*********************************************************************
*
* End-to-end transit delay.
*
* References for this IE are:
*
* Q.2931 pp. 70...71
* UNI4.0 pp. 69...70
* PNNI1.0 pp. 198...200
*
* Not clear, whether the new indicator should be used with NET coding or
* not.
*
* Only ITU-T coding allowed.
*/
static void
print_eetd(struct uni_ie_eetd *ie, struct unicx *cx)
{
if (uni_print_iehdr("eetd", &ie->h, cx))
return;
if (ie->h.present & UNI_EETD_CUM_P)
uni_print_entry(cx, "cum", "%u", ie->cumulative);
if (ie->h.present & UNI_EETD_MAX_P) {
if (ie->maximum == UNI_EETD_ANYMAX)
uni_print_entry(cx, "max", "any");
else
uni_print_entry(cx, "max", "%u", ie->maximum);
}
if (ie->h.present & UNI_EETD_PCTD_P)
uni_print_entry(cx, "pnni_cum", "%u", ie->pctd);
if (ie->h.present & UNI_EETD_PMTD_P)
uni_print_entry(cx, "pnni_max", "%u", ie->pmtd);
if (ie->h.present & UNI_EETD_NET_P)
uni_print_flag("netgen", cx);
uni_print_ieend(cx);
}
DEF_IE_PRINT(itu, eetd)
{
print_eetd(ie, cx);
}
DEF_IE_PRINT(net, eetd)
{
print_eetd(ie, cx);
}
DEF_IE_CHECK(itu, eetd)
{
cx = cx;
if (!(ie->h.present & UNI_EETD_CUM_P))
return (-1);
if (ie->h.present & (UNI_EETD_PMTD_P | UNI_EETD_PCTD_P))
return (-1);
return (0);
}
DEF_IE_CHECK(net, eetd)
{
if (!cx->pnni) {
if (!(ie->h.present & UNI_EETD_CUM_P))
return (-1);
if (ie->h.present & (UNI_EETD_PMTD_P | UNI_EETD_PCTD_P))
return (-1);
} else {
if (ie->h.present & UNI_EETD_MAX_P)
return (-1);
if ((ie->h.present & UNI_EETD_CUM_P) &&
(ie->h.present & UNI_EETD_PCTD_P))
return (-1);
}
return (0);
}
DEF_IE_ENCODE(itu, eetd)
{
START_IE(eetd, UNI_IE_EETD, 9);
if (ie->h.present & UNI_EETD_CUM_P) {
APP_BYTE(msg, UNI_EETD_CTD_ID);
APP_16BIT(msg, ie->cumulative);
}
if (ie->h.present & UNI_EETD_MAX_P) {
APP_BYTE(msg, UNI_EETD_MTD_ID);
APP_16BIT(msg, ie->maximum);
}
if (ie->h.present & UNI_EETD_PMTD_P) {
APP_BYTE(msg, UNI_EETD_PMTD_ID);
APP_24BIT(msg, ie->pmtd);
}
if (ie->h.present & UNI_EETD_PCTD_P) {
APP_BYTE(msg, UNI_EETD_PCTD_ID);
APP_24BIT(msg, ie->pctd);
}
if (ie->h.present & UNI_EETD_NET_P) {
APP_BYTE(msg, UNI_EETD_NET_ID);
}
SET_IE_LEN(msg);
return (0);
}
DEF_IE_ENCODE(net, eetd)
{
return (uni_ie_encode_itu_eetd(msg, ie, cx));
}
DEF_IE_DECODE(itu, eetd)
{
IE_START(;);
while (ielen > 0) {
switch (ielen--, *msg->b_rptr++) {
case UNI_EETD_CTD_ID:
if (ielen < 2)
goto rej;
ie->h.present |= UNI_EETD_CUM_P;
ie->cumulative = *msg->b_rptr++ << 8;
ie->cumulative |= *msg->b_rptr++;
ielen -= 2;
break;
case UNI_EETD_MTD_ID:
if (ielen < 2)
goto rej;
ie->h.present |= UNI_EETD_MAX_P;
ie->maximum = *msg->b_rptr++ << 8;
ie->maximum |= *msg->b_rptr++;
ielen -= 2;
break;
case UNI_EETD_PCTD_ID:
if (ielen < 3)
goto rej;
ie->h.present |= UNI_EETD_PCTD_P;
ie->pctd = *msg->b_rptr++ << 16;
ie->pctd |= *msg->b_rptr++ << 8;
ie->pctd |= *msg->b_rptr++;
ielen -= 3;
break;
case UNI_EETD_PMTD_ID:
if (ielen < 3)
goto rej;
ie->h.present |= UNI_EETD_PMTD_P;
ie->pmtd = *msg->b_rptr++ << 16;
ie->pmtd |= *msg->b_rptr++ << 8;
ie->pmtd |= *msg->b_rptr++;
ielen -= 3;
break;
case UNI_EETD_NET_ID:
ie->h.present |= UNI_EETD_NET_P;
break;
default:
goto rej;
}
}
IE_END(EETD);
}
DEF_IE_DECODE(net, eetd)
{
return (uni_ie_decode_itu_eetd(ie, msg, ielen, cx));
}
/*********************************************************************
*
* Called address
* Called subaddress
* Calling address
* Calling subaddress
* Connected address
* Connected subaddress
*
* References for this IE are:
*
* Q.2931 pp. 60...68
* ...A4 pp. 27...36
* UNI4.0 pp. 14...15
* Q.2951 pp. 28...40
*
* It is assumed, that the coding of the addr arrays is ok.
*
* Only ITU-T coding allowed.
*/
static const struct uni_print_tbl screen_tbl[] = {
MKT(UNI_ADDR_SCREEN_NOT, no),
MKT(UNI_ADDR_SCREEN_PASSED, passed),
MKT(UNI_ADDR_SCREEN_FAILED, failed),
MKT(UNI_ADDR_SCREEN_NET, network),
EOT()
};
static const struct uni_print_tbl pres_tbl[] = {
MKT(UNI_ADDR_PRES, allowed),
MKT(UNI_ADDR_RESTRICT, restricted),
MKT(UNI_ADDR_NONUMBER, no-number),
EOT()
};
static void
print_addr(struct unicx *cx, struct uni_addr *addr)
{
static const struct uni_print_tbl plan_tbl[] = {
MKT(UNI_ADDR_UNKNOWN, unknown),
MKT(UNI_ADDR_E164, E164),
MKT(UNI_ADDR_ATME, ATME),
MKT(UNI_ADDR_DATA, data),
MKT(UNI_ADDR_PRIVATE, private),
EOT()
};
static const struct uni_print_tbl type_tbl[] = {
MKT(UNI_ADDR_UNKNOWN, unknown),
MKT(UNI_ADDR_INTERNATIONAL, international),
MKT(UNI_ADDR_NATIONAL, national),
MKT(UNI_ADDR_NETWORK, network),
MKT(UNI_ADDR_SUBSCR, subscriber),
MKT(UNI_ADDR_ABBR, abbreviated),
EOT()
};
u_int i;
uni_print_entry(cx, "addr", "(");
uni_print_tbl(NULL, addr->type, type_tbl, cx);
uni_putc(',', cx);
uni_print_tbl(NULL, addr->plan, plan_tbl, cx);
uni_putc(',', cx);
if(addr->plan == UNI_ADDR_E164) {
uni_putc('"', cx);
for(i = 0; i < addr->len; i++) {
if(addr->addr[i] < ' ')
uni_printf(cx, "^%c", addr->addr[i] + '@');
else if(addr->addr[i] <= '~')
uni_putc(addr->addr[i], cx);
else
uni_printf(cx, "\\%03o", addr->addr[i]);
}
uni_putc('"', cx);
} else if(addr->plan == UNI_ADDR_ATME) {
for(i = 0; i < addr->len; i++)
uni_printf(cx, "%02x", addr->addr[i]);
}
uni_putc(')', cx);
}
static void
print_addrsub(struct unicx *cx, struct uni_subaddr *addr)
{
static const struct uni_print_tbl type_tbl[] = {
MKT(UNI_SUBADDR_NSAP, NSAP),
MKT(UNI_SUBADDR_ATME, ATME),
MKT(UNI_SUBADDR_USER, USER),
EOT()
};
u_int i;
uni_print_entry(cx, "addr", "(");
uni_print_tbl(NULL, addr->type, type_tbl, cx);
uni_putc(',', cx);
for(i = 0; i < addr->len; i++)
uni_printf(cx, "%02x", addr->addr[i]);
uni_putc(')', cx);
}
static int
check_addr(struct uni_addr *addr)
{
u_int i;
switch(addr->plan) {
default:
return -1;
case UNI_ADDR_E164:
if(addr->type != UNI_ADDR_INTERNATIONAL)
return -1;
if(addr->len > 15 || addr->len == 0)
return -1;
for(i = 0; i < addr->len; i++)
if(addr->addr[i] == 0 || (addr->addr[i] & 0x80))
return -1;
break;
case UNI_ADDR_ATME:
if(addr->type != UNI_ADDR_UNKNOWN)
return -1;
if(addr->len != 20)
return -1;
break;
}
return 0;
}
static int
check_subaddr(struct uni_subaddr *addr)
{
switch(addr->type) {
default:
return -1;
case UNI_SUBADDR_NSAP:
if(addr->len != 20)
return -1;
break;
case UNI_SUBADDR_ATME:
if(addr->len > 20)
return -1;
break;
}
return 0;
}
static int
check_screen(enum uni_addr_screen screen, enum uni_addr_pres pres)
{
switch(pres) {
default:
return -1;
case UNI_ADDR_PRES:
case UNI_ADDR_RESTRICT:
case UNI_ADDR_NONUMBER:
break;
}
switch(screen) {
default:
return -1;
case UNI_ADDR_SCREEN_NOT:
case UNI_ADDR_SCREEN_PASSED:
case UNI_ADDR_SCREEN_FAILED:
case UNI_ADDR_SCREEN_NET:
break;
}
return 0;
}
static void
encode_addr(struct uni_msg *msg, struct uni_addr *addr, u_int flag,
enum uni_addr_screen screen, enum uni_addr_pres pres, int err)
{
u_char ext = err ? 0x00 : 0x80;
if (flag) {
APP_BYTE(msg, (addr->type << 4) | addr->plan);
APP_BYTE(msg, ext | (pres << 5) | (screen));
} else {
APP_BYTE(msg, ext | (addr->type << 4) | addr->plan);
}
APP_BUF(msg, addr->addr, addr->len);
}
static void
encode_subaddr(struct uni_msg *msg, struct uni_subaddr *addr)
{
APP_BYTE(msg, 0x80|(addr->type<<4));
APP_BUF(msg, addr->addr, addr->len);
}
static int
decode_addr(struct uni_addr *addr, u_int ielen, struct uni_msg *msg, u_int plan)
{
addr->plan = plan & 0xf;
addr->type = (plan >> 4) & 0x7;
switch(addr->plan) {
case UNI_ADDR_E164:
if(ielen > 15 || ielen == 0)
return -1;
addr->addr[ielen] = 0;
break;
case UNI_ADDR_ATME:
if(ielen != 20)
return -1;
break;
default:
return -1;
}
(void)memcpy(addr->addr, msg->b_rptr, ielen);
addr->len = ielen;
msg->b_rptr += ielen;
return 0;
}
static int
decode_subaddr(struct uni_subaddr *addr, u_int ielen, struct uni_msg *msg,
u_int type)
{
switch(addr->type = (type >> 4) & 0x7) {
case UNI_SUBADDR_NSAP:
if(ielen == 0 || ielen > 20)
return -1;
break;
case UNI_SUBADDR_ATME:
if(ielen != 20)
return -1;
break;
default:
return -1;
}
if(!(type & 0x80))
return -1;
if((type & 0x7) != 0)
return -1;
addr->len = ielen;
(void)memcpy(addr->addr, msg->b_rptr, ielen);
msg->b_rptr += ielen;
return 0;
}
/**********************************************************************/
DEF_IE_PRINT(itu, called)
{
if (uni_print_iehdr("called", &ie->h, cx))
return;
print_addr(cx, &ie->addr);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, called)
{
cx = cx;
if (check_addr(&ie->addr))
return (-1);
return (0);
}
DEF_IE_ENCODE(itu, called)
{
START_IE(called, UNI_IE_CALLED, 21);
encode_addr(msg, &ie->addr, 0, 0, 0, IE_ISERROR(*ie));
SET_IE_LEN(msg);
return (0);
}
DEF_IE_DECODE(itu, called)
{
u_char c;
IE_START(;);
if (ielen > 21 || ielen < 1)
goto rej;
c = *msg->b_rptr++;
ielen--;
if (!(c & 0x80))
goto rej;
if (decode_addr(&ie->addr, ielen, msg, c))
goto rej;
IE_END(CALLED);
}
/**********************************************************************/
DEF_IE_PRINT(itu, calledsub)
{
if(uni_print_iehdr("calledsub", &ie->h, cx))
return;
print_addrsub(cx, &ie->addr);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, calledsub)
{
cx = cx;
if(check_subaddr(&ie->addr))
return -1;
return 0;
}
DEF_IE_ENCODE(itu, calledsub)
{
START_IE(calledsub, UNI_IE_CALLEDSUB, 21);
encode_subaddr(msg, &ie->addr);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, calledsub)
{
u_char c;
IE_START(;);
if(ielen > 21)
goto rej;
c = *msg->b_rptr++;
ielen--;
if(decode_subaddr(&ie->addr, ielen, msg, c))
goto rej;
IE_END(CALLEDSUB);
}
/**********************************************************************/
DEF_IE_PRINT(itu, calling)
{
if(uni_print_iehdr("calling", &ie->h, cx))
return;
print_addr(cx, &ie->addr);
if(ie->h.present & UNI_CALLING_SCREEN_P) {
uni_print_tbl("screening", ie->screen, screen_tbl, cx);
uni_print_tbl("presentation", ie->pres, pres_tbl, cx);
}
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, calling)
{
cx = cx;
if(check_addr(&ie->addr))
return -1;
if(ie->h.present & UNI_CALLING_SCREEN_P)
if(check_screen(ie->screen, ie->pres))
return -1;
return 0;
}
DEF_IE_ENCODE(itu, calling)
{
START_IE(calling, UNI_IE_CALLING, 22);
encode_addr(msg, &ie->addr, ie->h.present & UNI_CALLING_SCREEN_P, ie->screen, ie->pres, IE_ISERROR(*ie));
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, calling)
{
u_char c, plan;
IE_START(;);
if(ielen > 22 || ielen < 1)
goto rej;
plan = *msg->b_rptr++;
ielen--;
if(!(plan & 0x80)) {
if(ielen == 0)
goto rej;
ielen--;
c = *msg->b_rptr++;
ie->h.present |= UNI_CALLING_SCREEN_P;
ie->pres = (c >> 5) & 0x3;
ie->screen = c & 0x3;
if(!(c & 0x80))
goto rej;
}
if(decode_addr(&ie->addr, ielen, msg, plan))
goto rej;
IE_END(CALLING);
}
/**********************************************************************/
DEF_IE_PRINT(itu, callingsub)
{
if(uni_print_iehdr("callingsub", &ie->h, cx))
return;
print_addrsub(cx, &ie->addr);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, callingsub)
{
cx = cx;
if(check_subaddr(&ie->addr))
return -1;
return 0;
}
DEF_IE_ENCODE(itu, callingsub)
{
START_IE(callingsub, UNI_IE_CALLINGSUB, 21);
encode_subaddr(msg, &ie->addr);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, callingsub)
{
u_char c;
IE_START(;);
if(ielen > 21)
goto rej;
c = *msg->b_rptr++;
ielen--;
if(decode_subaddr(&ie->addr, ielen, msg, c))
goto rej;
IE_END(CALLINGSUB);
}
/**********************************************************************/
DEF_IE_PRINT(itu, conned)
{
if(uni_print_iehdr("conned", &ie->h, cx))
return;
print_addr(cx, &ie->addr);
if(ie->h.present & UNI_CONNED_SCREEN_P) {
uni_print_tbl("screening", ie->screen, screen_tbl, cx);
uni_print_tbl("presentation", ie->pres, pres_tbl, cx);
}
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, conned)
{
cx = cx;
if(check_addr(&ie->addr))
return -1;
if(ie->h.present & UNI_CONNED_SCREEN_P)
if(check_screen(ie->screen, ie->pres))
return -1;
return 0;
}
DEF_IE_ENCODE(itu, conned)
{
START_IE(conned, UNI_IE_CONNED, 22);
encode_addr(msg, &ie->addr, ie->h.present & UNI_CONNED_SCREEN_P, ie->screen, ie->pres, IE_ISERROR(*ie));
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, conned)
{
u_char c, plan;
IE_START(;);
if(ielen > 22 || ielen < 1)
goto rej;
plan = *msg->b_rptr++;
ielen--;
if(!(plan & 0x80)) {
if(ielen == 0)
goto rej;
ielen--;
c = *msg->b_rptr++;
ie->h.present |= UNI_CONNED_SCREEN_P;
ie->pres = (c >> 5) & 0x3;
ie->screen = c & 0x3;
if(!(c & 0x80))
goto rej;
}
if(decode_addr(&ie->addr, ielen, msg, plan))
goto rej;
IE_END(CONNED);
}
/**********************************************************************/
DEF_IE_PRINT(itu, connedsub)
{
if(uni_print_iehdr("connedsub", &ie->h, cx))
return;
print_addrsub(cx, &ie->addr);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, connedsub)
{
cx = cx;
if(check_subaddr(&ie->addr))
return -1;
return 0;
}
DEF_IE_ENCODE(itu, connedsub)
{
START_IE(connedsub, UNI_IE_CONNEDSUB, 21);
encode_subaddr(msg, &ie->addr);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, connedsub)
{
u_char c;
IE_START(;);
if(ielen > 21)
goto rej;
c = *msg->b_rptr++;
ielen--;
if(decode_subaddr(&ie->addr, ielen, msg, c))
goto rej;
IE_END(CONNEDSUB);
}
/*********************************************************************
*
* Endpoint reference.
*
* References for this IE are:
*
* Q.2971 p. 14
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, epref)
{
if(uni_print_iehdr("epref", &ie->h, cx))
return;
uni_print_entry(cx, "epref", "(%u,%u)", ie->flag, ie->epref);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, epref)
{
cx = cx;
if(ie->epref >= (2<<15))
return -1;
return 0;
}
DEF_IE_ENCODE(itu, epref)
{
START_IE(epref, UNI_IE_EPREF, 3);
if (IE_ISERROR(*ie))
APP_BYTE(msg, 0xff);
else
APP_BYTE(msg, 0);
APP_BYTE(msg, (ie->flag << 7) | ((ie->epref >> 8) & 0x7f));
APP_BYTE(msg, (ie->epref & 0xff));
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, epref)
{
u_char c;
IE_START(;);
if(ielen != 3)
goto rej;
if(*msg->b_rptr++ != 0)
goto rej;
c = *msg->b_rptr++;
ie->flag = (c & 0x80) ? 1 : 0;
ie->epref = (c & 0x7f) << 8;
ie->epref |= *msg->b_rptr++;
IE_END(EPREF);
}
/*********************************************************************
*
* Endpoint state.
*
* References for this IE are:
*
* Q.2971 pp. 14...15
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, epstate)
{
static const struct uni_print_tbl tbl[] = {
MKT(UNI_EPSTATE_NULL, null),
MKT(UNI_EPSTATE_ADD_INIT, add-initiated),
MKT(UNI_EPSTATE_ALERT_DLVD, alerting-delivered),
MKT(UNI_EPSTATE_ADD_RCVD, add-received),
MKT(UNI_EPSTATE_ALERT_RCVD, alerting-received),
MKT(UNI_EPSTATE_ACTIVE, active),
MKT(UNI_EPSTATE_DROP_INIT, drop-initiated),
MKT(UNI_EPSTATE_DROP_RCVD, drop-received),
EOT()
};
if(uni_print_iehdr("epstate", &ie->h, cx))
return;
uni_print_tbl("state", ie->state, tbl, cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, epstate)
{
cx = cx;
switch(ie->state) {
default:
return -1;
case UNI_EPSTATE_NULL:
case UNI_EPSTATE_ADD_INIT:
case UNI_EPSTATE_ALERT_DLVD:
case UNI_EPSTATE_ADD_RCVD:
case UNI_EPSTATE_ALERT_RCVD:
case UNI_EPSTATE_DROP_INIT:
case UNI_EPSTATE_DROP_RCVD:
case UNI_EPSTATE_ACTIVE:
break;
}
return 0;
}
DEF_IE_ENCODE(itu, epstate)
{
START_IE(epstate, UNI_IE_EPSTATE, 1);
APP_BYTE(msg, ie->state);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, epstate)
{
IE_START(;);
if(ielen != 1)
goto rej;
ie->state = *msg->b_rptr++ & 0x3f;
IE_END(EPSTATE);
}
/*********************************************************************
*
* ATM adaptation layer parameters
*
* References for this IE are:
*
* Q.2931 pp. 43...49
* Q.2931 Amd 2
* UNI4.0 p. 9
*
* UNI4.0 states, that AAL2 is not supported. However we keep it. No
* parameters are associated with AAL2.
*
* Amd2 not checked. XXX
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, aal)
{
static const struct uni_print_tbl aal_tbl[] = {
MKT(UNI_AAL_0, VOICE),
MKT(UNI_AAL_1, 1),
MKT(UNI_AAL_2, 2),
MKT(UNI_AAL_4, 3/4),
MKT(UNI_AAL_5, 5),
MKT(UNI_AAL_USER, USER),
EOT()
};
static const struct uni_print_tbl subtype_tbl[] = {
MKT(UNI_AAL1_SUB_NULL, null),
MKT(UNI_AAL1_SUB_VOICE, voice),
MKT(UNI_AAL1_SUB_CIRCUIT, circuit),
MKT(UNI_AAL1_SUB_HQAUDIO, hqaudio),
MKT(UNI_AAL1_SUB_VIDEO, video),
EOT()
};
static const struct uni_print_tbl cbr_rate_tbl[] = {
MKT(UNI_AAL1_CBR_64, 64),
MKT(UNI_AAL1_CBR_1544, 1544(DS1)),
MKT(UNI_AAL1_CBR_6312, 6312(DS2)),
MKT(UNI_AAL1_CBR_32064, 32064),
MKT(UNI_AAL1_CBR_44736, 44736(DS3)),
MKT(UNI_AAL1_CBR_97728, 97728),
MKT(UNI_AAL1_CBR_2048, 2048(E1)),
MKT(UNI_AAL1_CBR_8448, 8448(E2)),
MKT(UNI_AAL1_CBR_34368, 34368(E3)),
MKT(UNI_AAL1_CBR_139264, 139264),
MKT(UNI_AAL1_CBR_N64, Nx64),
MKT(UNI_AAL1_CBR_N8, Nx8),
EOT()
};
static const struct uni_print_tbl screc_tbl[] = {
MKT(UNI_AAL1_SCREC_NULL, null),
MKT(UNI_AAL1_SCREC_SRTS, srts),
MKT(UNI_AAL1_SCREC_ACLK, aclk),
EOT()
};
static const struct uni_print_tbl ecm_tbl[] = {
MKT(UNI_AAL1_ECM_NULL, null),
MKT(UNI_AAL1_ECM_LOSS, loss),
MKT(UNI_AAL1_ECM_DELAY, delay),
EOT()
};
static const struct uni_print_tbl sscs_tbl[] = {
MKT(UNI_AAL_SSCS_NULL, null),
MKT(UNI_AAL_SSCS_SSCOPA, sscopa),
MKT(UNI_AAL_SSCS_SSCOPU, sscopu),
MKT(UNI_AAL_SSCS_FRAME, frame),
EOT()
};
if(uni_print_iehdr("aal", &ie->h, cx))
return;
uni_print_tbl("type", ie->type, aal_tbl, cx);
switch(ie->type) {
case UNI_AAL_0:
uni_print_push_prefix("0", cx);
cx->indent++;
break;
case UNI_AAL_2:
uni_print_push_prefix("2", cx);
cx->indent++;
break;
case UNI_AAL_1:
uni_print_push_prefix("1", cx);
cx->indent++;
uni_print_tbl("subtype", ie->u.aal1.subtype, subtype_tbl, cx);
uni_print_tbl("cbr_rate", ie->u.aal1.cbr_rate, cbr_rate_tbl, cx);
if(ie->h.present & UNI_AAL1_MULT_P)
uni_print_entry(cx, "mult", "%u", ie->u.aal1.mult);
if(ie->h.present & UNI_AAL1_SCREC_P)
uni_print_tbl("screc", ie->u.aal1.screc, screc_tbl, cx);
if(ie->h.present & UNI_AAL1_ECM_P)
uni_print_tbl("ecm", ie->u.aal1.ecm, ecm_tbl, cx);
if(ie->h.present & UNI_AAL1_BSIZE_P)
uni_print_entry(cx, "bsize", "%u", ie->u.aal1.bsize);
if(ie->h.present & UNI_AAL1_PART_P)
uni_print_entry(cx, "part", "%u", ie->u.aal1.part);
break;
case UNI_AAL_4:
uni_print_push_prefix("4", cx);
cx->indent++;
if(ie->h.present & UNI_AAL4_CPCS_P)
uni_print_entry(cx, "cpcs", "(%u,%u)", ie->u.aal4.fwd_cpcs,
ie->u.aal4.bwd_cpcs);
if(ie->h.present & UNI_AAL4_MID_P)
uni_print_entry(cx, "mid", "(%u,%u)", ie->u.aal4.mid_low,
ie->u.aal4.mid_high);
if(ie->h.present & UNI_AAL4_SSCS_P)
uni_print_tbl("sscs", ie->u.aal4.sscs, sscs_tbl, cx);
break;
case UNI_AAL_5:
uni_print_push_prefix("5", cx);
cx->indent++;
if(ie->h.present & UNI_AAL5_CPCS_P)
uni_print_entry(cx, "cpcs", "(%u,%u)", ie->u.aal5.fwd_cpcs,
ie->u.aal5.bwd_cpcs);
if(ie->h.present & UNI_AAL5_SSCS_P)
uni_print_tbl("sscs", ie->u.aal5.sscs, sscs_tbl, cx);
break;
case UNI_AAL_USER:
uni_print_push_prefix("user", cx);
cx->indent++;
if(ie->u.aalu.len > 4) {
uni_print_entry(cx, "info", "ERROR(len=%u)", ie->u.aalu.len);
} else {
u_int i;
uni_print_entry(cx, "info", "(");
for(i = 0; i < ie->u.aalu.len; i++)
uni_printf(cx, "%s%u", !i?"":",", ie->u.aalu.user[i]);
uni_printf(cx, ")");
}
break;
}
cx->indent--;
uni_print_pop_prefix(cx);
uni_print_eol(cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, aal)
{
cx = cx;
if(ie->type == UNI_AAL_0) {
;
} else if(ie->type == UNI_AAL_1) {
switch(ie->u.aal1.subtype) {
default:
return -1;
case UNI_AAL1_SUB_NULL:
case UNI_AAL1_SUB_VOICE:
case UNI_AAL1_SUB_CIRCUIT:
case UNI_AAL1_SUB_HQAUDIO:
case UNI_AAL1_SUB_VIDEO:
break;
}
switch(ie->u.aal1.cbr_rate) {
default:
return -1;
case UNI_AAL1_CBR_64:
case UNI_AAL1_CBR_1544:
case UNI_AAL1_CBR_6312:
case UNI_AAL1_CBR_32064:
case UNI_AAL1_CBR_44736:
case UNI_AAL1_CBR_97728:
case UNI_AAL1_CBR_2048:
case UNI_AAL1_CBR_8448:
case UNI_AAL1_CBR_34368:
case UNI_AAL1_CBR_139264:
if((ie->h.present & UNI_AAL1_MULT_P))
return -1;
break;
case UNI_AAL1_CBR_N64:
if(!(ie->h.present & UNI_AAL1_MULT_P))
return -1;
if(ie->u.aal1.mult < 2)
return -1;
break;
case UNI_AAL1_CBR_N8:
if(!(ie->h.present & UNI_AAL1_MULT_P))
return -1;
if(ie->u.aal1.mult == 0 || ie->u.aal1.mult > 7)
return -1;
break;
}
if(ie->h.present & UNI_AAL1_SCREC_P) {
switch(ie->u.aal1.screc) {
default:
return -1;
case UNI_AAL1_SCREC_NULL:
case UNI_AAL1_SCREC_SRTS:
case UNI_AAL1_SCREC_ACLK:
break;
}
}
if(ie->h.present & UNI_AAL1_ECM_P) {
switch(ie->u.aal1.ecm) {
default:
return -1;
case UNI_AAL1_ECM_NULL:
case UNI_AAL1_ECM_LOSS:
case UNI_AAL1_ECM_DELAY:
break;
}
}
if(ie->h.present & UNI_AAL1_BSIZE_P) {
if(ie->u.aal1.bsize == 0)
return -1;
}
if(ie->h.present & UNI_AAL1_PART_P) {
if(ie->u.aal1.part == 0 || ie->u.aal1.part > 47)
return -1;
}
} else if(ie->type == UNI_AAL_2) {
;
} else if(ie->type == UNI_AAL_4) {
if(ie->h.present & UNI_AAL4_MID_P) {
if(ie->u.aal4.mid_low >= 1024)
return -1;
if(ie->u.aal4.mid_high >= 1024)
return -1;
if(ie->u.aal4.mid_low > ie->u.aal4.mid_high)
return -1;
}
if(ie->h.present & UNI_AAL4_SSCS_P) {
switch(ie->u.aal4.sscs) {
default:
return -1;
case UNI_AAL_SSCS_NULL:
case UNI_AAL_SSCS_SSCOPA:
case UNI_AAL_SSCS_SSCOPU:
case UNI_AAL_SSCS_FRAME:
break;
}
}
} else if(ie->type == UNI_AAL_5) {
if(ie->h.present & UNI_AAL5_SSCS_P) {
switch(ie->u.aal5.sscs) {
default:
return -1;
case UNI_AAL_SSCS_NULL:
case UNI_AAL_SSCS_SSCOPA:
case UNI_AAL_SSCS_SSCOPU:
case UNI_AAL_SSCS_FRAME:
break;
}
}
} else if(ie->type == UNI_AAL_USER) {
if(ie->u.aalu.len > 4)
return -1;
} else
return -1;
return 0;
}
DEF_IE_ENCODE(itu, aal)
{
START_IE(aal, UNI_IE_AAL, 16);
APP_BYTE(msg, ie->type);
switch(ie->type) {
case UNI_AAL_0:
break;
case UNI_AAL_1:
APP_SUB_BYTE(msg,
UNI_AAL_SUB_ID, ie->u.aal1.subtype);
APP_SUB_BYTE(msg,
UNI_AAL_CBR_ID, ie->u.aal1.cbr_rate);
APP_OPT_16BIT(msg, ie->h.present, UNI_AAL1_MULT_P,
UNI_AAL_MULT_ID, ie->u.aal1.mult);
APP_OPT_BYTE(msg, ie->h.present, UNI_AAL1_SCREC_P,
UNI_AAL_SCREC_ID, ie->u.aal1.screc);
APP_OPT_BYTE(msg, ie->h.present, UNI_AAL1_ECM_P,
UNI_AAL_ECM_ID, ie->u.aal1.ecm);
APP_OPT_16BIT(msg, ie->h.present, UNI_AAL1_BSIZE_P,
UNI_AAL_BSIZE_ID, ie->u.aal1.bsize);
APP_OPT_BYTE(msg, ie->h.present, UNI_AAL1_PART_P,
UNI_AAL_PART_ID, ie->u.aal1.part);
break;
case UNI_AAL_2:
break;
case UNI_AAL_4:
if(ie->h.present & UNI_AAL4_CPCS_P) {
APP_SUB_16BIT(msg,
UNI_AAL_FWDCPCS_ID, ie->u.aal4.fwd_cpcs);
APP_SUB_16BIT(msg,
UNI_AAL_BWDCPCS_ID, ie->u.aal4.bwd_cpcs);
}
if(ie->h.present & UNI_AAL4_MID_P) {
APP_BYTE(msg, UNI_AAL_MID_ID);
APP_16BIT(msg, ie->u.aal4.mid_low);
APP_16BIT(msg, ie->u.aal4.mid_high);
}
APP_OPT_BYTE(msg, ie->h.present, UNI_AAL4_SSCS_P,
UNI_AAL_SSCS_ID, ie->u.aal4.sscs);
break;
case UNI_AAL_5:
if(ie->h.present & UNI_AAL5_CPCS_P) {
APP_SUB_16BIT(msg,
UNI_AAL_FWDCPCS_ID, ie->u.aal5.fwd_cpcs);
APP_SUB_16BIT(msg,
UNI_AAL_BWDCPCS_ID, ie->u.aal5.bwd_cpcs);
}
APP_OPT_BYTE(msg, ie->h.present, UNI_AAL5_SSCS_P,
UNI_AAL_SSCS_ID, ie->u.aal5.sscs);
break;
case UNI_AAL_USER:
APP_BUF(msg, ie->u.aalu.user, ie->u.aalu.len);
break;
default:
return -1;
}
SET_IE_LEN(msg);
return 0;
}
/*
* XXX What should we do with multiple subtype occurences? Ignore
* or reject. Currently we reject.
*/
static int
decode_aal_1(struct uni_ie_aal *ie, struct uni_msg *msg, u_int ielen)
{
int subtype_p, cbr_p;
subtype_p = cbr_p = 0;
while(ielen-- > 0) {
switch(*msg->b_rptr++) {
case UNI_AAL_SUB_ID:
if(ielen == 0 || subtype_p)
return -1;
ielen--;
subtype_p = 1;
ie->u.aal1.subtype = *msg->b_rptr++;
break;
case UNI_AAL_CBR_ID:
if(ielen == 0 || cbr_p)
return -1;
ielen--;
cbr_p = 1;
ie->u.aal1.cbr_rate = *msg->b_rptr++;
break;
case UNI_AAL_MULT_ID:
if(ielen < 2 || (ie->h.present & UNI_AAL1_MULT_P))
return -1;
ielen -= 2;
ie->h.present |= UNI_AAL1_MULT_P;
ie->u.aal1.mult = *msg->b_rptr++ << 8;
ie->u.aal1.mult |= *msg->b_rptr++;
break;
case UNI_AAL_SCREC_ID:
if(ielen == 0 || (ie->h.present & UNI_AAL1_SCREC_P))
return -1;
ielen--;
ie->h.present |= UNI_AAL1_SCREC_P;
ie->u.aal1.screc = *msg->b_rptr++;
break;
case UNI_AAL_ECM_ID:
if(ielen == 0 || (ie->h.present & UNI_AAL1_ECM_P))
return -1;
ielen--;
ie->h.present |= UNI_AAL1_ECM_P;
ie->u.aal1.ecm = *msg->b_rptr++;
break;
case UNI_AAL_BSIZE_ID:
if(ielen < 2 || (ie->h.present & UNI_AAL1_BSIZE_P))
return -1;
ielen -= 2;
ie->h.present |= UNI_AAL1_BSIZE_P;
ie->u.aal1.bsize = *msg->b_rptr++ << 8;
ie->u.aal1.bsize |= *msg->b_rptr++;
break;
case UNI_AAL_PART_ID:
if(ielen == 0 || (ie->h.present & UNI_AAL1_PART_P))
return -1;
ielen--;
ie->h.present |= UNI_AAL1_PART_P;
ie->u.aal1.part = *msg->b_rptr++;
break;
default:
return -1;
}
}
if(!subtype_p || !cbr_p)
return -1;
return 0;
}
static int
decode_aal_4(struct uni_ie_aal *ie, struct uni_msg *msg, u_int ielen)
{
int fcpcs_p, bcpcs_p;
fcpcs_p = bcpcs_p = 0;
while(ielen-- > 0) {
switch(*msg->b_rptr++) {
case UNI_AAL_FWDCPCS_ID:
if(ielen < 2 || fcpcs_p)
return -1;
ielen -= 2;
fcpcs_p = 1;
ie->u.aal4.fwd_cpcs = *msg->b_rptr++ << 8;
ie->u.aal4.fwd_cpcs |= *msg->b_rptr++;
break;
case UNI_AAL_BWDCPCS_ID:
if(ielen < 2 || bcpcs_p)
return -1;
ielen -= 2;
bcpcs_p = 1;
ie->u.aal4.bwd_cpcs = *msg->b_rptr++ << 8;
ie->u.aal4.bwd_cpcs |= *msg->b_rptr++;
break;
case UNI_AAL_MID_ID:
if(ielen < 4 || (ie->h.present & UNI_AAL4_MID_P))
return -1;
ielen -= 4;
ie->h.present |= UNI_AAL4_MID_P;
ie->u.aal4.mid_low = *msg->b_rptr++ << 8;
ie->u.aal4.mid_low |= *msg->b_rptr++;
ie->u.aal4.mid_high = *msg->b_rptr++ << 8;
ie->u.aal4.mid_high |= *msg->b_rptr++;
break;
case UNI_AAL_SSCS_ID:
if(ielen == 0 || (ie->h.present & UNI_AAL4_SSCS_P))
return -1;
ielen--;
ie->h.present |= UNI_AAL4_SSCS_P;
ie->u.aal4.sscs = *msg->b_rptr++;
break;
default:
return -1;
}
}
if(fcpcs_p ^ bcpcs_p)
return -1;
if(fcpcs_p)
ie->h.present |= UNI_AAL4_CPCS_P;
return 0;
}
static int
decode_aal_5(struct uni_ie_aal *ie, struct uni_msg *msg, u_int ielen)
{
int fcpcs_p, bcpcs_p;
fcpcs_p = bcpcs_p = 0;
while(ielen-- > 0) {
switch(*msg->b_rptr++) {
case UNI_AAL_FWDCPCS_ID:
if(ielen < 2 || fcpcs_p)
return -1;
ielen -= 2;
fcpcs_p = 1;
ie->u.aal5.fwd_cpcs = *msg->b_rptr++ << 8;
ie->u.aal5.fwd_cpcs |= *msg->b_rptr++;
break;
case UNI_AAL_BWDCPCS_ID:
if(ielen < 2 || bcpcs_p)
return -1;
ielen -= 2;
bcpcs_p = 1;
ie->u.aal5.bwd_cpcs = *msg->b_rptr++ << 8;
ie->u.aal5.bwd_cpcs |= *msg->b_rptr++;
break;
case UNI_AAL_SSCS_ID:
if(ielen == 0 || (ie->h.present & UNI_AAL5_SSCS_P))
return -1;
ielen--;
ie->h.present |= UNI_AAL5_SSCS_P;
ie->u.aal5.sscs = *msg->b_rptr++;
break;
default:
return -1;
}
}
if(fcpcs_p ^ bcpcs_p)
return -1;
if(fcpcs_p)
ie->h.present |= UNI_AAL5_CPCS_P;
return 0;
}
static int
decode_aal_user(struct uni_ie_aal *ie, struct uni_msg *msg, u_int ielen)
{
if(ielen > 4)
return -1;
ie->u.aalu.len = 0;
while(ielen--)
ie->u.aalu.user[ie->u.aalu.len++] = *msg->b_rptr++;
return 0;
}
DEF_IE_DECODE(itu, aal)
{
u_char c;
IE_START(DISC_ACC_ERR(AAL));
if(ielen < 1 || ielen > 21)
goto rej;
c = *msg->b_rptr++;
ielen--;
switch(c) {
case UNI_AAL_0:
ie->type = c;
break;
case UNI_AAL_1:
ie->type = c;
if(decode_aal_1(ie, msg, ielen))
goto rej;
break;
case UNI_AAL_2:
ie->type = c;
break;
case UNI_AAL_4:
ie->type = c;
if(decode_aal_4(ie, msg, ielen))
goto rej;
break;
case UNI_AAL_5:
ie->type = c;
if(decode_aal_5(ie, msg, ielen))
goto rej;
break;
case UNI_AAL_USER:
ie->type = c;
if(decode_aal_user(ie, msg, ielen))
goto rej;
break;
default:
goto rej;
}
IE_END(AAL);
}
/*********************************************************************
*
* Traffic descriptor.
* Alternate traffic descriptor.
* Minimum traffic descriptor.
*
* References for this IE are:
*
* Q.2931 pp. 49...51
* Q.2961
* Q.2962
* UNI4.0 pp. 9...10, 106...109
*
* The Q.s specify the coding. UNI4.0 adds frame discard and best-effort.
* Appendix in UNI4.0 lists the allowed combinations.
*
* PCR0 PCR1 SCR/MBS0 SCR/MBS1 BE TAG FDISC ABR
* 1 CBR.1 - Y - - - N Y/N -
* 2 CBR.2 - Y - - - N Y/N - (*)
* 3 CBR.3 Y Y - - - Y Y/N - (*)
* 4 rt-VBR.1 - Y - Y - N Y/N -
* 5 rt-VBR.2 - Y Y - - N Y/N -
* 6 rt-VBR.3 - Y Y - - Y Y/N -
* 7 rt-VBR.4 Y Y - - - Y/N Y/N - (*)
* 8 rt-VBR.5 - Y - - - N Y/N - (*)
* 9 rt-VBR.6 - Y - Y - N Y/N - (*)
* 10 nrt-VBR.1 - Y - Y - N Y/N -
* 11 nrt-VBR.2 - Y Y - - N Y/N -
* 12 nrt-VBR.3 - Y Y - - Y Y/N -
* 13 nrt-VBR.4 Y Y - - - Y/N Y/N - (*)
* 14 nrt-VBR.5 - Y - - - N Y/N - (*)
* 15 nrt-VBR.6 - Y - Y - N Y/N - (*)
* 16 ABR - Y - - - N Y/N O (*)
* 17 UBR.1 - Y - - Y N Y/N -
* 18 UBR.2 - Y - - Y Y Y/N -
*
* Allow ITU-T and NET coding, because its not clear, whether the
* new fields in UNI4.0 should be used with NET coding or not.
* Does not allow for experimental codings yet.
*/
static void
print_ie_traffic_common(struct unicx *cx, u_int present, struct uni_xtraffic *ie)
{
uni_print_entry(cx, "fwd", "(");
if(present & UNI_TRAFFIC_FPCR0_P)
uni_printf(cx, "%u", ie->fpcr0);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_FPCR1_P)
uni_printf(cx, "%u", ie->fpcr1);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_FSCR0_P)
uni_printf(cx, "%u", ie->fscr0);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_FSCR1_P)
uni_printf(cx, "%u", ie->fscr1);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_FMBS0_P)
uni_printf(cx, "%u", ie->fmbs0);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_FMBS1_P)
uni_printf(cx, "%u", ie->fmbs1);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_FABR1_P)
uni_printf(cx, "%u", ie->fabr1);
uni_printf(cx, ")");
uni_print_entry(cx, "bwd", "(");
if(present & UNI_TRAFFIC_BPCR0_P)
uni_printf(cx, "%u", ie->bpcr0);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_BPCR1_P)
uni_printf(cx, "%u", ie->bpcr1);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_BSCR0_P)
uni_printf(cx, "%u", ie->bscr0);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_BSCR1_P)
uni_printf(cx, "%u", ie->bscr1);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_BMBS0_P)
uni_printf(cx, "%u", ie->bmbs0);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_BMBS1_P)
uni_printf(cx, "%u", ie->bmbs1);
uni_putc(',', cx);
if(present & UNI_TRAFFIC_BABR1_P)
uni_printf(cx, "%u", ie->babr1);
uni_printf(cx, ")");
if(present & UNI_TRAFFIC_BEST_P)
uni_print_flag("best_effort", cx);
if(present & UNI_TRAFFIC_MOPT_P) {
uni_print_entry(cx, "tag", "(");
if(ie->ftag)
uni_printf(cx, "fwd");
uni_putc(',', cx);
if(ie->btag)
uni_printf(cx, "bwd");
uni_putc(')', cx);
uni_print_entry(cx, "disc", "(");
if(ie->fdisc)
uni_printf(cx, "fwd");
uni_putc(',', cx);
if(ie->bdisc)
uni_printf(cx, "bwd");
uni_putc(')', cx);
}
}
struct tallow {
u_int mask;
int mopt_flag;
u_char mopt_mask, mopt_val;
};
static int
check_traffic(u_int mask, u_int mopt, struct tallow *a)
{
if(mask != a->mask)
return 0;
if(a->mopt_flag == 0) {
/* not allowed */
if(mopt == 0xffff)
return 1;
return 0;
}
if(a->mopt_flag < 0) {
/* optional */
if(mopt == 0xffff)
return 1;
if((mopt & a->mopt_mask) == a->mopt_val)
return 1;
return 0;
}
/* required */
if(mopt == 0xffff)
return 0;
if((mopt & a->mopt_mask) == a->mopt_val)
return 1;
return 0;
}
static int
check_ie_traffic_common(struct uni_xtraffic *ie, u_int present,
struct unicx *cx __unused)
{
static u_int fmask =
UNI_TRAFFIC_FPCR0_P | UNI_TRAFFIC_FPCR1_P |
UNI_TRAFFIC_FSCR0_P | UNI_TRAFFIC_FSCR1_P |
UNI_TRAFFIC_FMBS0_P | UNI_TRAFFIC_FMBS1_P |
UNI_TRAFFIC_FABR1_P;
static u_int bmask =
UNI_TRAFFIC_BPCR0_P | UNI_TRAFFIC_BPCR1_P |
UNI_TRAFFIC_BSCR0_P | UNI_TRAFFIC_BSCR1_P |
UNI_TRAFFIC_BMBS0_P | UNI_TRAFFIC_BMBS1_P |
UNI_TRAFFIC_BABR1_P;
#define DTAB(U,X) \
{ U##X##PCR1_P, \
-1, U##X##TAG, 0 }, /* 1, 2, 8, 14 */ \
{ U##X##PCR0_P | U##X##PCR1_P, \
+1, U##X##TAG, U##X##TAG }, /* 3 */ \
{ U##X##PCR1_P | U##X##SCR1_P | U##X##MBS1_P, \
-1, U##X##TAG, 0 }, /* 4, 9, 10, 15 */ \
{ U##X##PCR1_P | U##X##SCR0_P | U##X##MBS0_P, \
-1, 0, 0 }, /* 5, 6, 11, 12 */ \
{ U##X##PCR0_P | U##X##PCR1_P, \
-1, 0, 0 }, /* 7, 13 */ \
{ U##X##PCR1_P | U##X##ABR1_P, \
-1, U##X##TAG, 0 }, /* 16a */
#define DTABSIZE 6
static struct tallow allow[2][DTABSIZE] = {
{ DTAB(UNI_TRAFFIC_, F) },
{ DTAB(UNI_TRAFFIC_, B) },
};
#undef DTAB
u_int f, b, p, m;
int i;
f = present & fmask;
b = present & bmask;
p = present & (fmask | bmask);
m = (present & UNI_TRAFFIC_MOPT_P)
? ( (ie->ftag ? UNI_TRAFFIC_FTAG : 0)
| (ie->btag ? UNI_TRAFFIC_BTAG : 0)
| (ie->fdisc ? UNI_TRAFFIC_FDISC : 0)
| (ie->bdisc ? UNI_TRAFFIC_BDISC : 0))
: 0xffff;
if(present & UNI_TRAFFIC_BEST_P) {
/*
* Lines 17 and 18
*/
if(p != (UNI_TRAFFIC_FPCR1_P | UNI_TRAFFIC_BPCR1_P))
return -1;
return 0;
}
/*
* Check forward and backward independent. There must be a higher
* level checking in the CAC
*/
for(i = 0; i < DTABSIZE; i++)
if(check_traffic(f, m, &allow[0][i]))
break;
if(i == DTABSIZE)
return -1;
for(i = 0; i < DTABSIZE; i++)
if(check_traffic(b, m, &allow[1][i]))
break;
if(i == DTABSIZE)
return -1;
return 0;
}
static int
encode_traffic_common(struct uni_msg *msg, struct uni_xtraffic *ie,
u_int present, struct unicx *cx __unused)
{
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_FPCR0_P,
UNI_TRAFFIC_FPCR0_ID, ie->fpcr0);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_BPCR0_P,
UNI_TRAFFIC_BPCR0_ID, ie->bpcr0);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_FPCR1_P,
UNI_TRAFFIC_FPCR1_ID, ie->fpcr1);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_BPCR1_P,
UNI_TRAFFIC_BPCR1_ID, ie->bpcr1);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_FSCR0_P,
UNI_TRAFFIC_FSCR0_ID, ie->fscr0);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_BSCR0_P,
UNI_TRAFFIC_BSCR0_ID, ie->bscr0);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_FSCR1_P,
UNI_TRAFFIC_FSCR1_ID, ie->fscr1);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_BSCR1_P,
UNI_TRAFFIC_BSCR1_ID, ie->bscr1);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_FMBS0_P,
UNI_TRAFFIC_FMBS0_ID, ie->fmbs0);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_BMBS0_P,
UNI_TRAFFIC_BMBS0_ID, ie->bmbs0);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_FMBS1_P,
UNI_TRAFFIC_FMBS1_ID, ie->fmbs1);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_BMBS1_P,
UNI_TRAFFIC_BMBS1_ID, ie->bmbs1);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_FABR1_P,
UNI_TRAFFIC_FABR1_ID, ie->fabr1);
APP_OPT_24BIT(msg, present, UNI_TRAFFIC_BABR1_P,
UNI_TRAFFIC_BABR1_ID, ie->babr1);
APP_OPT(msg, present, UNI_TRAFFIC_BEST_P,
UNI_TRAFFIC_BEST_ID);
APP_OPT_BYTE(msg, present, UNI_TRAFFIC_MOPT_P,
UNI_TRAFFIC_MOPT_ID,
(ie->ftag ? UNI_TRAFFIC_FTAG : 0) |
(ie->btag ? UNI_TRAFFIC_BTAG : 0) |
(ie->fdisc ? UNI_TRAFFIC_FDISC : 0) |
(ie->fdisc ? UNI_TRAFFIC_BDISC : 0));
return 0;
}
static int
decode_traffic_common(struct uni_xtraffic *ie, struct uni_msg *msg,
u_int ielen, u_int *present)
{
u_char c;
while(ielen--) {
switch(c = *msg->b_rptr++) {
default:
rej:
return -1;
DEC_GETF3(TRAFFIC_FPCR0, fpcr0, *present);
DEC_GETF3(TRAFFIC_BPCR0, bpcr0, *present);
DEC_GETF3(TRAFFIC_FPCR1, fpcr1, *present);
DEC_GETF3(TRAFFIC_BPCR1, bpcr1, *present);
DEC_GETF3(TRAFFIC_FSCR0, fscr0, *present);
DEC_GETF3(TRAFFIC_BSCR0, bscr0, *present);
DEC_GETF3(TRAFFIC_FSCR1, fscr1, *present);
DEC_GETF3(TRAFFIC_BSCR1, bscr1, *present);
DEC_GETF3(TRAFFIC_FMBS0, fmbs0, *present);
DEC_GETF3(TRAFFIC_BMBS0, bmbs0, *present);
DEC_GETF3(TRAFFIC_BMBS1, bmbs1, *present);
DEC_GETF3(TRAFFIC_FABR1, fabr1, *present);
DEC_GETF3(TRAFFIC_BABR1, babr1, *present);
case UNI_TRAFFIC_BEST_ID:
*present |= UNI_TRAFFIC_BEST_P;
break;
case UNI_TRAFFIC_MOPT_ID:
if(ielen == 0)
return -1;
ielen--;
if(!(*present & UNI_TRAFFIC_MOPT_P)) {
*present |= UNI_TRAFFIC_MOPT_P;
ie->ftag = (*msg->b_rptr&UNI_TRAFFIC_FTAG)?1:0;
ie->btag = (*msg->b_rptr&UNI_TRAFFIC_BTAG)?1:0;
ie->fdisc = (*msg->b_rptr&UNI_TRAFFIC_FDISC)?1:0;
ie->bdisc = (*msg->b_rptr&UNI_TRAFFIC_BDISC)?1:0;
}
msg->b_rptr++;
break;
}
}
return 0;
}
/*****************************************************************/
DEF_IE_PRINT(itu, traffic)
{
if(uni_print_iehdr("traffic", &ie->h, cx))
return;
print_ie_traffic_common(cx, ie->h.present, &ie->t);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, traffic)
{
return check_ie_traffic_common(&ie->t, ie->h.present, cx);
}
DEF_IE_ENCODE(itu, traffic)
{
START_IE(traffic, UNI_IE_TRAFFIC, 26);
encode_traffic_common(msg, &ie->t, ie->h.present, cx);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, traffic)
{
IE_START(;);
if(ielen > 30)
goto rej;
if(decode_traffic_common(&ie->t, msg, ielen, &ie->h.present))
goto rej;
IE_END(TRAFFIC);
}
/*****************************************************************/
DEF_IE_PRINT(itu, atraffic)
{
if(uni_print_iehdr("atraffic", &ie->h, cx))
return;
print_ie_traffic_common(cx, ie->h.present, &ie->t);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, atraffic)
{
return check_ie_traffic_common(&ie->t, ie->h.present, cx);
}
DEF_IE_ENCODE(itu, atraffic)
{
START_IE(traffic, UNI_IE_ATRAFFIC, 26);
encode_traffic_common(msg, &ie->t, ie->h.present, cx);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, atraffic)
{
IE_START(;);
if(ielen > 30)
goto rej;
if(decode_traffic_common(&ie->t, msg, ielen, &ie->h.present))
goto rej;
IE_END(ATRAFFIC);
}
/*****************************************************************/
DEF_IE_PRINT(itu, mintraffic)
{
if(uni_print_iehdr("mintraffic", &ie->h, cx))
return;
uni_print_entry(cx, "pcr0", "(");
if(ie->h.present & UNI_MINTRAFFIC_FPCR0_P)
uni_printf(cx, "%u", ie->fpcr0);
uni_putc(',', cx);
if(ie->h.present & UNI_MINTRAFFIC_BPCR0_P)
uni_printf(cx, "%u", ie->bpcr0);
uni_putc(')', cx);
uni_print_entry(cx, "pcr1", "(");
if(ie->h.present & UNI_MINTRAFFIC_FPCR1_P)
uni_printf(cx, "%u", ie->fpcr1);
uni_putc(',', cx);
if(ie->h.present & UNI_MINTRAFFIC_BPCR1_P)
uni_printf(cx, "%u", ie->bpcr1);
uni_putc(')', cx);
uni_print_entry(cx, "abr1", "(");
if(ie->h.present & UNI_MINTRAFFIC_FABR1_P)
uni_printf(cx, "%u", ie->fabr1);
uni_putc(',', cx);
if(ie->h.present & UNI_MINTRAFFIC_BABR1_P)
uni_printf(cx, "%u", ie->babr1);
uni_printf(cx, ")");
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, mintraffic)
{
u_int abr;
u_int xbr;
cx = cx;
abr = ie->h.present & (UNI_MINTRAFFIC_FABR1_P|UNI_MINTRAFFIC_BABR1_P);
xbr = ie->h.present & (UNI_MINTRAFFIC_FPCR0_P|UNI_MINTRAFFIC_BPCR0_P|
UNI_MINTRAFFIC_FPCR1_P|UNI_MINTRAFFIC_BPCR1_P);
if(abr && xbr)
return -1;
return 0;
}
DEF_IE_ENCODE(itu, mintraffic)
{
START_IE(mintraffic, UNI_IE_MINTRAFFIC, 16);
APP_OPT_24BIT(msg, ie->h.present, UNI_MINTRAFFIC_FPCR0_P,
UNI_TRAFFIC_FPCR0_ID, ie->fpcr0);
APP_OPT_24BIT(msg, ie->h.present, UNI_MINTRAFFIC_BPCR0_P,
UNI_TRAFFIC_BPCR0_ID, ie->bpcr0);
APP_OPT_24BIT(msg, ie->h.present, UNI_MINTRAFFIC_FPCR1_P,
UNI_TRAFFIC_FPCR1_ID, ie->fpcr1);
APP_OPT_24BIT(msg, ie->h.present, UNI_MINTRAFFIC_BPCR1_P,
UNI_TRAFFIC_BPCR1_ID, ie->bpcr1);
APP_OPT_24BIT(msg, ie->h.present, UNI_MINTRAFFIC_FABR1_P,
UNI_TRAFFIC_FABR1_ID, ie->fabr1);
APP_OPT_24BIT(msg, ie->h.present, UNI_MINTRAFFIC_BABR1_P,
UNI_TRAFFIC_BABR1_ID, ie->babr1);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, mintraffic)
{
u_char c;
IE_START(;);
if(ielen > 20)
goto rej;
while(ielen--) {
switch(c = *msg->b_rptr++) {
default:
goto rej;
DEC_GETF3(MINTRAFFIC_FPCR0, fpcr0, ie->h.present);
DEC_GETF3(MINTRAFFIC_BPCR0, bpcr0, ie->h.present);
DEC_GETF3(MINTRAFFIC_FPCR1, fpcr1, ie->h.present);
DEC_GETF3(MINTRAFFIC_BPCR1, bpcr1, ie->h.present);
DEC_GETF3(MINTRAFFIC_FABR1, fabr1, ie->h.present);
DEC_GETF3(MINTRAFFIC_BABR1, babr1, ie->h.present);
}
}
IE_END(MINTRAFFIC);
}
/*****************************************************************/
DEF_IE_PRINT(net, mdcr)
{
static const struct uni_print_tbl origin_tbl[] = {
MKT(UNI_MDCR_ORIGIN_USER, user),
MKT(UNI_MDCR_ORIGIN_NET, net),
EOT()
};
if(uni_print_iehdr("mdcr", &ie->h, cx))
return;
uni_print_tbl("origin", ie->origin, origin_tbl, cx);
uni_print_entry(cx, "mdcr", "(");
uni_printf(cx, "%u", ie->fmdcr);
uni_putc(',', cx);
uni_printf(cx, "%u", ie->bmdcr);
uni_putc(')', cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, mdcr)
{
cx = cx;
if ((ie->origin != UNI_MDCR_ORIGIN_USER &&
ie->origin != UNI_MDCR_ORIGIN_NET) ||
ie->fmdcr >= (1 << 24) || ie->bmdcr >= (1 << 24))
return (-1);
return (0);
}
DEF_IE_ENCODE(net, mdcr)
{
START_IE(mdcr, UNI_IE_MDCR, 9);
APP_BYTE(msg, ie->origin);
APP_SUB_24BIT(msg, UNI_TRAFFIC_FMDCR_ID, ie->fmdcr);
APP_SUB_24BIT(msg, UNI_TRAFFIC_BMDCR_ID, ie->bmdcr);
SET_IE_LEN(msg);
return (0);
}
DEF_IE_DECODE(net, mdcr)
{
u_char c;
#define UNI_TRAFFIC_FMDCR_P 0x01
#define UNI_TRAFFIC_BMDCR_P 0x02
u_int p = 0;
IE_START(;);
if(ielen != 9)
goto rej;
ie->origin = *msg->b_rptr++;
ielen--;
while(ielen--) {
switch(c = *msg->b_rptr++) {
default:
goto rej;
DEC_GETF3(TRAFFIC_FMDCR, fmdcr, p);
DEC_GETF3(TRAFFIC_BMDCR, bmdcr, p);
}
}
if (p != (UNI_TRAFFIC_FMDCR_P | UNI_TRAFFIC_BMDCR_P))
goto rej;
IE_END(MDCR);
}
/*********************************************************************
*
* Connection identifier
*
* References for this IE are:
*
* Q.2931 pp. 69...70
* UNI4.0 pp. 15...16
* PNNI1.0 p. 198
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, connid)
{
static const struct uni_print_tbl tbl[] = {
MKT(UNI_CONNID_VCI, exclusive),
MKT(UNI_CONNID_ANYVCI, any),
MKT(UNI_CONNID_NOVCI, no),
EOT()
};
static const struct uni_print_tbl assoc_tbl[] = {
MKT(UNI_CONNID_ASSOC, associated),
MKT(UNI_CONNID_NONASSOC,non-associated),
EOT()
};
if(uni_print_iehdr("connid", &ie->h, cx))
return;
uni_print_tbl("mode", ie->assoc, assoc_tbl, cx);
uni_print_entry(cx, "connid", "(%u,", ie->vpci);
if(ie->type == UNI_CONNID_VCI)
uni_printf(cx, "%u", ie->vci);
else
uni_print_tbl(NULL, ie->type, tbl, cx);
uni_printf(cx, ")");
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, connid)
{
cx = cx;
switch(ie->type) {
default:
return -1;
case UNI_CONNID_VCI:
case UNI_CONNID_ANYVCI:
case UNI_CONNID_NOVCI:
break;
}
#if 0
/*
* This field must be checked by the application to fulfil
* Q.2931Amd4 27) 5.2.3 last sentence
*/
switch(ie->assoc) {
case UNI_CONNID_ASSOC:
if(!cx->cx.pnni)
return -1;
break;
case UNI_CONNID_NONASSOC:
break;
default:
return -1;
}
#endif
return 0;
}
DEF_IE_ENCODE(itu, connid)
{
START_IE(connid, UNI_IE_CONNID, 5);
APP_BYTE(msg, 0x80 | (ie->assoc << 3) | ie->type);
APP_BYTE(msg, ie->vpci >> 8);
APP_BYTE(msg, ie->vpci >> 0);
APP_BYTE(msg, ie->vci >> 8);
APP_BYTE(msg, ie->vci >> 0);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, connid)
{
u_char c;
IE_START(;);
if(ielen != 5)
goto rej;
c = *msg->b_rptr++;
if((c & 0x80) == 0)
goto rej;
ie->assoc = (c >> 3) & 3;
ie->type = c & 7;
ie->vpci = *msg->b_rptr++ << 8;
ie->vpci |= *msg->b_rptr++;
ie->vci = *msg->b_rptr++ << 8;
ie->vci |= *msg->b_rptr++;
IE_END(CONNID);
}
/*********************************************************************
*
* Quality of Service
*
* References for this IE are:
*
* Q.2931 pp. 72
* UNI4.0 pp. 16...17
*/
static void
print_qos(struct unicx *cx, struct uni_ie_qos *ie)
{
static const struct uni_print_tbl class_tbl[] = {
MKT(UNI_QOS_CLASS0, Class0),
MKT(UNI_QOS_CLASS1, Class1),
MKT(UNI_QOS_CLASS2, Class2),
MKT(UNI_QOS_CLASS3, Class3),
MKT(UNI_QOS_CLASS4, Class4),
EOT()
};
if(uni_print_iehdr("qos", &ie->h, cx))
return;
uni_print_tbl("fwd", ie->fwd, class_tbl, cx);
uni_print_tbl("bwd", ie->bwd, class_tbl, cx);
uni_print_ieend(cx);
}
DEF_IE_PRINT(itu, qos)
{
print_qos(cx, ie);
}
DEF_IE_PRINT(net, qos)
{
print_qos(cx, ie);
}
DEF_IE_CHECK(itu, qos)
{
cx = cx;
switch(ie->fwd) {
default:
return -1;
case UNI_QOS_CLASS0:
break;
}
switch(ie->bwd) {
default:
return -1;
case UNI_QOS_CLASS0:
break;
}
return 0;
}
DEF_IE_CHECK(net, qos)
{
cx = cx;
switch(ie->fwd) {
default:
return -1;
case UNI_QOS_CLASS1:
case UNI_QOS_CLASS2:
case UNI_QOS_CLASS3:
case UNI_QOS_CLASS4:
break;
}
switch(ie->bwd) {
default:
return -1;
case UNI_QOS_CLASS1:
case UNI_QOS_CLASS2:
case UNI_QOS_CLASS3:
case UNI_QOS_CLASS4:
break;
}
return 0;
}
DEF_IE_ENCODE(itu, qos)
{
START_IE(qos, UNI_IE_QOS, 2);
APP_BYTE(msg, ie->fwd);
APP_BYTE(msg, ie->bwd);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_ENCODE(net, qos)
{
START_IE(qos, UNI_IE_QOS, 2);
APP_BYTE(msg, ie->fwd);
APP_BYTE(msg, ie->bwd);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, qos)
{
IE_START(;);
if(ielen != 2)
goto rej;
ie->fwd = *msg->b_rptr++;
ie->bwd = *msg->b_rptr++;
IE_END(QOS);
}
DEF_IE_DECODE(net, qos)
{
IE_START(;);
if(ielen != 2)
goto rej;
ie->fwd = *msg->b_rptr++;
ie->bwd = *msg->b_rptr++;
IE_END(QOS);
}
/*********************************************************************
*
* Broadband Lower Layer Information
*
* References for this IE are:
*
* Q.2931 pp. 53...54
* UNI4.0 p. 12
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, bhli)
{
static const struct uni_print_tbl type_tbl[] = {
MKT(UNI_BHLI_ISO, iso),
MKT(UNI_BHLI_USER, user),
MKT(UNI_BHLI_VENDOR, vendor),
EOT()
};
u_int i;
if(uni_print_iehdr("bhli", &ie->h, cx))
return;
uni_print_tbl("type", ie->type, type_tbl, cx);
uni_print_entry(cx, "len", "%d", ie->len);
uni_print_entry(cx, "info", "(");
for(i = 0; i < ie->len; i++)
uni_printf(cx, ",0x%02x", ie->info[i]);
uni_printf(cx, ")");
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, bhli)
{
cx = cx;
switch(ie->type) {
default:
return -1;
case UNI_BHLI_ISO:
case UNI_BHLI_USER:
case UNI_BHLI_VENDOR:
break;
}
if(ie->len > 8)
return -1;
return 0;
}
DEF_IE_ENCODE(itu, bhli)
{
START_IE(bhli, UNI_IE_BHLI, 9);
APP_BYTE(msg, 0x80 | ie->type);
APP_BUF(msg, ie->info, ie->len);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, bhli)
{
u_char c;
IE_START(;);
if(ielen > 9)
goto rej;
c = *msg->b_rptr++;
ielen--;
if(!(c & 0x80))
goto rej;
ie->type = c & 0x7f;
ie->len = ielen;
(void)memcpy(ie->info, msg->b_rptr, ielen);
msg->b_rptr += ielen;
IE_END(BHLI);
}
/*********************************************************************
*
* Broadband bearer capabilities
*
* References for this IE are:
*
* Q.2931 pp. 51...52
* Q.2931 Amd 1
* UNI4.0 pp. 10...12, 106...109
*
* UNI4.0 changed the meaning of byte 5a. Instead of 3 bit traffic type and
* 2 bit timing requirements there are now 7 bits ATM transfer capabilities.
* However the old format is still supported: it should be recognized on
* input, but never be generated on output. Mapping is left to the user of
* UNI.
*
* Amd 1 not checked XXX.
*
* The Appendix in UNI4.0 lists all the supported combinations of various
* traffic IE's. The check function implements part of it.
*
* A C X VP
* 1 CBR.1 7 . 7 7
* 2 CBR.2 - . 4,5,6 5 (*)
* 3 CBR.3 - . 4,5,6 5 (*)
* 4 rt-VBR.1 . 19 19 19
* 5 rt-VBR.2 . 9 1,9 9
* 6 rt-VBR.3 . 9 1,9 9
* 7 rt-VBR.4 . . 1,9 . (*)
* 8 rt-VBR.5 . . 1,9 . (*)
* 9 rt-VBR.6 . 9 1,9 9 (*)
* 10 nrt-VBR.1 . 11 11 11
* 11 nrt-VBR.2 . - -,0,2,8,10 -,10
* 12 nrt-VBR.3 . - -,0,2,8,10 -,10
* 13 nrt-VBR.4 . - -,0,2,8,10 . (*)
* 14 nrt-VBR.5 . - -,0,2,8,10 . (*)
* 15 nrt-VBR.6 . - -,0,2,8,10 -,10(*)
* 16 ABR . 12 12 12
* 17 UBR.1 . - -,0,2,8,10 -,10
* 18 UBR.2 . - -,0,2,8,10 -,10
*
* (*) compatibility
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, bearer)
{
static const struct uni_print_tbl bclass_tbl[] = {
MKT(UNI_BEARER_A, bcob-A),
MKT(UNI_BEARER_C, bcob-C),
MKT(UNI_BEARER_X, bcob-X),
MKT(UNI_BEARER_TVP, transparent-VP),
EOT()
};
static const struct uni_print_tbl atc_tbl[] = {
MKT(UNI_BEARER_ATC_CBR, cbr),
MKT(UNI_BEARER_ATC_CBR1, cbr1),
MKT(UNI_BEARER_ATC_VBR, vbr),
MKT(UNI_BEARER_ATC_VBR1, vbr1),
MKT(UNI_BEARER_ATC_NVBR, nvbr),
MKT(UNI_BEARER_ATC_NVBR1, nvbr1),
MKT(UNI_BEARER_ATC_ABR, abr),
MKT(UNI_BEARER_ATCX_0, x0),
MKT(UNI_BEARER_ATCX_1, x1),
MKT(UNI_BEARER_ATCX_2, x2),
MKT(UNI_BEARER_ATCX_4, x4),
MKT(UNI_BEARER_ATCX_6, x6),
MKT(UNI_BEARER_ATCX_8, x8),
EOT()
};
static const struct uni_print_tbl cfg_tbl[] = {
MKT(UNI_BEARER_P2P, p2p),
MKT(UNI_BEARER_MP, mp),
EOT()
};
static const struct uni_print_tbl clip_tbl[] = {
MKT(UNI_BEARER_NOCLIP, no),
MKT(UNI_BEARER_CLIP, yes),
EOT()
};
if(uni_print_iehdr("bearer", &ie->h, cx))
return;
uni_print_tbl("class", ie->bclass, bclass_tbl, cx);
if(ie->h.present & UNI_BEARER_ATC_P) {
uni_print_tbl("atc", ie->atc, atc_tbl, cx);
}
uni_print_tbl("clip", ie->clip, clip_tbl, cx);
uni_print_tbl("cfg", ie->cfg, cfg_tbl, cx);
uni_print_ieend(cx);
}
#define QTYPE(C,A) ((UNI_BEARER_##C << 8) | UNI_BEARER_ATC_##A)
#define QTYPEX(C,A) ((UNI_BEARER_##C << 8) | UNI_BEARER_ATCX_##A)
#define QTYPE0(C) ((UNI_BEARER_##C << 8) | (1 << 16))
DEF_IE_CHECK(itu, bearer)
{
cx = cx;
switch((ie->bclass << 8) |
((ie->h.present & UNI_BEARER_ATC_P) == 0
? (1 << 16)
: ie->atc)) {
default:
return -1;
case QTYPE (A, CBR1): /* 1 */
case QTYPE (X, CBR1): /* 1 */
case QTYPE (TVP, CBR1): /* 1 */
case QTYPE0(A): /* 2,3 */
case QTYPEX(X, 4): /* 2,3 */
case QTYPE (X, CBR): /* 2,3 */
case QTYPEX(X, 6): /* 2,3 */
case QTYPE (TVP, CBR): /* 2,3 */
case QTYPE (C, VBR1): /* 4 */
case QTYPE (X, VBR1): /* 4 */
case QTYPE (TVP, VBR1): /* 4 */
case QTYPE (C, VBR): /* 5,6,9 */
case QTYPEX(X, 1): /* 5,6,7,8,9 */
case QTYPE (X, VBR): /* 5,6,7,8,9 */
case QTYPE (TVP, VBR): /* 5,6,9 */
case QTYPE (C, NVBR1): /* 10 */
case QTYPE (X, NVBR1): /* 10 */
case QTYPE (TVP, NVBR1): /* 10 */
case QTYPE0(C): /* 11,12,13,14,15,17,18 */
case QTYPE0(X): /* 11,12,13,14,15,17,18 */
case QTYPEX(X, 0): /* 11,12,13,14,15,17,18 */
case QTYPEX(X, 2): /* 11,12,13,14,15,17,18 */
case QTYPEX(X, 8): /* 11,12,13,14,15,17,18 */
case QTYPE (X, NVBR): /* 11,12,13,14,15,17,18 */
case QTYPE0(TVP): /* 11,12,15,17,18 */
case QTYPE (TVP, NVBR): /* 11,12,15,17,18 */
case QTYPE (C, ABR): /* 16 */
case QTYPE (X, ABR): /* 16 */
case QTYPE (TVP, ABR): /* 16 */
break;
}
switch(ie->clip) {
default:
return -1;
case UNI_BEARER_NOCLIP:
case UNI_BEARER_CLIP:
break;
}
switch(ie->cfg) {
default:
return -1;
case UNI_BEARER_P2P:
case UNI_BEARER_MP:
break;
}
return 0;
}
#undef QTYPE
#undef QTYPEX
#undef QTYPE0
DEF_IE_ENCODE(itu, bearer)
{
START_IE(bearer, UNI_IE_BEARER, 3);
APP_BYTE(msg, ie->bclass |
((ie->h.present & UNI_BEARER_ATC_P) ? 0:0x80));
APP_OPT(msg, ie->h.present, UNI_BEARER_ATC_P,
0x80 | ie->atc);
APP_BYTE(msg, 0x80 | (ie->clip << 5) | ie->cfg);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, bearer)
{
u_char c;
IE_START(;);
if(ielen != 2 && ielen != 3)
goto rej;
c = *msg->b_rptr++;
ielen--;
ie->bclass = c & 0x1f;
if(!(c & 0x80)) {
c = *msg->b_rptr++;
ielen--;
ie->h.present |= UNI_BEARER_ATC_P;
switch(c & 0x7f) {
/*
* Real legal values
*/
case UNI_BEARER_ATC_CBR:
case UNI_BEARER_ATC_CBR1:
case UNI_BEARER_ATC_VBR:
case UNI_BEARER_ATC_VBR1:
case UNI_BEARER_ATC_NVBR:
case UNI_BEARER_ATC_NVBR1:
case UNI_BEARER_ATC_ABR:
break;
/*
* Compat values
*/
case UNI_BEARER_ATCX_0:
case UNI_BEARER_ATCX_1:
case UNI_BEARER_ATCX_2:
case UNI_BEARER_ATCX_4:
case UNI_BEARER_ATCX_6:
case UNI_BEARER_ATCX_8:
break;
default:
goto rej;
}
if(!(c & 0x80))
goto rej;
ie->atc = c & 0x7f;
}
if(ielen == 0)
goto rej;
c = *msg->b_rptr++;
ielen--;
if(!(c & 0x80))
goto rej;
ie->clip = (c >> 5) & 0x3;
ie->cfg = c & 0x3;
IE_END(BEARER);
}
/*********************************************************************
*
* Broadband Lower Layer Information
*
* References for this IE are:
*
* Q.2931 pp. 54...59
* UNI4.0 pp. 12...14
*
* UNI4.0 states, that layer 1 info is not supported.
* We allow a layer 1 protocol identifier.
*
* UNI4.0 states, that the layer information subelements are NOT position
* dependent. We allow them in any order on input, but generate always the
* definit order on output.
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, blli)
{
static const struct uni_print_tbl l2_tbl[] = {
MKT(UNI_BLLI_L2_BASIC, basic),
MKT(UNI_BLLI_L2_Q921, Q921),
MKT(UNI_BLLI_L2_X25LL, X25-LL),
MKT(UNI_BLLI_L2_X25ML, X25-ML),
MKT(UNI_BLLI_L2_LABP, LAPB),
MKT(UNI_BLLI_L2_HDLC_ARM, HDLC-ARM),
MKT(UNI_BLLI_L2_HDLC_NRM, HDLC-NRM),
MKT(UNI_BLLI_L2_HDLC_ABM, HDLC-ABM),
MKT(UNI_BLLI_L2_LAN, LAN),
MKT(UNI_BLLI_L2_X75, X75),
MKT(UNI_BLLI_L2_Q922, Q922),
MKT(UNI_BLLI_L2_USER, user),
MKT(UNI_BLLI_L2_ISO7776, ISO7776),
EOT()
};
static const struct uni_print_tbl l2mode_tbl[] = {
MKT(UNI_BLLI_L2NORM, normal),
MKT(UNI_BLLI_L2EXT, extended),
EOT()
};
static const struct uni_print_tbl l3_tbl[] = {
MKT(UNI_BLLI_L3_X25, X25),
MKT(UNI_BLLI_L3_ISO8208, ISO8208),
MKT(UNI_BLLI_L3_X223, X223),
MKT(UNI_BLLI_L3_CLMP, CLMP),
MKT(UNI_BLLI_L3_T70, T70),
MKT(UNI_BLLI_L3_TR9577, TR9577),
MKT(UNI_BLLI_L3_USER, user),
MKT(UNI_BLLI_L3_H310, H310),
MKT(UNI_BLLI_L3_H321, H321),
EOT()
};
static const struct uni_print_tbl l3mode_tbl[] = {
MKT(UNI_BLLI_L3NSEQ, normal-seq),
MKT(UNI_BLLI_L3ESEQ, extended-seq),
EOT()
};
static const struct uni_print_tbl l3psiz_tbl[] = {
MKT(UNI_BLLI_L3_16, 16),
MKT(UNI_BLLI_L3_32, 32),
MKT(UNI_BLLI_L3_64, 64),
MKT(UNI_BLLI_L3_128, 128),
MKT(UNI_BLLI_L3_256, 256),
MKT(UNI_BLLI_L3_512, 512),
MKT(UNI_BLLI_L3_1024, 1024),
MKT(UNI_BLLI_L3_2048, 2048),
MKT(UNI_BLLI_L3_4096, 4096),
EOT()
};
static const struct uni_print_tbl l3ttype_tbl[] = {
MKT(UNI_BLLI_L3_TTYPE_RECV, receive_only),
MKT(UNI_BLLI_L3_TTYPE_SEND, send_only),
MKT(UNI_BLLI_L3_TTYPE_BOTH, both),
EOT()
};
static const struct uni_print_tbl l3mux_tbl[] = {
MKT(UNI_BLLI_L3_MUX_NOMUX, NOMUX),
MKT(UNI_BLLI_L3_MUX_TS, TS),
MKT(UNI_BLLI_L3_MUX_TSFEC, TSFEC),
MKT(UNI_BLLI_L3_MUX_PS, PS),
MKT(UNI_BLLI_L3_MUX_PSFEC, PSFEC),
MKT(UNI_BLLI_L3_MUX_H221, H221),
EOT()
};
static const struct uni_print_tbl l3tcap_tbl[] = {
MKT(UNI_BLLI_L3_TCAP_NOIND, noind),
MKT(UNI_BLLI_L3_TCAP_AAL1, aal1),
MKT(UNI_BLLI_L3_TCAP_AAL5, aal5),
MKT(UNI_BLLI_L3_TCAP_AAL15, aal1&5),
EOT()
};
if(uni_print_iehdr("blli", &ie->h, cx))
return;
if(ie->h.present & UNI_BLLI_L1_P) {
uni_print_entry(cx, "l1", "%u", ie->l1);
uni_print_eol(cx);
}
if(ie->h.present & UNI_BLLI_L2_P) {
uni_print_tbl("l2", ie->l2, l2_tbl, cx);
uni_print_push_prefix("l2", cx);
cx->indent++;
if(ie->h.present & UNI_BLLI_L2_USER_P)
uni_print_entry(cx, "proto", "%u", ie->l2_user);
if(ie->h.present & UNI_BLLI_L2_Q933_P) {
uni_print_entry(cx, "q933", "%u", ie->l2_q933);
uni_print_tbl("mode", ie->l2_mode, l2mode_tbl, cx);
}
if(ie->h.present & UNI_BLLI_L2_WSIZ_P)
uni_print_entry(cx, "wsize", "%u", ie->l2_wsiz);
uni_print_pop_prefix(cx);
cx->indent--;
uni_print_eol(cx);
}
if(ie->h.present & UNI_BLLI_L3_P) {
uni_print_tbl("l3", ie->l3, l3_tbl, cx);
uni_print_push_prefix("l3", cx);
cx->indent++;
if(ie->h.present & UNI_BLLI_L3_USER_P)
uni_print_entry(cx, "proto", "%u", ie->l3_user);
if(ie->h.present & UNI_BLLI_L3_MODE_P)
uni_print_tbl("mode", ie->l3_mode, l3mode_tbl, cx);
if(ie->h.present & UNI_BLLI_L3_PSIZ_P)
uni_print_tbl("packet-size", ie->l3_psiz, l3psiz_tbl, cx);
if(ie->h.present & UNI_BLLI_L3_WSIZ_P)
uni_print_entry(cx, "window-size", "%u", ie->l3_wsiz);
if(ie->h.present & UNI_BLLI_L3_TTYPE_P) {
uni_print_tbl("ttype", ie->l3_ttype, l3ttype_tbl, cx);
uni_print_tbl("tcap", ie->l3_tcap, l3tcap_tbl, cx);
}
if(ie->h.present & UNI_BLLI_L3_MUX_P) {
uni_print_tbl("fmux", ie->l3_fmux, l3mux_tbl, cx);
uni_print_tbl("bmux", ie->l3_bmux, l3mux_tbl, cx);
}
if(ie->h.present & UNI_BLLI_L3_IPI_P)
uni_print_entry(cx, "ipi", "0x%02x", ie->l3_ipi);
if(ie->h.present & UNI_BLLI_L3_SNAP_P)
uni_print_entry(cx, "snap", "%06x.%04x", ie->oui, ie->pid);
uni_print_pop_prefix(cx);
cx->indent--;
uni_print_eol(cx);
}
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, blli)
{
cx = cx;
/*
if(ie->h.present & UNI_BLLI_L1_P)
;
*/
if(ie->h.present & UNI_BLLI_L2_P) {
static u_int mask =
UNI_BLLI_L2_Q933_P | UNI_BLLI_L2_WSIZ_P |
UNI_BLLI_L2_USER_P;
switch(ie->l2) {
default:
return -1;
case UNI_BLLI_L2_BASIC:
case UNI_BLLI_L2_Q921:
case UNI_BLLI_L2_LABP:
case UNI_BLLI_L2_LAN:
case UNI_BLLI_L2_X75:
if(ie->h.present & mask)
return -1;
break;
case UNI_BLLI_L2_X25LL:
case UNI_BLLI_L2_X25ML:
case UNI_BLLI_L2_HDLC_ARM:
case UNI_BLLI_L2_HDLC_NRM:
case UNI_BLLI_L2_HDLC_ABM:
case UNI_BLLI_L2_Q922:
case UNI_BLLI_L2_ISO7776:
switch(ie->h.present & mask) {
default:
return -1;
case 0:
case UNI_BLLI_L2_Q933_P:
case UNI_BLLI_L2_Q933_P | UNI_BLLI_L2_WSIZ_P:
break;
}
break;
case UNI_BLLI_L2_USER:
switch(ie->h.present & mask) {
default:
return -1;
case 0: /* XXX ? */
case UNI_BLLI_L2_USER_P:
break;
}
break;
}
if(ie->h.present & UNI_BLLI_L2_Q933_P) {
if(ie->l2_q933 != 0)
return -1;
switch(ie->l2_mode) {
default:
return -1;
case UNI_BLLI_L2NORM:
case UNI_BLLI_L2EXT:
break;
}
}
if(ie->h.present & UNI_BLLI_L2_WSIZ_P) {
if(ie->l2_wsiz == 0 || ie->l2_wsiz > 127)
return -1;
}
if(ie->h.present & UNI_BLLI_L2_USER_P) {
if(ie->l2_user > 127)
return -1;
}
}
if(ie->h.present & UNI_BLLI_L3_P) {
static u_int mask =
UNI_BLLI_L3_MODE_P | UNI_BLLI_L3_PSIZ_P |
UNI_BLLI_L3_WSIZ_P | UNI_BLLI_L3_USER_P |
UNI_BLLI_L3_IPI_P | UNI_BLLI_L3_SNAP_P |
UNI_BLLI_L3_TTYPE_P | UNI_BLLI_L3_MUX_P;
switch(ie->l3) {
default:
return -1;
case UNI_BLLI_L3_X25:
case UNI_BLLI_L3_ISO8208:
case UNI_BLLI_L3_X223:
switch(ie->h.present & mask) {
default:
return -1;
case 0:
case UNI_BLLI_L3_MODE_P:
case UNI_BLLI_L3_MODE_P |
UNI_BLLI_L3_PSIZ_P:
case UNI_BLLI_L3_MODE_P |
UNI_BLLI_L3_PSIZ_P |
UNI_BLLI_L3_WSIZ_P:
break;
}
break;
case UNI_BLLI_L3_CLMP:
case UNI_BLLI_L3_T70:
if(ie->h.present & mask)
return -1;
break;
case UNI_BLLI_L3_TR9577:
switch(ie->h.present & mask) {
default:
return -1;
case 0:
case UNI_BLLI_L3_IPI_P:
case UNI_BLLI_L3_IPI_P | UNI_BLLI_L3_SNAP_P:
break;
}
break;
case UNI_BLLI_L3_H310:
switch(ie->h.present & mask) {
default:
return -1;
case 0:
case UNI_BLLI_L3_TTYPE_P:
case UNI_BLLI_L3_TTYPE_P|UNI_BLLI_L3_MUX_P:
break;
}
break;
case UNI_BLLI_L3_USER:
switch(ie->h.present & mask) {
default:
return -1;
case 0: /* XXX ? */
case UNI_BLLI_L3_USER_P:
break;
}
break;
}
if(ie->h.present & UNI_BLLI_L3_MODE_P) {
switch(ie->l3_mode) {
default:
return -1;
case UNI_BLLI_L3NSEQ:
case UNI_BLLI_L3ESEQ:
break;
}
}
if(ie->h.present & UNI_BLLI_L3_PSIZ_P) {
switch(ie->l3_psiz) {
default:
return -1;
case UNI_BLLI_L3_16:
case UNI_BLLI_L3_32:
case UNI_BLLI_L3_64:
case UNI_BLLI_L3_128:
case UNI_BLLI_L3_256:
case UNI_BLLI_L3_512:
case UNI_BLLI_L3_1024:
case UNI_BLLI_L3_2048:
case UNI_BLLI_L3_4096:
break;
}
}
if(ie->h.present & UNI_BLLI_L3_WSIZ_P) {
if(ie->l3_wsiz == 0 || ie->l3_wsiz > 127)
return -1;
}
if(ie->h.present & UNI_BLLI_L3_IPI_P) {
if(ie->l3_ipi == UNI_BLLI_L3_SNAP) {
if(!(ie->h.present & UNI_BLLI_L3_SNAP_P))
return -1;
} else {
if(ie->h.present & UNI_BLLI_L3_SNAP_P)
return -1;
}
}
if(ie->h.present & UNI_BLLI_L3_USER_P) {
if(ie->l3_user > 127)
return -1;
}
if(ie->h.present & UNI_BLLI_L3_SNAP_P) {
if(ie->oui >= (1<<24))
return -1;
if(ie->pid >= (1<<16))
return -1;
}
if(ie->h.present & UNI_BLLI_L3_TTYPE_P) {
switch(ie->l3_ttype) {
default:
return -1;
case UNI_BLLI_L3_TTYPE_RECV:
case UNI_BLLI_L3_TTYPE_SEND:
case UNI_BLLI_L3_TTYPE_BOTH:
break;
}
switch(ie->l3_tcap) {
default:
return -1;
case UNI_BLLI_L3_TCAP_NOIND:
case UNI_BLLI_L3_TCAP_AAL1:
case UNI_BLLI_L3_TCAP_AAL5:
case UNI_BLLI_L3_TCAP_AAL15:
break;
}
}
if(ie->h.present & UNI_BLLI_L3_MUX_P) {
switch(ie->l3_fmux) {
default:
return -1;
case UNI_BLLI_L3_MUX_NOMUX:
case UNI_BLLI_L3_MUX_TS:
case UNI_BLLI_L3_MUX_TSFEC:
case UNI_BLLI_L3_MUX_PS:
case UNI_BLLI_L3_MUX_PSFEC:
case UNI_BLLI_L3_MUX_H221:
break;
}
switch(ie->l3_bmux) {
default:
return -1;
case UNI_BLLI_L3_MUX_NOMUX:
case UNI_BLLI_L3_MUX_TS:
case UNI_BLLI_L3_MUX_TSFEC:
case UNI_BLLI_L3_MUX_PS:
case UNI_BLLI_L3_MUX_PSFEC:
case UNI_BLLI_L3_MUX_H221:
break;
}
}
}
return 0;
}
DEF_IE_ENCODE(itu, blli)
{
START_IE(blli, UNI_IE_BLLI, 13);
if (IE_ISERROR(*ie)) {
APP_BYTE(msg, 0xff);
APP_BYTE(msg, 0xff);
goto out;
}
if(ie->h.present & UNI_BLLI_L1_P)
APP_BYTE(msg, (UNI_BLLI_L1_ID<<5)|ie->l1|0x80);
if(ie->h.present & UNI_BLLI_L2_P) {
if(ie->h.present & UNI_BLLI_L2_Q933_P) {
APP_BYTE(msg, (UNI_BLLI_L2_ID<<5)|ie->l2);
if(ie->h.present & UNI_BLLI_L2_WSIZ_P) {
APP_BYTE(msg, (ie->l2_mode<<5)|ie->l2_q933);
APP_BYTE(msg, ie->l2_wsiz | 0x80);
} else {
APP_BYTE(msg, (ie->l2_mode<<5)|ie->l2_q933|0x80);
}
} else if(ie->h.present & UNI_BLLI_L2_USER_P) {
APP_BYTE(msg, (UNI_BLLI_L2_ID<<5)|ie->l2);
APP_BYTE(msg, ie->l2_user | 0x80);
} else {
APP_BYTE(msg, (UNI_BLLI_L2_ID << 5) | ie->l2 | 0x80);
}
}
if(ie->h.present & UNI_BLLI_L3_P) {
if(ie->h.present & UNI_BLLI_L3_MODE_P) {
if(ie->h.present & UNI_BLLI_L3_PSIZ_P) {
if(ie->h.present & UNI_BLLI_L3_WSIZ_P) {
APP_BYTE(msg,(UNI_BLLI_L3_ID<<5)|ie->l3);
APP_BYTE(msg,(ie->l3_mode<<5));
APP_BYTE(msg,ie->l3_psiz);
APP_BYTE(msg,ie->l3_wsiz|0x80);
} else {
APP_BYTE(msg,(UNI_BLLI_L3_ID<<5)|ie->l3);
APP_BYTE(msg,(ie->l3_mode<<5));
APP_BYTE(msg,(ie->l3_psiz|0x80));
}
} else {
APP_BYTE(msg, (UNI_BLLI_L3_ID<<5)|ie->l3);
APP_BYTE(msg, (ie->l3_mode<<5)|0x80);
}
} else if(ie->h.present & UNI_BLLI_L3_USER_P) {
APP_BYTE(msg, (UNI_BLLI_L3_ID<<5)|ie->l3);
APP_BYTE(msg,(ie->l3_user|0x80));
} else if(ie->h.present & UNI_BLLI_L3_IPI_P) {
APP_BYTE(msg, (UNI_BLLI_L3_ID<<5)|ie->l3);
APP_BYTE(msg,((ie->l3_ipi>>1) & 0x7f));
APP_BYTE(msg,(((ie->l3_ipi&1)<<6)|0x80));
if(ie->h.present & UNI_BLLI_L3_SNAP_P) {
APP_BYTE(msg, 0x80);
APP_BYTE(msg, (ie->oui >> 16));
APP_BYTE(msg, (ie->oui >> 8));
APP_BYTE(msg, (ie->oui >> 0));
APP_BYTE(msg, (ie->pid >> 8));
APP_BYTE(msg, (ie->pid >> 0));
}
} else if(ie->h.present & UNI_BLLI_L3_TTYPE_P) {
if(ie->h.present & UNI_BLLI_L3_MUX_P) {
APP_BYTE(msg, ie->l3_ttype | (ie->l3_tcap << 4));
APP_BYTE(msg, 0x80 | (ie->l3_fmux << 3) | ie->l3_bmux);
} else {
APP_BYTE(msg, 0x80 | ie->l3_ttype | (ie->l3_tcap << 4));
}
} else {
APP_BYTE(msg, (UNI_BLLI_L3_ID<<5)|ie->l3|0x80);
}
}
out:
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, blli)
{
u_char c;
IE_START(;);
if(ielen > 17)
goto rej;
while(ielen--) {
switch(((c = *msg->b_rptr++) >> 5) & 0x3) {
default:
goto rej;
case UNI_BLLI_L1_ID:
ie->h.present |= UNI_BLLI_L1_P;
ie->l1 = c & 0x1f;
if(!(c & 0x80))
goto rej;
break;
case UNI_BLLI_L2_ID:
ie->h.present |= UNI_BLLI_L2_P;
ie->l2 = c & 0x1f;
if(!(c & 0x80)) {
if(ielen == 0)
goto rej;
ielen--;
c = *msg->b_rptr++;
if(ie->l2 == UNI_BLLI_L2_USER) {
ie->h.present |= UNI_BLLI_L2_USER_P;
ie->l2_user = c & 0x7f;
if(!(c & 0x80))
goto rej;
} else {
ie->h.present |= UNI_BLLI_L2_Q933_P;
ie->l2_q933 = c & 0x3;
ie->l2_mode = (c >> 5) & 0x3;
if(!(c & 0x80)) {
if(ielen == 0)
goto rej;
ielen--;
c = *msg->b_rptr++;
ie->h.present |= UNI_BLLI_L2_WSIZ_P;
ie->l2_wsiz = c & 0x7f;
if(!(c & 0x80))
goto rej;
}
}
}
break;
case UNI_BLLI_L3_ID:
ie->h.present |= UNI_BLLI_L3_P;
ie->l3 = c & 0x1f;
if(!(c & 0x80)) {
switch(ie->l3) {
default:
case UNI_BLLI_L3_CLMP:
case UNI_BLLI_L3_T70:
goto rej;
case UNI_BLLI_L3_X25:
case UNI_BLLI_L3_ISO8208:
case UNI_BLLI_L3_X223:
if(ielen == 0)
goto rej;
ielen--;
c = *msg->b_rptr++;
ie->l3_mode = (c >> 5) & 0x3;
ie->h.present |= UNI_BLLI_L3_MODE_P;
if(c & 0x80)
break;
if(ielen == 0)
goto rej;
ielen--;
c = *msg->b_rptr++;
ie->l3_psiz = c & 0xf;
ie->h.present |= UNI_BLLI_L3_PSIZ_P;
if(c & 0x80)
break;
if(ielen == 0)
goto rej;
ielen--;
c = *msg->b_rptr++;
ie->l3_wsiz = c & 0x7f;
ie->h.present |= UNI_BLLI_L3_WSIZ_P;
if(!(c & 0x80))
goto rej;
break;
case UNI_BLLI_L3_TR9577:
if(ielen < 2)
goto rej;
ielen -= 2;
c = *msg->b_rptr++;
ie->l3_ipi = (c << 1) & 0xfe;
if(c & 0x80)
goto rej;
c = *msg->b_rptr++;
ie->l3_ipi |= c & 1;
if(!(c & 0x80))
goto rej;
ie->h.present |= UNI_BLLI_L3_IPI_P;
if(ie->l3_ipi != UNI_BLLI_L3_SNAP)
break;
if(ielen < 6)
goto rej;
ielen -= 6;
if(*msg->b_rptr++ != 0x80)
goto rej;
ie->h.present |= UNI_BLLI_L3_SNAP_P;
ie->oui = *msg->b_rptr++ << 16;
ie->oui |= *msg->b_rptr++ << 8;
ie->oui |= *msg->b_rptr++;
ie->pid = *msg->b_rptr++ << 8;
ie->pid |= *msg->b_rptr++;
break;
case UNI_BLLI_L3_H310:
if(ielen == 0)
goto rej;
ielen--;
c = *msg->b_rptr++;
ie->l3_ttype = c & 0xf;
ie->l3_tcap = (c >> 4) & 0x7;
ie->h.present |= UNI_BLLI_L3_TTYPE_P;
if(c & 0x80)
break;
if(ielen == 0)
goto rej;
ielen--;
c = *msg->b_rptr++;
ie->l3_fmux = (c >> 3) & 7;
ie->l3_bmux = c & 7;
ie->h.present |= UNI_BLLI_L3_MUX_P;
if(!(c & 0x80))
goto rej;
break;
case UNI_BLLI_L3_USER:
if(ielen == 0)
goto rej;
ielen--;
c = *msg->b_rptr++;
ie->l3_user = c & 0x7f;
ie->h.present |= UNI_BLLI_L3_USER_P;
if(!(c & 0x80))
goto rej;
break;
}
}
break;
}
}
IE_END(BLLI);
}
/*********************************************************************
*
* Broadband locking shift
* Broadband non-locking shift.
*
* References for this IE are:
*
* Q.2931 pp. 41...42
* UNI4.0 pp. 9
*
* Procedure not supported in UNI4.0, but IE's must be recognized.
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, lshift)
{
if(uni_print_iehdr("locking_shift", &ie->h, cx))
return;
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, lshift)
{
cx = cx; ie = ie;
return -1;
}
DEF_IE_ENCODE(itu, lshift)
{
START_IE(lshift, UNI_IE_LSHIFT, 1);
APP_BYTE(msg, 0x80 | ie->set);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, lshift)
{
u_char c;
IE_START(;);
if(ielen != 1)
goto rej;
c = *msg->b_rptr++;
if(!(c & 0x80))
goto rej;
ie->set = c & 7;
IE_END(LSHIFT);
}
/***********************************************************************/
DEF_IE_PRINT(itu, nlshift)
{
if(uni_print_iehdr("nonlocking_shift", &ie->h, cx))
return;
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, nlshift)
{
cx = cx; ie = ie;
return -1;
}
DEF_IE_ENCODE(itu, nlshift)
{
START_IE(nlshift, UNI_IE_NLSHIFT, 1);
APP_BYTE(msg, 0x80 | ie->set);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, nlshift)
{
u_char c;
IE_START(;);
if(ielen != 1)
goto rej;
c = *msg->b_rptr++;
if(!(c & 0x80))
goto rej;
ie->set = c & 7;
IE_END(NLSHIFT);
}
/*********************************************************************
*
* Broadband Sending Complete Indicator
*
* References for this IE are:
*
* Q.2931 pp. 74-75
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, scompl)
{
if(uni_print_iehdr("sending_complete", &ie->h, cx))
return;
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, scompl)
{
ie = ie; cx = cx;
return 0;
}
DEF_IE_ENCODE(itu, scompl)
{
START_IE(scompl, UNI_IE_SCOMPL, 1);
APP_BYTE(msg, 0x80 | 0x21);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, scompl)
{
IE_START(;);
if(ielen != 1)
goto rej;
if(*msg->b_rptr++ != (0x80 | 0x21))
goto rej;
IE_END(SCOMPL);
}
/*********************************************************************
*
* Broadband Repeat Indicator
*
* References for this IE are:
*
* Q.2931 p. 73
* PNNI1.0 p. 196
*
* Q.2931 has table 4-19. Only codepoints 0x2 and 0xa (for PNNI) supported.
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, repeat)
{
static const struct uni_print_tbl tbl[] = {
MKT(UNI_REPEAT_PRIDESC, desc),
MKT(UNI_REPEAT_STACK, stack),
EOT()
};
if(uni_print_iehdr("repeat", &ie->h, cx))
return;
uni_print_tbl("type", ie->type, tbl, cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, repeat)
{
switch(ie->type) {
case UNI_REPEAT_PRIDESC:
break;
case UNI_REPEAT_STACK:
if(!cx->pnni)
return -1;
break;
default:
return -1;
}
return 0;
}
DEF_IE_ENCODE(itu, repeat)
{
START_IE(repeat, UNI_IE_REPEAT, 1);
APP_BYTE(msg, 0x80 | ie->type);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, repeat)
{
u_char c;
IE_START(;);
if(ielen != 1)
goto rej;
c = *msg->b_rptr++;
if(!(c & 0x80))
goto rej;
ie->type = c & 0xf;
IE_END(REPEAT);
}
/*********************************************************************
*
* Transit Network Selection
*
* References for this IE are:
*
* Q.2931 pp. 75...76
* UNI4.0 pp. 17
*
* According to UNI4.0 this is always National Network Id/Carried Id.
*
* ITU-T/Net coding allowed.
*/
DEF_IE_PRINT(itu, tns)
{
u_int i;
if(uni_print_iehdr("tns", &ie->h, cx))
return;
uni_print_entry(cx, "net", "%u,\"", ie->len);
uni_putc('"', cx);
for(i = 0; i < ie->len; i++) {
if(ie->net[i] < ' ')
uni_printf(cx, "^%c", ie->net[i] + '@');
else if(ie->net[i] < '~')
uni_putc(ie->net[i], cx);
else
uni_printf(cx, "\\%03o", ie->net[i]);
}
uni_putc('"', cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, tns)
{
u_int i;
cx = cx;
if(ie->len == 0 || ie->len > UNI_TNS_MAXLEN)
return -1;
for(i = 0; i < ie->len; i++)
if(ie->net[i] < ' ' || ie->net[i] > '~')
return -1;
return 0;
}
DEF_IE_ENCODE(itu, tns)
{
START_IE(tns, UNI_IE_TNS, ie->len + 1);
APP_BYTE(msg, 0x80 | (0x2 << 4) | 0x1);
APP_BUF(msg, ie->net, ie->len);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, tns)
{
IE_START(;);
if(ielen < 2 || ielen > 5)
goto rej;
if(*msg->b_rptr++ != (0x80 | (0x2 << 4) | 0x1))
goto rej;
ielen--;
ie->len = 0;
while(ielen--)
ie->net[ie->len++] = *msg->b_rptr++;
IE_END(TNS);
}
/*********************************************************************
*
* Restart indicator
*
* References for this IE are:
*
* Q.2931 pp. 73...74
* UNI4.0 p. 17
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, restart)
{
static const struct uni_print_tbl tbl[] = {
MKT(UNI_RESTART_CHANNEL, channel),
MKT(UNI_RESTART_PATH, path),
MKT(UNI_RESTART_ALL, all),
EOT()
};
if(uni_print_iehdr("restart", &ie->h, cx))
return;
uni_print_tbl("class", ie->rclass, tbl, cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, restart)
{
cx = cx;
switch(ie->rclass) {
default:
return -1;
case UNI_RESTART_CHANNEL:
case UNI_RESTART_PATH:
case UNI_RESTART_ALL:
break;
}
return 0;
}
DEF_IE_ENCODE(itu, restart)
{
START_IE(restart, UNI_IE_RESTART, 1);
APP_BYTE(msg, 0x80 | ie->rclass);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, restart)
{
u_char c;
IE_START(;);
if(ielen != 1)
goto rej;
ie->rclass = (c = *msg->b_rptr++) & 0x7;
if(!(c & 0x80))
goto rej;
IE_END(RESTART);
}
/*********************************************************************
*
* User-to-user info.
*
* References for this IE are:
*
* Q.2957
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, uu)
{
u_int i;
if(uni_print_iehdr("uu", &ie->h, cx))
return;
uni_print_entry(cx, "len", "%u", ie->len);
uni_print_entry(cx, "info", "(");
for(i = 0; i < ie->len; i++)
uni_printf(cx, "%s0x%02x", i == 0 ? "" : " ", ie->uu[i]);
uni_printf(cx, ")");
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, uu)
{
cx = cx;
if(ie->len > UNI_UU_MAXLEN)
return -1;
return 0;
}
DEF_IE_ENCODE(itu, uu)
{
START_IE(uu, UNI_IE_UU, ie->len);
APP_BUF(msg, ie->uu, ie->len);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, uu)
{
IE_START(;);
if(ielen > UNI_UU_MAXLEN || ielen < 1)
goto rej;
ie->len = ielen;
ielen = 0;
(void)memcpy(ie->uu, msg->b_rptr, ie->len);
msg->b_rptr += ie->len;
IE_END(UU);
}
/*********************************************************************
*
* Generic Identifier Transport
*
* References for this IE are:
*
* UNI4.0 pp. 26...28
*
* UNI4.0 prescribes a fixed format for this IE. We have a flag in the
* context structur, which tells us whether the check of this IE should be
* hard or soft. Probably it should be hard for end systems and soft for
* network nodes.
*
* Only Net Coding allowed. (XXX)
*/
DEF_IE_PRINT(net, git)
{
static const struct uni_print_tbl std_tbl[] = {
MKT(UNI_GIT_STD_DSMCC, dsmcc),
MKT(UNI_GIT_STD_H245, H.245),
EOT()
};
static const struct uni_print_tbl type_tbl[] = {
MKT(UNI_GIT_TYPE_SESS, sess),
MKT(UNI_GIT_TYPE_RES, res),
EOT()
};
u_int i, j;
char buf[20];
if(uni_print_iehdr("git", &ie->h, cx))
return;
uni_print_tbl("std", ie->std, std_tbl, cx);
uni_print_eol(cx);
uni_print_push_prefix("id", cx);
cx->indent++;
for(i = 0; i < ie->numsub; i++) {
sprintf(buf, "%u", i);
uni_print_entry(cx, buf, "(");
uni_print_tbl(NULL, ie->sub[i].type, type_tbl, cx);
for(j = 0; j < ie->sub[i].len; j++)
uni_printf(cx, ",0x%02x", ie->sub[i].val[j]);
uni_printf(cx, ")");
uni_print_eol(cx);
}
cx->indent--;
uni_print_pop_prefix(cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, git)
{
u_int i;
if(cx->git_hard) {
switch(ie->std) {
case UNI_GIT_STD_DSMCC:
case UNI_GIT_STD_H245:
break;
default:
return -1;
}
if(ie->numsub != 2)
return -1;
if(ie->sub[0].type != UNI_GIT_TYPE_SESS)
return -1;
if(ie->sub[0].len > UNI_GIT_MAXSESS)
return -1;
if(ie->sub[1].type != UNI_GIT_TYPE_RES)
return -1;
if(ie->sub[1].len > UNI_GIT_MAXRES)
return -1;
} else {
if(ie->numsub > UNI_GIT_MAXSUB)
return -1;
for(i = 0; i < ie->numsub; i++)
if(ie->sub[i].len > UNI_GIT_MAXVAL)
return -1;
}
return 0;
}
DEF_IE_ENCODE(net, git)
{
u_int i;
START_IE(git, UNI_IE_GIT, 1 + ie->numsub * (1 + UNI_GIT_MAXVAL));
APP_BYTE(msg, ie->std);
for(i = 0; i < ie->numsub; i++) {
APP_BYTE(msg, ie->sub[i].type);
APP_BYTE(msg, ie->sub[i].len);
APP_BUF(msg, ie->sub[i].val, ie->sub[i].len);
}
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(net, git)
{
IE_START(;);
if(ielen > 1 + UNI_GIT_MAXSUB * (1 + UNI_GIT_MAXVAL) || ielen < 1)
goto rej;
ie->std = *msg->b_rptr++;
ielen--;
ie->numsub = 0;
while(ielen > 0) {
if(ie->numsub >= UNI_GIT_MAXSUB)
goto rej;
ie->sub[ie->numsub].type = *msg->b_rptr++;
ielen--;
if(ielen == 0)
goto rej;
ie->sub[ie->numsub].len = *msg->b_rptr++;
ielen--;
if(ie->sub[ie->numsub].len > UNI_GIT_MAXVAL)
goto rej;
if(ie->sub[ie->numsub].len > (u_int)ielen)
goto rej;
(void)memcpy(ie->sub[ie->numsub].val, msg->b_rptr, ie->sub[ie->numsub].len);
ielen -= ie->sub[ie->numsub].len;
msg->b_rptr += ie->sub[ie->numsub].len;
ie->numsub++;
}
IE_END(GIT);
}
/*********************************************************************
*
* Additional ABR Parameters
* ABR Setup parameters
*
* References for this IE are:
*
* UNI4.0 pp. 78...82
* PNNI1.0 p. 195
*
* Notes:
* Only NET coding.
*/
static void
print_abr_rec(struct unicx *cx, struct uni_abr_rec *rec)
{
if(rec->present & UNI_ABR_REC_NRM_P)
uni_print_entry(cx, "nrm", "%d", rec->nrm);
if(rec->present & UNI_ABR_REC_TRM_P)
uni_print_entry(cx, "trm", "%d", rec->trm);
if(rec->present & UNI_ABR_REC_CDF_P)
uni_print_entry(cx, "cdf", "%d", rec->cdf);
if(rec->present & UNI_ABR_REC_ADTF_P)
uni_print_entry(cx, "adtf", "%d", rec->adtf);
}
DEF_IE_PRINT(net, abradd)
{
if(uni_print_iehdr("abradd", &ie->h, cx))
return;
uni_print_push_prefix("fwd", cx);
print_abr_rec(cx, &ie->fwd);
uni_print_pop_prefix(cx);
uni_print_push_prefix("bwd", cx);
print_abr_rec(cx, &ie->bwd);
uni_print_pop_prefix(cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, abradd)
{
cx = cx;
ie = ie;
return 0;
}
static u_int
encode_abr_rec(struct uni_abr_rec *rec)
{
u_int ret = rec->present & 0xf000;
if(ret & UNI_ABR_REC_NRM_P)
ret |= (rec->nrm & 0x7) << 25;
if(ret & UNI_ABR_REC_TRM_P)
ret |= (rec->trm & 0x7) << 22;
if(ret & UNI_ABR_REC_CDF_P)
ret |= (rec->cdf & 0x7) << 19;
if(ret & UNI_ABR_REC_ADTF_P)
ret |= (rec->adtf & 0x3ff) << 9;
return ret;
}
DEF_IE_ENCODE(net, abradd)
{
START_IE(abradd, UNI_IE_ABRADD, 10);
APP_SUB_32BIT(msg, UNI_ABRADD_FADD_ID, encode_abr_rec(&ie->fwd));
APP_SUB_32BIT(msg, UNI_ABRADD_BADD_ID, encode_abr_rec(&ie->bwd));
SET_IE_LEN(msg);
return 0;
}
static int
decode_abr_rec(struct uni_msg *msg, struct uni_abr_rec *rec)
{
u_int val;
val = *msg->b_rptr++ << 24;
val |= *msg->b_rptr++ << 16;
val |= *msg->b_rptr++ << 8;
val |= *msg->b_rptr++ << 0;
rec->present = val & 0xf000;
rec->nrm = (val & UNI_ABR_REC_NRM_P) ? ((val >> 25) & 0x7) : 0;
rec->trm = (val & UNI_ABR_REC_TRM_P) ? ((val >> 22) & 0x7) : 0;
rec->cdf = (val & UNI_ABR_REC_CDF_P) ? ((val >> 19) & 0x7) : 0;
rec->adtf = (val & UNI_ABR_REC_ADTF_P)? ((val >> 9) & 0x3ff) : 0;
return 0;
}
DEF_IE_DECODE(net, abradd)
{
IE_START(;);
if(ielen != 10)
goto rej;
while(ielen--) {
switch(*msg->b_rptr++) {
default:
goto rej;
case UNI_ABRADD_FADD_ID:
if(decode_abr_rec(msg, &ie->fwd))
goto rej;
ielen -= 4;
break;
case UNI_ABRADD_BADD_ID:
if(decode_abr_rec(msg, &ie->bwd))
goto rej;
ielen -= 4;
break;
}
}
IE_END(ABRADD);
}
/*********************************************************************/
DEF_IE_PRINT(net, abrsetup)
{
if(uni_print_iehdr("abrsetup", &ie->h, cx))
return;
uni_print_entry(cx, "rm_frt", "%d", ie->rmfrt);
uni_print_push_prefix("fwd", cx);
if(ie->h.present & UNI_ABRSETUP_FICR_P)
uni_print_entry(cx, "icr", "%d", ie->ficr);
if(ie->h.present & UNI_ABRSETUP_FTBE_P)
uni_print_entry(cx, "tbe", "%d", ie->ftbe);
if(ie->h.present & UNI_ABRSETUP_FRIF_P)
uni_print_entry(cx, "rif", "%d", ie->frif);
if(ie->h.present & UNI_ABRSETUP_FRDF_P)
uni_print_entry(cx, "rdf", "%d", ie->frdf);
uni_print_pop_prefix(cx);
uni_print_push_prefix("bwd", cx);
if(ie->h.present & UNI_ABRSETUP_BICR_P)
uni_print_entry(cx, "icr", "%d", ie->bicr);
if(ie->h.present & UNI_ABRSETUP_BTBE_P)
uni_print_entry(cx, "tbe", "%d", ie->btbe);
if(ie->h.present & UNI_ABRSETUP_BRIF_P)
uni_print_entry(cx, "rif", "%d", ie->brif);
if(ie->h.present & UNI_ABRSETUP_BRDF_P)
uni_print_entry(cx, "rdf", "%d", ie->brdf);
uni_print_pop_prefix(cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, abrsetup)
{
if(cx->pnni) {
if(!(ie->h.present & UNI_ABRSETUP_FICR_P))
return -1;
if(!(ie->h.present & UNI_ABRSETUP_BICR_P))
return -1;
if(!(ie->h.present & UNI_ABRSETUP_FTBE_P))
return -1;
if(!(ie->h.present & UNI_ABRSETUP_BTBE_P))
return -1;
if(!(ie->h.present & UNI_ABRSETUP_FRIF_P))
return -1;
if(!(ie->h.present & UNI_ABRSETUP_BRIF_P))
return -1;
if(!(ie->h.present & UNI_ABRSETUP_FRDF_P))
return -1;
if(!(ie->h.present & UNI_ABRSETUP_BRDF_P))
return -1;
if(!(ie->h.present & UNI_ABRSETUP_RMFRT_P))
return -1;
}
if(!(ie->h.present & UNI_ABRSETUP_RMFRT_P))
return -1;
if(ie->h.present & UNI_ABRSETUP_FICR_P)
if(ie->ficr >= 1 << 24)
return -1;
if(ie->h.present & UNI_ABRSETUP_BICR_P)
if(ie->bicr >= 1 << 24)
return -1;
if(ie->h.present & UNI_ABRSETUP_FTBE_P)
if(ie->ftbe >= 1 << 24 || ie->ftbe == 0)
return -1;
if(ie->h.present & UNI_ABRSETUP_BTBE_P)
if(ie->btbe >= 1 << 24 || ie->btbe == 0)
return -1;
if(ie->rmfrt >= 1 << 24)
return -1;
if(ie->h.present & UNI_ABRSETUP_FRIF_P)
if(ie->frif > 15)
return -1;
if(ie->h.present & UNI_ABRSETUP_FRDF_P)
if(ie->frdf > 15)
return -1;
if(ie->h.present & UNI_ABRSETUP_BRIF_P)
if(ie->brif > 15)
return -1;
if(ie->h.present & UNI_ABRSETUP_BRDF_P)
if(ie->brdf > 15)
return -1;
return 0;
}
DEF_IE_ENCODE(net, abrsetup)
{
START_IE(abrsetup, UNI_IE_ABRSETUP, 32);
APP_OPT_24BIT(msg, ie->h.present, UNI_ABRSETUP_FICR_P,
UNI_ABRSETUP_FICR_ID, ie->ficr);
APP_OPT_24BIT(msg, ie->h.present, UNI_ABRSETUP_BICR_P,
UNI_ABRSETUP_BICR_ID, ie->bicr);
APP_OPT_24BIT(msg, ie->h.present, UNI_ABRSETUP_FTBE_P,
UNI_ABRSETUP_FTBE_ID, ie->ftbe);
APP_OPT_24BIT(msg, ie->h.present, UNI_ABRSETUP_BTBE_P,
UNI_ABRSETUP_BTBE_ID, ie->btbe);
APP_SUB_24BIT(msg, UNI_ABRSETUP_RMFRT_ID, ie->rmfrt);
APP_OPT_BYTE(msg, ie->h.present, UNI_ABRSETUP_FRIF_P,
UNI_ABRSETUP_FRIF_ID, ie->frif);
APP_OPT_BYTE(msg, ie->h.present, UNI_ABRSETUP_BRIF_P,
UNI_ABRSETUP_BRIF_ID, ie->brif);
APP_OPT_BYTE(msg, ie->h.present, UNI_ABRSETUP_FRDF_P,
UNI_ABRSETUP_FRDF_ID, ie->frdf);
APP_OPT_BYTE(msg, ie->h.present, UNI_ABRSETUP_BRDF_P,
UNI_ABRSETUP_BRDF_ID, ie->brdf);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(net, abrsetup)
{
IE_START(;);
if(ielen < 4 || ielen > 32)
goto rej;
while(ielen--) {
switch(*msg->b_rptr++) {
default:
goto rej;
DEC_GETF3(ABRSETUP_FICR, ficr, ie->h.present);
DEC_GETF3(ABRSETUP_BICR, bicr, ie->h.present);
DEC_GETF3(ABRSETUP_FTBE, ftbe, ie->h.present);
DEC_GETF3(ABRSETUP_BTBE, btbe, ie->h.present);
DEC_GETF1(ABRSETUP_FRIF, frif, ie->h.present);
DEC_GETF1(ABRSETUP_BRIF, brif, ie->h.present);
DEC_GETF1(ABRSETUP_FRDF, frdf, ie->h.present);
DEC_GETF1(ABRSETUP_BRDF, brdf, ie->h.present);
DEC_GETF3(ABRSETUP_RMFRT, frif, ie->h.present);
}
}
IE_END(ABRSETUP);
}
/*********************************************************************
*
* Broadband report type
*
* References for this IE are:
*
* Q.2963.1 pp. 7...8
*
* Only ITU-T coding allowed.
*/
DEF_IE_PRINT(itu, report)
{
static const struct uni_print_tbl tbl[] = {
MKT(UNI_REPORT_MODCONF, modconf),
MKT(UNI_REPORT_CLOCK, clock),
MKT(UNI_REPORT_EEAVAIL, eeavail),
MKT(UNI_REPORT_EEREQ, eereq),
MKT(UNI_REPORT_EECOMPL, eecompl),
EOT()
};
if(uni_print_iehdr("report", &ie->h, cx))
return;
uni_print_tbl("type", ie->report, tbl, cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, report)
{
cx = cx;
switch(ie->report) {
default:
return -1;
case UNI_REPORT_MODCONF:
case UNI_REPORT_CLOCK:
case UNI_REPORT_EEAVAIL:
case UNI_REPORT_EEREQ:
case UNI_REPORT_EECOMPL:
break;
}
return 0;
}
DEF_IE_ENCODE(itu, report)
{
START_IE(report, UNI_IE_REPORT, 1);
APP_BYTE(msg, ie->report);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(itu, report)
{
IE_START(;);
if(ielen != 1)
goto rej;
ie->report = *msg->b_rptr++;
IE_END(REPORT);
}
/*********************************************************************
*
* Soft PVPC/PVCC
*
* References for this IE are:
*
* PNNI1.0 pp. 201...203
*
* Only NET coding allowed.
*/
DEF_IE_PRINT(net, calling_soft)
{
if(uni_print_iehdr("calling_soft", &ie->h, cx))
return;
uni_print_entry(cx, "vpi", "%d", ie->vpi);
if(ie->h.present & UNI_CALLING_SOFT_VCI_P)
uni_print_entry(cx, "vci", "%d", ie->vci);
uni_print_ieend(cx);
}
DEF_IE_PRINT(net, called_soft)
{
static const struct uni_print_tbl tab[] = {
MKT(UNI_SOFT_SEL_ANY, any),
MKT(UNI_SOFT_SEL_REQ, required),
MKT(UNI_SOFT_SEL_ASS, assigned),
EOT()
};
if(uni_print_iehdr("called_soft", &ie->h, cx))
return;
uni_print_tbl("selection", ie->sel, tab, cx);
if(ie->h.present & UNI_CALLED_SOFT_VPI_P)
uni_print_entry(cx, "vpi", "%d", ie->vpi);
if(ie->h.present & UNI_CALLED_SOFT_VCI_P)
uni_print_entry(cx, "vci", "%d", ie->vci);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, calling_soft)
{
cx = cx;
if(ie->vpi >= 1 << 12)
return -1;
return 0;
}
DEF_IE_CHECK(net, called_soft)
{
cx = cx;
switch(ie->sel) {
case UNI_SOFT_SEL_ANY:
case UNI_SOFT_SEL_REQ:
case UNI_SOFT_SEL_ASS:
break;
default:
return -1;
}
if(ie->h.present & UNI_CALLED_SOFT_VPI_P) {
if(ie->vpi >= 1 << 12)
return -1;
} else {
if(ie->sel != UNI_SOFT_SEL_ANY)
return -1;
}
if(ie->h.present & UNI_CALLED_SOFT_VCI_P)
if(!(ie->h.present & UNI_CALLED_SOFT_VPI_P))
return -1;
return 0;
}
DEF_IE_ENCODE(net, calling_soft)
{
START_IE(calling_soft, UNI_IE_CALLING_SOFT, 6);
APP_BYTE(msg, 0x81);
APP_16BIT(msg, ie->vpi);
if(ie->h.present & UNI_CALLING_SOFT_VCI_P) {
APP_BYTE(msg, 0x82);
APP_16BIT(msg, ie->vci);
}
SET_IE_LEN(msg);
return 0;
}
DEF_IE_ENCODE(net, called_soft)
{
START_IE(called_soft, UNI_IE_CALLED_SOFT, 7);
APP_BYTE(msg, ie->sel);
if(ie->h.present & UNI_CALLED_SOFT_VPI_P) {
APP_BYTE(msg, 0x81);
APP_16BIT(msg, ie->vpi);
}
if(ie->h.present & UNI_CALLED_SOFT_VCI_P) {
APP_BYTE(msg, 0x82);
APP_16BIT(msg, ie->vci);
}
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(net, calling_soft)
{
int vci_seen, vpi_seen;
IE_START(;);
if(ielen < 3)
goto rej;
vci_seen = 0;
vpi_seen = 0;
while(ielen) {
switch(*msg->b_rptr++) {
case 0x81:
if(!vpi_seen) {
ie->vpi = *msg->b_rptr++ << 8;
ie->vpi |= *msg->b_rptr++;
} else {
msg->b_rptr += 2;
}
ielen -= 3;
break;
case 0x82:
if(!vci_seen) {
ie->vci = *msg->b_rptr++ << 8;
ie->vci |= *msg->b_rptr++;
} else {
msg->b_rptr += 2;
}
ie->h.present |= UNI_CALLING_SOFT_VCI_P;
ielen -= 3;
break;
default:
goto rej;
}
}
if(!vpi_seen)
goto rej;
IE_END(CALLING_SOFT);
}
DEF_IE_DECODE(net, called_soft)
{
int vci_seen, vpi_seen;
IE_START(;);
if(ielen < 3)
goto rej;
vci_seen = 0;
vpi_seen = 0;
while(ielen) {
switch(*msg->b_rptr++) {
case 0x81:
if(!vpi_seen) {
ie->vpi = *msg->b_rptr++ << 8;
ie->vpi |= *msg->b_rptr++;
vpi_seen = 1;
} else {
msg->b_rptr += 2;
}
ielen -= 3;
ie->h.present |= UNI_CALLED_SOFT_VCI_P;
break;
case 0x82:
if(!vci_seen) {
ie->vci = *msg->b_rptr++ << 8;
ie->vci |= *msg->b_rptr++;
vci_seen = 1;
} else {
msg->b_rptr += 2;
}
ie->h.present |= UNI_CALLED_SOFT_VCI_P;
ielen -= 3;
break;
default:
goto rej;
}
}
IE_END(CALLED_SOFT);
}
/*********************************************************************
*
* Crankback
*
* References for this IE are:
*
* PNNI1.0 pp. 203...206
*
* Only NET coding allowed.
*/
DEF_IE_PRINT(net, crankback)
{
u_int j;
if(uni_print_iehdr("crankback", &ie->h, cx))
return;
uni_print_entry(cx, "level", "%d", ie->level);
switch(ie->type) {
case UNI_CRANKBACK_IF:
uni_print_entry(cx, "type", "interface");
break;
case UNI_CRANKBACK_NODE:
uni_print_entry(cx, "type", "node");
uni_print_entry(cx, "node", "{%d/", ie->id.node.level);
for(j = 0; j < 21; j++)
uni_printf(cx, "%02x", ie->id.node.id[j]);
uni_printf(cx, "}");
uni_print_eol(cx);
break;
case UNI_CRANKBACK_LINK:
uni_print_entry(cx, "type", "link");
uni_print_push_prefix("link", cx);
cx->indent++;
uni_print_entry(cx, "prec", "{%d/", ie->id.link.plevel);
for(j = 0; j < 21; j++)
uni_printf(cx, "%02x", ie->id.link.pid[j]);
uni_printf(cx, "}");
uni_print_eol(cx);
uni_print_entry(cx, "port", "0x%04x", ie->id.link.port);
uni_print_eol(cx);
uni_print_entry(cx, "succ", "{%d/", ie->id.link.slevel);
for(j = 0; j < 21; j++)
uni_printf(cx, "%02x", ie->id.link.sid[j]);
uni_printf(cx, "}");
uni_print_eol(cx);
cx->indent--;
uni_print_pop_prefix(cx);
break;
default:
uni_print_entry(cx, "type", "0x%02x", ie->type);
break;
}
uni_print_entry(cx, "cause", "0x%02x", ie->cause);
if(ie->h.present & UNI_CRANKBACK_TOP_P) {
uni_print_push_prefix("topol", cx);
uni_print_entry(cx, "dir", "%d", ie->diag.top.dir);
uni_print_entry(cx, "port", "0x%04x", ie->diag.top.port);
uni_print_entry(cx, "avcr", "%u", ie->diag.top.avcr);
if(ie->h.present & UNI_CRANKBACK_TOPX_P) {
uni_print_entry(cx, "crm", "%u", ie->diag.top.crm);
uni_print_entry(cx, "vf", "%u", ie->diag.top.vf);
}
uni_print_pop_prefix(cx);
uni_print_eol(cx);
}
if(ie->h.present & UNI_CRANKBACK_QOS_P) {
uni_print_push_prefix("qos", cx);
uni_print_entry(cx, "ctd", "%savail", ie->diag.qos.ctd ? "" : "un");
uni_print_entry(cx, "cdv", "%savail", ie->diag.qos.cdv ? "" : "un");
uni_print_entry(cx, "clr", "%savail", ie->diag.qos.clr ? "" : "un");
uni_print_entry(cx, "other", "%savail", ie->diag.qos.other ? "" : "un");
uni_print_pop_prefix(cx);
uni_print_eol(cx);
}
uni_print_eol(cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, crankback)
{
cx = cx;
if(ie->level > 104)
return -1;
switch(ie->type) {
case UNI_CRANKBACK_IF:
break;
case UNI_CRANKBACK_NODE:
if(ie->id.node.level > 104)
return -1;
break;
case UNI_CRANKBACK_LINK:
if(ie->id.link.plevel > 104)
return -1;
if(ie->id.link.slevel > 104)
return -1;
break;
default:
return -1;
}
if(ie->h.present & UNI_CRANKBACK_TOP_P) {
if(ie->h.present & UNI_CRANKBACK_QOS_P)
return -1;
if(ie->cause != UNI_CAUSE_CRATE_NAVL)
return -1;
switch(ie->diag.top.dir) {
case 0x00:
case 0x01:
break;
default:
return -1;
}
}
if(ie->h.present & UNI_CRANKBACK_QOS_P) {
if(ie->cause != UNI_CAUSE_QOS_NAVL)
return -1;
}
return 0;
}
DEF_IE_ENCODE(net, crankback)
{
START_IE(crankback, UNI_IE_CRANKBACK, 72);
APP_BYTE(msg, ie->level);
APP_BYTE(msg, ie->type);
switch(ie->type) {
case UNI_CRANKBACK_IF:
break;
case UNI_CRANKBACK_NODE:
APP_BYTE(msg, ie->id.node.level);
APP_BUF(msg, ie->id.node.id, 21);
break;
case UNI_CRANKBACK_LINK:
APP_BYTE(msg, ie->id.link.plevel);
APP_BUF(msg, ie->id.link.pid, 21);
APP_32BIT(msg, ie->id.link.port);
APP_BYTE(msg, ie->id.link.slevel);
APP_BUF(msg, ie->id.link.sid, 21);
break;
}
APP_BYTE(msg, ie->cause);
if(ie->h.present & UNI_CRANKBACK_TOP_P) {
APP_BYTE(msg, ie->diag.top.dir);
APP_32BIT(msg, ie->diag.top.port);
APP_32BIT(msg, ie->diag.top.avcr);
if(ie->h.present & UNI_CRANKBACK_TOPX_P) {
APP_32BIT(msg, ie->diag.top.crm);
APP_32BIT(msg, ie->diag.top.vf);
}
}
if(ie->h.present & UNI_CRANKBACK_QOS_P) {
APP_BYTE(msg, (ie->diag.qos.ctd << 3)
|(ie->diag.qos.cdv << 2)
|(ie->diag.qos.clr << 1)
|(ie->diag.qos.other));
}
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(net, crankback)
{
IE_START(;);
if(ielen < 3)
goto rej;
ie->level = *msg->b_rptr++;
ielen--;
ie->type = *msg->b_rptr++;
ielen--;
switch(ie->type) {
default:
goto rej;
case UNI_CRANKBACK_IF:
break;
case UNI_CRANKBACK_NODE:
if(ielen < 22)
goto rej;
ie->id.node.level = *msg->b_rptr++;
(void)memcpy(ie->id.node.id, msg->b_rptr, 21);
msg->b_rptr += 21;
ielen -= 22;
break;
case UNI_CRANKBACK_LINK:
if(ielen < 48)
goto rej;
ie->id.link.plevel = *msg->b_rptr++;
(void)memcpy(ie->id.link.pid, msg->b_rptr, 21);
msg->b_rptr += 21;
ielen -= 22;
ie->id.link.port = *msg->b_rptr++ << 24;
ie->id.link.port |= *msg->b_rptr++ << 16;
ie->id.link.port |= *msg->b_rptr++ << 8;
ie->id.link.port |= *msg->b_rptr++ << 0;
ielen -= 4;
ie->id.link.slevel = *msg->b_rptr++;
(void)memcpy(ie->id.link.sid, msg->b_rptr, 21);
msg->b_rptr += 21;
ielen -= 22;
break;
}
if(ielen < 1)
goto rej;
ie->cause = *msg->b_rptr++;
ielen--;
if(ie->cause == UNI_CAUSE_CRATE_NAVL) {
if(ielen > 0) {
if(ielen != 9 && ielen != 17)
goto rej;
ie->diag.top.dir = *msg->b_rptr++;
ie->diag.top.port = *msg->b_rptr++ << 24;
ie->diag.top.port |= *msg->b_rptr++ << 16;
ie->diag.top.port |= *msg->b_rptr++ << 8;
ie->diag.top.port |= *msg->b_rptr++ << 0;
ie->diag.top.avcr = *msg->b_rptr++ << 24;
ie->diag.top.avcr |= *msg->b_rptr++ << 16;
ie->diag.top.avcr |= *msg->b_rptr++ << 8;
ie->diag.top.avcr |= *msg->b_rptr++ << 0;
ielen -= 9;
ie->h.present |= UNI_CRANKBACK_TOP_P;
if(ielen > 0) {
ie->diag.top.crm = *msg->b_rptr++ << 24;
ie->diag.top.crm |= *msg->b_rptr++ << 16;
ie->diag.top.crm |= *msg->b_rptr++ << 8;
ie->diag.top.crm |= *msg->b_rptr++ << 0;
ie->diag.top.vf = *msg->b_rptr++ << 24;
ie->diag.top.vf |= *msg->b_rptr++ << 16;
ie->diag.top.vf |= *msg->b_rptr++ << 8;
ie->diag.top.vf |= *msg->b_rptr++ << 0;
ie->h.present |= UNI_CRANKBACK_TOPX_P;
ielen -= 8;
}
}
} else if(ie->cause == UNI_CAUSE_QOS_NAVL) {
if(ielen > 0) {
if(ielen != 1)
goto rej;
ie->diag.qos.ctd = *msg->b_rptr >> 3;
ie->diag.qos.cdv = *msg->b_rptr >> 2;
ie->diag.qos.clr = *msg->b_rptr >> 1;
ie->diag.qos.other = *msg->b_rptr >> 0;
ie->h.present |= UNI_CRANKBACK_QOS_P;
ielen -= 1;
}
} else {
if(ielen > 0)
goto rej;
}
IE_END(CRANKBACK);
}
/*********************************************************************
*
* Designated transit list
*
* References for this IE are:
*
* PNNI1.0 pp. 206...208
*
* Only NET coding allowed.
*/
DEF_IE_PRINT(net, dtl)
{
u_int i, j;
char buf[10];
if(uni_print_iehdr("dtl", &ie->h, cx))
return;
uni_print_entry(cx, "ptr", "%d(%d)", ie->ptr, ie->ptr / UNI_DTL_LOGNP_SIZE);
uni_print_push_prefix("dtl", cx);
cx->indent++;
uni_printf(cx, "{");
for(i = 0; i < ie->num; i++) {
sprintf(buf, "%d", i);
uni_print_entry(cx, buf, "{%d/", ie->dtl[i].node_level);
for(j = 0; j < 21; j++)
uni_printf(cx, "%02x", ie->dtl[i].node_id[j]);
uni_printf(cx, ",%04x}", ie->dtl[i].port_id);
uni_print_eol(cx);
}
cx->indent--;
uni_print_pop_prefix(cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, dtl)
{
u_int i;
cx = cx;
if(ie->ptr % UNI_DTL_LOGNP_SIZE != 0)
return -1;
if(ie->ptr / UNI_DTL_LOGNP_SIZE > UNI_DTL_MAXNUM)
return -1;
if(ie->num > UNI_DTL_MAXNUM)
return -1;
for(i = 0; i < ie->num; i++)
if(ie->dtl[i].node_level > 104)
return -1;
return 0;
}
DEF_IE_ENCODE(net, dtl)
{
u_int i;
START_IE(dtl, UNI_IE_DTL, 2 + UNI_DTL_LOGNP_SIZE * ie->num);
APP_16BIT(msg, ie->ptr);
for(i = 0; i < ie->num; i++) {
APP_BYTE(msg, UNI_DTL_LOGNP);
APP_BYTE(msg, ie->dtl[i].node_level);
APP_BUF(msg, ie->dtl[i].node_id, 21);
APP_32BIT(msg, ie->dtl[i].port_id);
}
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(net, dtl)
{
IE_START(;);
if(ielen < 2)
goto rej;
ie->ptr = *msg->b_rptr++ << 8;
ie->ptr |= *msg->b_rptr++;
ielen -= 2;
if(ielen % UNI_DTL_LOGNP_SIZE != 0)
goto rej;
if(ielen / UNI_DTL_LOGNP_SIZE > UNI_DTL_MAXNUM)
goto rej;
ie->num = 0;
while(ielen) {
if(*msg->b_rptr++ != UNI_DTL_LOGNP)
goto rej;
ielen--;
ie->dtl[ie->num].node_level = *msg->b_rptr++;
ielen--;
(void)memcpy(ie->dtl[ie->num].node_id, msg->b_rptr, 21);
msg->b_rptr += 21;
ielen -= 21;
ie->dtl[ie->num].port_id = *msg->b_rptr++ << 24;
ie->dtl[ie->num].port_id |= *msg->b_rptr++ << 16;
ie->dtl[ie->num].port_id |= *msg->b_rptr++ << 8;
ie->dtl[ie->num].port_id |= *msg->b_rptr++ << 0;
ielen -= 4;
ie->num++;
}
IE_END(DTL);
}
/*********************************************************************
*
* Leaf initiated join call identifier.
* Leaf initiated join parameters.
* Leaf initiated join sequence number.
*
* References for this IE are:
*
* UNI4.0 pp. 46...48
*
* Only NET coding allowed.
*/
/**********************************************************************/
DEF_IE_PRINT(net, lij_callid)
{
static const struct uni_print_tbl type_tbl[] = {
MKT(UNI_LIJ_IDTYPE_ROOT, root),
EOT()
};
if(uni_print_iehdr("lij_callid", &ie->h, cx))
return;
uni_print_tbl("type", ie->type, type_tbl, cx);
uni_print_entry(cx, "id", "0x%x", ie->callid);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, lij_callid)
{
cx = cx;
switch(ie->type) {
case UNI_LIJ_IDTYPE_ROOT:
break;
default:
return -1;
}
return 0;
}
DEF_IE_ENCODE(net, lij_callid)
{
START_IE(lij_callid, UNI_IE_LIJ_CALLID, 5);
APP_BYTE(msg, 0x80 | ie->type);
APP_32BIT(msg, ie->callid);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(net, lij_callid)
{
IE_START(;);
if(ielen != 5)
goto rej;
ie->type = *msg->b_rptr++ & 0xf;
ie->callid = *msg->b_rptr++ << 24;
ie->callid |= *msg->b_rptr++ << 16;
ie->callid |= *msg->b_rptr++ << 8;
ie->callid |= *msg->b_rptr++ << 0;
IE_END(LIJ_CALLID);
}
/**********************************************************************/
DEF_IE_PRINT(net, lij_param)
{
static const struct uni_print_tbl lscreen_tbl[] = {
MKT(UNI_LIJ_SCREEN_NETJOIN, netjoin),
EOT()
};
if(uni_print_iehdr("lij_param", &ie->h, cx))
return;
uni_print_tbl("screen", ie->screen, lscreen_tbl, cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, lij_param)
{
cx = cx;
switch(ie->screen) {
case UNI_LIJ_SCREEN_NETJOIN:
break;
default:
return -1;
}
return 0;
}
DEF_IE_ENCODE(net, lij_param)
{
START_IE(lij_param, UNI_IE_LIJ_PARAM, 1);
APP_BYTE(msg, 0x80 | ie->screen);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(net, lij_param)
{
IE_START(;);
if(ielen != 1)
goto rej;
ie->screen = *msg->b_rptr++ & 0xf;
IE_END(LIJ_PARAM);
}
/**********************************************************************/
DEF_IE_PRINT(net, lij_seqno)
{
if(uni_print_iehdr("lij_seqno", &ie->h, cx))
return;
uni_print_entry(cx, "seqno", "0x%x", ie->seqno);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, lij_seqno)
{
cx = cx; ie = ie;
return 0;
}
DEF_IE_ENCODE(net, lij_seqno)
{
START_IE(lij_seqno, UNI_IE_LIJ_SEQNO, 4);
APP_32BIT(msg, ie->seqno);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(net, lij_seqno)
{
IE_START(;);
if(ielen != 4)
goto rej;
ie->seqno = *msg->b_rptr++ << 24;
ie->seqno |= *msg->b_rptr++ << 16;
ie->seqno |= *msg->b_rptr++ << 8;
ie->seqno |= *msg->b_rptr++ << 0;
IE_END(LIJ_SEQNO);
}
/*********************************************************************
*
* Connection scope
*
* References for this IE are:
*
* UNI4.0 pp. 57...58
*
* Only NET coding allowed.
*/
DEF_IE_PRINT(net, cscope)
{
static const struct uni_print_tbl type_tbl[] = {
MKT(UNI_CSCOPE_ORG, org),
EOT()
};
static const struct uni_print_tbl scope_tbl[] = {
MKT(UNI_CSCOPE_ORG_LOC, local_network),
MKT(UNI_CSCOPE_ORG_LOC_P1, local_network_plus_one),
MKT(UNI_CSCOPE_ORG_LOC_P2, local_network_plus_two),
MKT(UNI_CSCOPE_ORG_SITE_M1, site_minus_one),
MKT(UNI_CSCOPE_ORG_SITE, intra_site),
MKT(UNI_CSCOPE_ORG_SITE_P1, site_plus_one),
MKT(UNI_CSCOPE_ORG_ORG_M1, organisation_minus_one),
MKT(UNI_CSCOPE_ORG_ORG, intra_organisation),
MKT(UNI_CSCOPE_ORG_ORG_P1, organisation_plus_one),
MKT(UNI_CSCOPE_ORG_COMM_M1, community_minus_one),
MKT(UNI_CSCOPE_ORG_COMM, intra_community),
MKT(UNI_CSCOPE_ORG_COMM_P1, community_plus_one),
MKT(UNI_CSCOPE_ORG_REG, regional),
MKT(UNI_CSCOPE_ORG_INTER, inter_regional),
MKT(UNI_CSCOPE_ORG_GLOBAL, global),
EOT()
};
if(uni_print_iehdr("cscope", &ie->h, cx))
return;
uni_print_tbl("type", ie->type, type_tbl, cx);
if(ie->type == UNI_CSCOPE_ORG)
uni_print_tbl("scope", (u_int)ie->scope, scope_tbl, cx);
else
uni_print_entry(cx, "scope", "0x%02x", ie->scope);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, cscope)
{
cx = cx;
switch(ie->type) {
default:
return -1;
case UNI_CSCOPE_ORG:
switch(ie->scope) {
default:
return -1;
case UNI_CSCOPE_ORG_LOC:
case UNI_CSCOPE_ORG_LOC_P1:
case UNI_CSCOPE_ORG_LOC_P2:
case UNI_CSCOPE_ORG_SITE_M1:
case UNI_CSCOPE_ORG_SITE:
case UNI_CSCOPE_ORG_SITE_P1:
case UNI_CSCOPE_ORG_ORG_M1:
case UNI_CSCOPE_ORG_ORG:
case UNI_CSCOPE_ORG_ORG_P1:
case UNI_CSCOPE_ORG_COMM_M1:
case UNI_CSCOPE_ORG_COMM:
case UNI_CSCOPE_ORG_COMM_P1:
case UNI_CSCOPE_ORG_REG:
case UNI_CSCOPE_ORG_INTER:
case UNI_CSCOPE_ORG_GLOBAL:
break;
}
break;
}
return 0;
}
DEF_IE_ENCODE(net, cscope)
{
START_IE(cscope, UNI_IE_CSCOPE, 2);
APP_BYTE(msg, ie->type | 0x80);
APP_BYTE(msg, ie->scope);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(net, cscope)
{
IE_START(;);
if(ielen != 2)
goto rej;
if((*msg->b_rptr & 0xf0) != 0x80)
goto rej;
ie->type = *msg->b_rptr++ & 0xf;
ie->scope = *msg->b_rptr++;
IE_END(CSCOPE);
}
/*********************************************************************
*
* Extended Quality of Service
*
* References for this IE are:
*
* UNI4.0 pp. 70...72
*
* Notes:
* Only NET coding.
*/
DEF_IE_PRINT(net, exqos)
{
static const struct uni_print_tbl tab[] = {
MKT(UNI_EXQOS_USER, user),
MKT(UNI_EXQOS_NET, net),
EOT()
};
if(uni_print_iehdr("exqos", &ie->h, cx))
return;
uni_print_tbl("origin", ie->origin, tab, cx);
uni_print_entry(cx, "acceptable", "(");
if(ie->h.present & UNI_EXQOS_FACC_P) {
if(ie->facc == UNI_EXQOS_ANY_CDV)
uni_printf(cx, "ANY");
else
uni_printf(cx, "%d", ie->facc);
}
uni_putc(',', cx);
if(ie->h.present & UNI_EXQOS_BACC_P) {
if(ie->bacc == UNI_EXQOS_ANY_CDV)
uni_printf(cx, "ANY");
else
uni_printf(cx, "%d", ie->bacc);
}
uni_putc(')', cx);
uni_print_entry(cx, "cumulative", "(");
if(ie->h.present & UNI_EXQOS_FCUM_P)
uni_printf(cx, "%d", ie->fcum);
uni_putc(',', cx);
if(ie->h.present & UNI_EXQOS_BCUM_P)
uni_printf(cx, "%d", ie->bcum);
uni_putc(')', cx);
uni_print_entry(cx, "clrid", "(");
if(ie->h.present & UNI_EXQOS_FCLR_P) {
if(ie->fclr == UNI_EXQOS_ANY_CLR)
uni_printf(cx, "ANY");
else
uni_printf(cx, "%d", ie->fclr);
}
uni_putc(',', cx);
if(ie->h.present & UNI_EXQOS_BCLR_P) {
if(ie->bclr == UNI_EXQOS_ANY_CLR)
uni_printf(cx, "ANY");
else
uni_printf(cx, "%d", ie->bclr);
}
uni_putc(')', cx);
uni_print_ieend(cx);
}
DEF_IE_CHECK(net, exqos)
{
cx = cx;
switch(ie->origin) {
case UNI_EXQOS_USER:
case UNI_EXQOS_NET:
break;
default:
return -1;
}
if(ie->h.present & UNI_EXQOS_FACC_P)
if(!(ie->h.present & UNI_EXQOS_FCUM_P))
return -1;
if(ie->h.present & UNI_EXQOS_BACC_P)
if(!(ie->h.present & UNI_EXQOS_BCUM_P))
return -1;
if(ie->h.present & UNI_EXQOS_FACC_P)
if(ie->facc >= 1 << 24)
return -1;
if(ie->h.present & UNI_EXQOS_BACC_P)
if(ie->bacc >= 1 << 24)
return -1;
if(ie->h.present & UNI_EXQOS_FCUM_P)
if(ie->fcum >= 1 << 24)
return -1;
if(ie->h.present & UNI_EXQOS_BCUM_P)
if(ie->bcum >= 1 << 24)
return -1;
if(ie->h.present & UNI_EXQOS_FCLR_P)
if(ie->fclr==0 || (ie->fclr>15 && ie->fclr!=UNI_EXQOS_ANY_CLR))
return -1;
if(ie->h.present & UNI_EXQOS_BCLR_P)
if(ie->bclr==0 || (ie->bclr>15 && ie->bclr!=UNI_EXQOS_ANY_CLR))
return -1;
return 0;
}
DEF_IE_ENCODE(net, exqos)
{
START_IE(exqos, UNI_IE_EXQOS, 21);
APP_BYTE(msg, ie->origin);
APP_OPT_24BIT(msg, ie->h.present, UNI_EXQOS_FACC_P,
UNI_EXQOS_FACC_ID, ie->facc);
APP_OPT_24BIT(msg, ie->h.present, UNI_EXQOS_BACC_P,
UNI_EXQOS_BACC_ID, ie->bacc);
APP_OPT_24BIT(msg, ie->h.present, UNI_EXQOS_FCUM_P,
UNI_EXQOS_FCUM_ID, ie->fcum);
APP_OPT_24BIT(msg, ie->h.present, UNI_EXQOS_BCUM_P,
UNI_EXQOS_BCUM_ID, ie->bcum);
APP_OPT_BYTE(msg, ie->h.present, UNI_EXQOS_FCLR_P,
UNI_EXQOS_FCLR_ID, ie->fclr);
APP_OPT_BYTE(msg, ie->h.present, UNI_EXQOS_BCLR_P,
UNI_EXQOS_BCLR_ID, ie->bclr);
SET_IE_LEN(msg);
return 0;
}
DEF_IE_DECODE(net, exqos)
{
IE_START(;);
if(ielen < 1 || ielen > 21)
goto rej;
ie->origin = *msg->b_rptr++;
ielen--;
while(ielen--) {
switch(*msg->b_rptr++) {
default:
goto rej;
DEC_GETF3(EXQOS_FACC, facc, ie->h.present);
DEC_GETF3(EXQOS_BACC, bacc, ie->h.present);
DEC_GETF3(EXQOS_FCUM, fcum, ie->h.present);
DEC_GETF3(EXQOS_BCUM, bcum, ie->h.present);
DEC_GETF1(EXQOS_FCLR, fclr, ie->h.present);
DEC_GETF1(EXQOS_BCLR, bclr, ie->h.present);
}
}
IE_END(EXQOS);
}
/**************************************************************
*
* Free form IE (for testing mainly)
*/
DEF_IE_PRINT(itu, unrec)
{
u_int i;
if (uni_print_iehdr("unrec", &ie->h, cx))
return;
uni_print_entry(cx, "len", "%u", ie->len);
uni_print_entry(cx, "data", "(");
for (i = 0; i < ie->len; i++)
uni_printf(cx, "%s0x%02x", i == 0 ? "" : " ", ie->data[i]);
uni_printf(cx, ")");
uni_print_ieend(cx);
}
DEF_IE_CHECK(itu, unrec)
{
cx = cx;
if (ie->len > sizeof(ie->data))
return (-1);
return (0);
}
DEF_IE_ENCODE(itu, unrec)
{
START_IE2(unrec, UNI_IE_UNREC, ie->len, ie->id);
APP_BUF(msg, ie->data, ie->len);
SET_IE_LEN(msg);
return (0);
}
DEF_IE_DECODE(itu, unrec)
{
IE_START(;);
if (ielen > sizeof(ie->data) / sizeof(ie->data[0]) || ielen < 1)
goto rej;
ie->len = ielen;
ielen = 0;
(void)memcpy(ie->data, msg->b_rptr, ie->len);
msg->b_rptr += ie->len;
IE_END(UNREC);
}
Reference in New Issue View Git Blame Copy Permalink