retronetworking
/
yate
12
0
Fork 2
Code Issues Pull Requests Projects Releases Wiki Activity
yate/libs/ysig/q921.cpp

2289 lines
68 KiB
C++
Raw Blame History

/**
* q921.cpp
* This file is part of the YATE Project http://YATE.null.ro
*
* Yet Another Signalling Stack - implements the support for SS7, ISDN and PSTN
*
* Yet Another Telephony Engine - a fully featured software PBX and IVR
* Copyright (C) 2004-2014 Null Team
*
* This software is distributed under multiple licenses;
* see the COPYING file in the main directory for licensing
* information for this specific distribution.
*
* This use of this software may be subject to additional restrictions.
* See the LEGAL file in the main directory for details.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
#include "yatesig.h"
#include <stdlib.h>
using namespace TelEngine;
/**
* DEFINEs controlling Q.921 implementation
* Q921_PASIVE_NOCHECK_PF
* Yes: Received UA/DM responses will be validated without checking the P/F bit
* No: Received UA/DM responses without P/F bit set will be dropped
*/
#ifndef Q921_PASIVE_NOCHECK_PF
#define Q921_PASIVE_NOCHECK_PF
#endif
static const char* s_linkSideNet = "NET";
static const char* s_linkSideCpe = "CPE";
#define Q921_MANAGEMENT_TEI 15 // TEI management message descriptor (first byte). See Q.921 Table 8
#define Q921_TEI_BROADCAST 127 // TEI value for broadcast and management procedures
#define Q921_SAPI_MANAGEMENT 63 // SAPI value for management procedures
static inline const char* linkSide(bool net)
{
return net ? s_linkSideNet : s_linkSideCpe;
}
static inline void fixParams(NamedList& params, const NamedList* config)
{
if (config && params.getBoolValue(YSTRING("local-config"),false))
params.copyParams(*config);
int rx = params.getIntValue(YSTRING("rxunderrun"));
if ((rx > 0) && (rx < 2500))
params.setParam("rxunderrun","2500");
}
// Drop frame reasons
static const char* s_noState = "Not allowed in this state";
// Used to set or compare values that may wrap at 127 boundary
class Modulo128
{
public:
// Increment a value. Set to 0 if greater the 127
static inline void inc(u_int8_t& value) {
if (value < 127)
value++;
else
value = 0;
}
// Check if a given value is in an interval given by it's margins
// @param value The value to check
// @param low The lower margin of the interval
// @param high The higher margin of the interval
static inline bool between(u_int8_t value, u_int8_t low, u_int8_t high) {
if (low == high)
return value == low;
if (low < high)
return value >= low && value <= high;
// low > high: counter wrapped around
return value >= low || value <= high;
}
// Get the lower margin of an interval given by it's higher margin and length
// The interval length is assumed non 0
// @param high The higher margin of the interval
// @param len The interval length
static inline u_int8_t getLow(u_int8_t high, u_int8_t len)
{ return ((high >= len) ? high - len + 1 : 128 - (len - high)); }
};
/**
* ISDNQ921
*/
// ****************************************************************************
// NOTE:
// * Private methods are not thread safe. They are called from public
// and protected methods which are thread safe
// * Always drop any lock before calling Layer 3 methods to avoid a deadlock:
// it may try to establish/release/send data from a different thread
// ****************************************************************************
// Constructor. Set data members. Print them
ISDNQ921::ISDNQ921(const NamedList& params, const char* name, ISDNQ921Management* mgmt, u_int8_t tei)
: SignallingComponent(name,&params,"isdn-q921"),
ISDNLayer2(params,name,tei),
SignallingReceiver(name),
SignallingDumpable(SignallingDumper::Q921,network()),
m_management(mgmt),
m_remoteBusy(false),
m_timerRecovery(false),
m_rejectSent(false),
m_pendingDMSabme(false),
m_lastPFBit(false),
m_vs(0),
m_va(0),
m_vr(0),
m_retransTimer(0),
m_idleTimer(0),
m_window(7),
m_n200(3),
m_txFrames(0),
m_txFailFrames(0),
m_rxFrames(0),
m_rxRejectedFrames(0),
m_rxDroppedFrames(0),
m_hwErrors(0),
m_printFrames(true),
m_extendedDebug(false),
m_errorSend(false),
m_errorReceive(false)
{
if (mgmt && network())
autoRestart(false);
m_retransTimer.interval(params,"t200",1000,1000,false);
m_idleTimer.interval(params,"t203",2000,10000,false);
// Adjust idle timeout to data link side
m_idleTimer.interval(m_idleTimer.interval() + (network() ? -500 : 500));
m_window.maxVal(params.getIntValue(YSTRING("maxpendingframes"),7));
if (!m_window.maxVal())
m_window.maxVal(7);
setDebug(params.getBoolValue(YSTRING("print-frames"),false),
params.getBoolValue(YSTRING("extended-debug"),false));
if (debugAt(DebugInfo)) {
String tmp;
#ifdef DEBUG
if (debugAt(DebugAll)) {
params.dump(tmp,"\r\n ",'\'',true);
Debug(this,DebugAll,"ISDNQ921::ISDNQ921(%p,'%s',%p,%u) [%p]%s",
&params,name,mgmt,tei,this,tmp.c_str());
tmp.clear();
}
tmp << " SAPI/TEI=" << (unsigned int)localSapi() << "/" << (unsigned int)localTei();
tmp << " auto-restart=" << String::boolText(autoRestart());
tmp << " max-user-data=" << (unsigned int)maxUserData();
tmp << " max-pending-frames: " << (unsigned int)m_window.maxVal();
tmp << " retrans/idle=" << (unsigned int)m_retransTimer.interval() << "/"
<< (unsigned int)m_idleTimer.interval();
#endif
Debug(this,DebugAll,"ISDN Data Link type=%s%s [%p]",
linkSide(network()),tmp.safe(),this);
}
if (!mgmt)
setDumper(params.getValue(YSTRING("layer2dump")));
}
// Destructor
ISDNQ921::~ISDNQ921()
{
Lock lock(l2Mutex());
ISDNLayer2::attach((ISDNLayer3*)0);
TelEngine::destruct(SignallingReceiver::attach(0));
cleanup();
DDebug(this,DebugAll,
"ISDN Data Link destroyed. Frames: sent=%u (failed=%u) recv=%u rejected=%u dropped=%u. HW errors=%u [%p]",
(unsigned int)m_txFrames,(unsigned int)m_txFailFrames,
(unsigned int)m_rxFrames,(unsigned int)m_rxRejectedFrames,
(unsigned int)m_rxDroppedFrames,(unsigned int)m_hwErrors,this);
}
// Initialize layer, attach interface if not managed
bool ISDNQ921::initialize(const NamedList* config)
{
#ifdef DEBUG
String tmp;
if (config && debugAt(DebugAll))
config->dump(tmp,"\r\n ",'\'',true);
Debug(this,DebugInfo,"ISDNQ921::initialize(%p) [%p]%s",config,this,tmp.c_str());
#endif
if (config) {
debugLevel(config->getIntValue(YSTRING("debuglevel_q921"),
config->getIntValue(YSTRING("debuglevel"),-1)));
setDebug(config->getBoolValue(YSTRING("print-frames"),false),
config->getBoolValue(YSTRING("extended-debug"),false));
}
if (config && !m_management && !iface()) {
NamedList params("");
if (resolveConfig(YSTRING("sig"),params,config) ||
resolveConfig(YSTRING("basename"),params,config)) {
params.addParam("basename",params);
params.assign(params + "/D");
fixParams(params,config);
SignallingInterface* ifc = YSIGCREATE(SignallingInterface,&params);
if (!ifc)
return false;
SignallingReceiver::attach(ifc);
if (ifc->initialize(&params)) {
SignallingReceiver::control(SignallingInterface::Enable);
multipleFrame(0,true,false);
}
else
TelEngine::destruct(SignallingReceiver::attach(0));
}
}
return m_management || iface();
}
// Set or release 'multiple frame acknowledged' mode
bool ISDNQ921::multipleFrame(u_int8_t tei, bool establish, bool force)
{
Lock lock(l2Mutex());
// Check state. Don't do anything in transition states or if TEI changes
if ((localTei() != tei) || (state() == WaitEstablish) || (state() == WaitRelease))
return false;
// The request wouldn't change our state and we are not forced to fulfill it
if (!force &&
((establish && (state() == Established)) ||
(!establish && (state() == Released))))
return false;
XDebug(this,DebugAll,"Process '%s' request, TEI=%u",establish ? "ESTABLISH" : "RELEASE",tei);
bool result = true;
if (establish) {
reset();
result = sendUFrame(ISDNFrame::SABME,true,true);
changeState(WaitEstablish,"multiple frame");
timer(true,false);
}
else {
// Already disconnected: Just notify Layer 3
if (state() == Released) {
lock.drop();
if (m_management)
m_management->multipleFrameReleased(tei,true,false,this);
else
multipleFrameReleased(tei,true,false);
return true;
}
reset();
result = sendUFrame(ISDNFrame::DISC,true,true);
changeState(WaitRelease,"multiple frame");
timer(true,false);
}
return result;
}
// Send data through the HDLC interface
bool ISDNQ921::sendData(const DataBlock& data, u_int8_t tei, bool ack)
{
if (data.null())
return false;
Lock lock(l2Mutex());
if (ack) {
if (localTei() != tei || !teiAssigned() || state() == Released || m_window.full())
return false;
// Enqueue and send outgoing data
ISDNFrame* f = new ISDNFrame(true,network(),localSapi(),localTei(),false,data);
// Update frame send seq number. Inc our send seq number and window counter
f->update(&m_vs,0);
Modulo128::inc(m_vs);
m_window.inc();
// Append and try to send frame
m_outFrames.append(f);
XDebug(this,DebugAll,"Enqueued data frame (%p). Sequence number: %u",f,f->ns());
sendOutgoingData();
return true;
}
// Unacknowledged data request
if (tei != Q921_TEI_BROADCAST) {
Debug(this,DebugInfo,"Not sending unacknowledged data with TEI %u [%p]",tei,this);
return false;
}
// P/F bit is always false for UI frames. See Q.921 5.2.2
ISDNFrame* f = new ISDNFrame(false,network(),localSapi(),localTei(),false,data);
bool result = sendFrame(f);
TelEngine::destruct(f);
return result;
}
// Send DISC. Reset data
void ISDNQ921::cleanup()
{
Lock lock(l2Mutex());
DDebug(this,DebugAll,"Cleanup in state '%s'",stateName(state()));
// Don't send DISC if we are disconnected or waiting to become disconnected
if (state() == Established)
sendUFrame(ISDNFrame::DISC,true,true);
reset();
changeState(Released,"cleanup");
}
// Method called periodically to check timeouts
// Re-sync with remote peer if necessary
void ISDNQ921::timerTick(const Time& when)
{
// If possible return early without locking
if (state() == Released)
return;
Lock lock(l2Mutex(),SignallingEngine::maxLockWait());
// Check state again after locking, to be sure it didn't change
if (!lock.locked() || (state() == Released))
return;
// T200 not started
if (!m_retransTimer.started()) {
// T203 not started: START
if (!m_idleTimer.started()) {
timer(false,true,when.msec());
m_timerRecovery = false;
return;
}
// T203 started: Timeout ?
if (!m_idleTimer.timeout(when.msec()))
return;
// Start timer
XDebug(this,DebugInfo,"T203 expired. Start T200");
timer(true,false,when.msec());
}
// T200 started
if (!m_retransTimer.timeout(when.msec()))
return;
// Q.921 5.6.7: Timeout
// Done all retransmissions ?
if (m_n200.full()) {
reset();
changeState(Released,"timeout");
lock.drop();
multipleFrameReleased(localTei(),false,true);
if (autoRestart())
multipleFrame(localTei(),true,false);
return;
}
// Waiting to establish/release ?
if (state() == WaitEstablish || state() == WaitRelease) {
ISDNFrame::Type t = (state() == WaitEstablish) ?
ISDNFrame::SABME : ISDNFrame::DISC;
XDebug(this,DebugAll,"T200 expired. Retransmit '%s'",ISDNFrame::typeName(t));
sendUFrame(t,true,true,true);
m_n200.inc();
timer(true,false,when.msec());
return;
}
// State is Established
if (!m_timerRecovery) {
m_n200.reset();
m_timerRecovery = true;
}
// Try to retransmit some data or send RR
if (!sendOutgoingData(true)) {
XDebug(this,DebugAll,"T200 expired. Send '%s'",ISDNFrame::typeName(ISDNFrame::RR));
sendSFrame(ISDNFrame::RR,true,true);
m_lastPFBit = true;
}
m_n200.inc();
timer(true,false,when.msec());
}
// Process a packet received by the receiver's interface
// Parse data. Validate received frame and process it
bool ISDNQ921::receivedPacket(const DataBlock& packet)
{
ISDNFrame* f = parsePacket(packet);
if (!f) {
if (!m_errorReceive) {
m_errorReceive = true;
Debug(this,DebugNote,"Received invalid packet with length %u [%p]",packet.length(),this);
}
return false;
}
m_errorReceive = false;
// Print & dump
if (debugAt(DebugInfo) && m_printFrames) {
String tmp;
f->toString(tmp,m_extendedDebug);
Debug(this,DebugInfo,"Received frame (%p):%s",f,tmp.c_str());
}
if (f->type() < ISDNFrame::Invalid)
dump(f->buffer(),false);
return receivedFrame(f);
}
bool ISDNQ921::receivedFrame(ISDNFrame* frame)
{
if (!frame)
return false;
Lock lock(l2Mutex());
bool reject = false;
// Not accepted:
// If not rejected, for out of range sequence number send
// REJ to request retransmission if not already sent or RR to confirm if REJ already sent
// Just drop the frame otherwise
// If rejected (unrecoverable error), re-establish data link
if (!acceptFrame(frame,reject)) {
if (!reject) {
if (frame->m_error == ISDNFrame::ErrTxSeqNo) {
if (!m_rejectSent) {
sendSFrame(ISDNFrame::REJ,true,true);
m_rejectSent = true;
m_lastPFBit = true;
}
else
sendSFrame(ISDNFrame::RR,false,frame->poll());
}
TelEngine::destruct(frame);
return true;
}
// Unrecoverable error: re-establish
Debug(this,DebugNote,"Rejected %s frame %p, reason: '%s'. Restarting",
frame->name(),frame,ISDNFrame::typeName(frame->error()));
TelEngine::destruct(frame);
reset();
changeState(WaitEstablish,"received frame");
sendUFrame(ISDNFrame::SABME,true,true);
timer(true,false);
return true;
}
// Process
XDebug(this,DebugAll,"Process %s frame %p in state '%s'",
frame->name(),frame,ISDNLayer2::stateName(state()));
bool chgState = false, confirmation = false;
State newState;
if (frame->category() == ISDNFrame::Data) {
bool ack = (frame->type() == ISDNFrame::I);
if (processDataFrame(frame,ack)) {
DataBlock tmp;
frame->getData(tmp);
lock.drop();
receiveData(tmp,localTei());
}
frame->deref();
return true;
}
if (frame->category() == ISDNFrame::Supervisory) {
if (processSFrame(frame)) {
// Exit from timer recovery
m_timerRecovery = false;
if (m_pendingDMSabme) {
m_pendingDMSabme = false;
chgState = true;
newState = WaitEstablish;
}
}
}
else
chgState = processUFrame(frame,newState,confirmation);
TelEngine::destruct(frame);
// Change state ?
if (!chgState)
return true;
reset();
changeState(newState,"received frame");
switch (newState) {
case Established:
timer(false,true);
lock.drop();
if (m_management)
m_management->multipleFrameEstablished(localTei(),confirmation,false,this);
else
multipleFrameEstablished(localTei(),confirmation,false);
break;
case Released:
lock.drop();
if (m_management)
m_management->multipleFrameReleased(localTei(),confirmation,false,this);
else
multipleFrameReleased(localTei(),confirmation,false);
break;
case WaitEstablish:
sendUFrame(ISDNFrame::SABME,true,true);
timer(true,false);
break;
case WaitRelease:
sendUFrame(ISDNFrame::DISC,true,true);
timer(true,false);
break;
}
return true;
}
// Process a notification generated by the attached interface
bool ISDNQ921::notify(SignallingInterface::Notification event)
{
Lock lock(l2Mutex());
if (event != SignallingInterface::LinkUp)
m_hwErrors++;
else {
Debug(this,DebugInfo,"Received notification %u: '%s'",
event,lookup(event,SignallingInterface::s_notifName));
return true;
}
if (event == SignallingInterface::LinkDown) {
Debug(this,DebugWarn,"Received notification %u: '%s'",
event,lookup(event,SignallingInterface::s_notifName));
reset();
changeState(Released,"interface down");
lock.drop();
multipleFrameReleased(localTei(),false,false);
if (m_management && !network()) {
teiAssigned(false);
setRi(0);
}
if (autoRestart())
multipleFrame(localTei(),true,false);
return true;
}
#ifdef DEBUG
if (!(m_hwErrors % 250))
Debug(this,DebugNote,"Received notification %u: '%s'. Total=%u",
event,lookup(event,SignallingInterface::s_notifName,"Undefined"),m_hwErrors);
#endif
return true;
}
// Reset data
void ISDNQ921::reset()
{
Lock lock(l2Mutex());
XDebug(this,DebugAll,"Reset, total frames: %d [%p]",m_outFrames.count(),this);
m_remoteBusy = false;
m_timerRecovery = false;
m_rejectSent = false;
m_lastPFBit = false;
m_n200.reset();
m_window.reset();
timer(false,false);
m_outFrames.clear();
m_va = m_vs = m_vr = 0;
}
// Acknoledge pending outgoing frames. See Q.921 5.6.3.2
// Remove ack'd frames from queue. Start idle timer
bool ISDNQ921::ackOutgoingFrames(const ISDNFrame* frame)
{
bool ack = false, unack = false;
// Acknoledge frames with N(S) up to frame->nr() (not including)
for (;;) {
ObjList* obj = m_outFrames.skipNull();
ISDNFrame* f = obj ? static_cast<ISDNFrame*>(obj->get()) : 0;
// Stop when no frames or seq number equals nr
if (!f || frame->nr() == f->ns()) {
if (f && f->sent())
unack = true;
break;
}
ack = true;
XDebug(this,DebugAll,
"Remove acknowledged data frame (%p). Sequence number: %u",f,f->ns());
m_window.dec();
m_outFrames.remove(f,true);
}
// Reset T200 if not in timer-recovery condition and ack some frame
// 5.5.3.2: Note 1: Dont't reset if we've requested a response and haven't got one
if (!m_timerRecovery && ack &&
!(frame->type() != ISDNFrame::I && m_lastPFBit))
timer(false,false);
// Start T200 if we have unacknowledged data and not already started
if (unack && !m_retransTimer.started())
timer(true,false);
return ack;
}
// Receive I/UI (data) frames (See Q.921 5.6.2)
// Send unacknowledged data to upper layer
// Ack pending outgoing data and confirm (by sending any pending data or an RR confirmation)
bool ISDNQ921::processDataFrame(const ISDNFrame* frame, bool ack)
{
// Always accept UI
if (!ack)
return true;
// Acknowledged data: accept only when established
if (state() != Established) {
dropFrame(frame,s_noState);
return false;
}
m_rejectSent = false;
m_remoteBusy = false;
m_vr = frame->ns();
Modulo128::inc(m_vr);
XDebug(this,DebugAll,"Set V(R) to %u",m_vr);
ackOutgoingFrames(frame);
m_va = frame->nr();
XDebug(this,DebugAll,"Set V(A) to %u.",m_va);
// P/F=1: Q.921 5.6.2.1 P/F=0: Q.921 5.6.2.2
if (frame->poll())
sendSFrame(ISDNFrame::RR,false,true);
else
if (!sendOutgoingData())
sendSFrame(ISDNFrame::RR,false,false);
// Start T203 if T200 not started
if (!m_retransTimer.started())
timer(false,true);
return true;
}
// Process received S (supervisory) frames: RR, REJ, RNR
// All Ack outgoing frames. Respond with RR if requested
// RR Send pending frames. Start idle timer
// REJ Send pending frames. Adjust send frame and expected frame counter if necessary
// RNR Adjust send frame counter if necessary
bool ISDNQ921::processSFrame(const ISDNFrame* frame)
{
if (!frame)
return false;
Lock lock(l2Mutex());
if (state() != Established) {
dropFrame(frame,s_noState);
return false;
}
if (frame->type() == ISDNFrame::RR) {
// Ack sent data. Send unsent data
// Respond if it's an unsolicited frame with P/F set to 1
m_remoteBusy = false;
ackOutgoingFrames(frame);
bool sent = sendOutgoingData();
if (frame->poll()) {
// Check if we requested a response. If not, respond if it is a command
if (!m_lastPFBit && frame->command())
sendSFrame(ISDNFrame::RR,false,true);
// Don't reset if we've sent any data
if (!sent) {
m_lastPFBit = false;
timer(false,true);
}
}
if (!m_retransTimer.started() && !m_idleTimer.started())
timer(false,true);
return false;
}
// Q.921 5.6.4: Receiving REJ frames
if (frame->type() == ISDNFrame::REJ) {
m_remoteBusy = false;
// Ack sent data.
ackOutgoingFrames(frame);
// Q.921 5.6.4 a) and b)
bool rspPF = !frame->command() && frame->poll();
if (!m_timerRecovery || (m_timerRecovery && rspPF)) {
m_vs = m_va = frame->nr();
XDebug(this,DebugAll,"Set V(S) and V(A) to %u.",m_vs);
if (!m_timerRecovery && frame->command() && frame->poll())
sendSFrame(ISDNFrame::RR,false,true);
// Retransmit only if we didn't sent a supervisory frame
if (!m_lastPFBit) {
bool t200 = sendOutgoingData(true);
timer(t200,!t200);
}
if (!m_timerRecovery && rspPF)
Debug(this,DebugNote,"Frame (%p) is a REJ response with P/F set",frame);
m_timerRecovery = false;
return false;
}
// Q.921 5.6.4 c)
m_va = frame->nr();
XDebug(this,DebugAll,"Set V(A) to %u.",m_va);
if (frame->command() && frame->poll())
sendSFrame(ISDNFrame::RR,false,true);
return false;
}
// Q.921 5.6.5: Receiving RNR frames
if (frame->type() == ISDNFrame::RNR) {
m_remoteBusy = true;
// Ack sent data.
ackOutgoingFrames(frame);
// Respond
if (frame->poll()) {
if (frame->command())
sendSFrame(ISDNFrame::RR,false,true);
else {
m_timerRecovery = false;
m_vs = frame->nr();
XDebug(this,DebugAll,"Set V(S) to %u.",m_vs);
}
}
if (!m_lastPFBit)
timer(true,false);
return false;
}
dropFrame(frame,s_noState);
return false;
}
// Receive U frames: UA, DM, SABME, DISC, FRMR
// UA If P/F = 0: DROP - not a valid response
// State is Wait...: it's a valid response: notify layer 3 and change state
// Otherwise: DROP
// DM State is Established or Released
// P/F = 0: It's an establish request. Send SABME. Change state
// P/F = 1: If state is Established and timer recovery: schedule establish
// State is WaitEstablish or WaitRelease and P/F = 1: Release. Notify layer 3
// Otherwise: DROP
// SABME State is Established or Released: Confirm. Notify layer 3. Reset
// State is WaitEstablish: Just confirm
// State is WaitRelease: Send DM. Release. Notify layer 3
// DISC State is Established: Confirm. Release. Notify layer 3
// State is Released: Just send a DM response
// State is WaitEstablish: Send DM response. Release. Notify layer 3
// State is WaitRelease: Just confirm
// FRMR If state is Established: re-establish
// Otherwise: DROP
bool ISDNQ921::processUFrame(const ISDNFrame* frame, State& newState,
bool& confirmation)
{
switch (frame->type()) {
case ISDNFrame::UA:
if (!(frame->poll() &&
(state() == WaitEstablish || state() == WaitRelease)))
break;
newState = (state() == WaitEstablish ? Established : Released);
confirmation = true;
return true;
case ISDNFrame::DM:
if (state() == Established || state() == Released) {
if (!frame->poll()) {
newState = WaitEstablish;
return true;
}
if (state() == Established && m_timerRecovery) {
m_pendingDMSabme = true;
return false;
}
}
if (frame->poll()) {
newState = Released;
confirmation = true;
return true;
}
break;
case ISDNFrame::SABME:
if (state() == Established || state() == Released) {
sendUFrame(ISDNFrame::UA,false,frame->poll());
newState = Established;
confirmation = false;
return true;
}
if (state() == WaitEstablish) {
sendUFrame(ISDNFrame::UA,false,frame->poll());
return false;
}
sendUFrame(ISDNFrame::DM,false,frame->poll());
newState = Released;
confirmation = true;
return true;
case ISDNFrame::DISC:
switch (state()) {
case Established:
sendUFrame(ISDNFrame::UA,false,frame->poll());
newState = Released;
confirmation = false;
return true;
case Released:
sendUFrame(ISDNFrame::DM,false,frame->poll());
return false;
case WaitEstablish:
sendUFrame(ISDNFrame::DM,false,frame->poll());
newState = Released;
confirmation = true;
return true;
case WaitRelease:
sendUFrame(ISDNFrame::UA,false,frame->poll());
return false;
}
break;
case ISDNFrame::FRMR:
if (state() == Established) {
newState = WaitEstablish;
return true;
}
break;
default: ;
}
dropFrame(frame,s_noState);
return false;
}
// Accept frame according to Q.921 5.8.5. Reasons to reject:
// Unknown command/response
// Invalid N(R)
// Information field too long
// Update receive counters
bool ISDNQ921::acceptFrame(ISDNFrame* frame, bool& reject)
{
reject = false;
// Update received frames
m_rxFrames++;
// Check frame only if it's not already invalid
for (; frame->error() < ISDNFrame::Invalid;) {
// Check SAPI/TEI
if (frame->sapi() != localSapi() || frame->tei() != localTei()) {
frame->m_error = ISDNFrame::ErrInvalidAddress;
break;
}
// Drop out of range I frames
if (frame->type() == ISDNFrame::I && frame->ns() != m_vr) {
frame->m_error = ISDNFrame::ErrTxSeqNo;
break;
}
// Check DISC/SABME commands and UA/DM responses
if (((frame->type() == ISDNFrame::SABME || frame->type() == ISDNFrame::DISC) &&
!frame->command()) ||
((frame->type() == ISDNFrame::UA || frame->type() == ISDNFrame::DM) &&
frame->command())) {
Debug(this,DebugMild,
"Received '%s': The remote peer has the same data link side type",
frame->name());
frame->m_error = ISDNFrame::ErrInvalidCR;
break;
}
// We don't support XID
if (frame->type() == ISDNFrame::XID) {
frame->m_error = ISDNFrame::ErrUnsupported;
break;
}
// Check N(R) for I or S frames (N(R) is set to 0xFF for U frames):
// N(R) should be between V(A) and V(S)
if (frame->nr() < 128 && !Modulo128::between(frame->nr(),m_va,m_vs)) {
frame->m_error = ISDNFrame::ErrRxSeqNo;
break;
}
// Check data length
if (frame->dataLength() > maxUserData()) {
frame->m_error = ISDNFrame::ErrDataLength;
break;
}
break;
}
// Accepted
if (frame->error() < ISDNFrame::Invalid)
return true;
// Frame is invalid. Reject or drop ?
if (frame->error() == ISDNFrame::ErrUnknownCR ||
frame->error() == ISDNFrame::ErrRxSeqNo ||
frame->error() == ISDNFrame::ErrDataLength) {
// Check if the state allows the rejection. Not allowed if:
// - Not in multiple frame operation mode
if (state() == Established) {
m_rxRejectedFrames++;
reject = true;
return false;
}
}
dropFrame(frame,ISDNFrame::typeName(frame->error()));
return false;
}
void ISDNQ921::dropFrame(const ISDNFrame* frame, const char* reason)
{
m_rxDroppedFrames++;
DDebug(this,DebugNote,
"Dropping frame (%p): %s. Reason: %s. V(S),V(R),V(A)=%u,%u,%u",
frame,frame->name(),reason,m_vs,m_vr,m_va);
}
// Send U frames except for UI frames
bool ISDNQ921::sendUFrame(ISDNFrame::Type type, bool command, bool pf,
bool retrans)
{
switch (type) {
case ISDNFrame::SABME:
case ISDNFrame::DISC:
case ISDNFrame::DM:
case ISDNFrame::UA:
case ISDNFrame::FRMR:
break;
default:
return false;
}
// Create and send frame
// U frames don't have an N(R) control data
ISDNFrame* f = new ISDNFrame(type,command,network(),localSapi(),localTei(),pf);
f->sent(retrans);
bool result = sendFrame(f);
TelEngine::destruct(f);
return result;
}
// Send S frames
bool ISDNQ921::sendSFrame(ISDNFrame::Type type, bool command, bool pf)
{
if (!(type == ISDNFrame::RR ||
type == ISDNFrame::RNR ||
type == ISDNFrame::REJ))
return false;
// Create and send frame
ISDNFrame* f = new ISDNFrame(type,command,network(),localSapi(),localTei(),pf,m_vr);
bool result = sendFrame(f);
TelEngine::destruct(f);
return result;
}
// Send a frame to remote peer. Dump data on success if we have a dumper
bool ISDNQ921::sendFrame(const ISDNFrame* frame)
{
if (!frame)
return false;
// This should never happen !!!
if (frame->type() >= ISDNFrame::Invalid) {
Debug(this,DebugWarn,"Refusing to send '%s' frame",frame->name());
return false;
}
// Print frame
if (debugAt(DebugInfo) && m_printFrames && !m_errorSend && frame->type() != ISDNFrame::UI) {
String tmp;
frame->toString(tmp,m_extendedDebug);
Debug(this,DebugInfo,"Sending frame (%p):%s",
frame,tmp.c_str());
}
bool result = m_management ? m_management->sendFrame(frame,this) :
SignallingReceiver::transmitPacket(frame->buffer(),false,SignallingInterface::Q921);
// Dump frame if no error and we have a dumper
if (result) {
m_txFrames++;
dump(frame->buffer(),true);
m_errorSend = false;
}
else {
m_txFailFrames++;
if (!m_errorSend)
Debug(this,DebugNote,"Error sending frame (%p): %s",frame,frame->name());
m_errorSend = true;
}
return result;
}
// Send (or re-send) enqueued data frames
bool ISDNQ921::sendOutgoingData(bool retrans)
{
bool sent = false;
for (;;) {
if (m_remoteBusy || m_window.empty())
break;
ObjList* obj = m_outFrames.skipNull();
// Queue empty ?
if (!obj)
break;
ISDNFrame* frame = 0;
// Not a retransmission: skip already sent frames
if (!retrans)
for (; obj; obj = obj->skipNext()) {
frame = static_cast<ISDNFrame*>(obj->get());
if (!frame->sent())
break;
}
// Send the remaining unsent frames in window or
// the whole queue if it is a retransmission
for (; obj ; obj = obj->skipNext()) {
frame = static_cast<ISDNFrame*>(obj->get());
// Update frame receive sequence number
frame->update(0,&m_vr);
XDebug(this,DebugAll,
"Sending data frame (%p). Sequence number: %u. Retransmission: %s",
frame,frame->ns(),String::boolText(frame->sent()));
// T200
if (!m_retransTimer.started())
timer(true,false);
// Send
sendFrame(frame);
sent = true;
frame->sent(true);
}
break;
}
return sent;
}
// Start/stop idle or retransmission timers
void ISDNQ921::timer(bool start, bool t203, u_int64_t time)
{
if (start) {
if (m_idleTimer.started()) {
m_idleTimer.stop();
XDebug(this,DebugAll,"T203 stopped");
}
// Start anyway. Even if already started
if (!time)
time = Time::msecNow();
m_retransTimer.start(time);
XDebug(this,DebugAll,"T200 started. Transmission counter: %u",
m_n200.count());
}
else {
m_n200.reset();
if (m_retransTimer.started()) {
m_retransTimer.stop();
XDebug(this,DebugAll,"T200 stopped");
}
if (t203) {
if (!m_idleTimer.started()) {
if (!time)
time = Time::msecNow();
m_idleTimer.start(time);
XDebug(this,DebugAll,"T203 started");
}
}
else if (m_idleTimer.started()) {
m_idleTimer.stop();
XDebug(this,DebugAll,"T203 stopped");
}
}
}
/**
* ISDNQ921Management
*/
// Constructor
ISDNQ921Management::ISDNQ921Management(const NamedList& params, const char* name, bool net)
: SignallingComponent(name,&params,"isdn-q921-mgm"),
ISDNLayer2(params,name),
SignallingReceiver(name),
SignallingDumpable(SignallingDumper::Q921,network()),
m_teiManTimer(0), m_teiTimer(0)
{
#ifdef DEBUG
if (debugAt(DebugAll)) {
String tmp;
params.dump(tmp,"\r\n ",'\'',true);
Debug(this,DebugAll,"ISDNQ921Management::ISDNQ921Management(%p,'%s',%s) [%p]%s",
&params,name,String::boolText(net),this,tmp.c_str());
}
#endif
String baseName = toString();
m_network = net;
m_teiManTimer.interval(params,"t202",2500,2600,false);
m_teiTimer.interval(params,"t201",1000,5000,false);
setDumper(params.getValue(YSTRING("layer2dump")));
bool set0 = true;
if (baseName.endsWith("Management")) {
baseName = baseName.substr(0,baseName.length()-10);
set0 = false;
}
// If we are NET create one ISDNQ921 for each possible TEI
for (int i = 0; i < 127; i++) {
if (network() || (i == 0)) {
String qName = baseName;
if (!network())
qName << "-CPE";
else if (set0 || (i != 0))
qName << "-" << i;
m_layer2[i] = new ISDNQ921(params,qName,this,i);
m_layer2[i]->ISDNLayer2::attach(this);
}
else
m_layer2[i] = 0;
}
if (!network()) {
m_layer2[0]->teiAssigned(false);
m_teiManTimer.start();
}
}
ISDNQ921Management::~ISDNQ921Management()
{
Lock lock(l2Mutex());
ISDNLayer2::attach((ISDNLayer3*)0);
TelEngine::destruct(SignallingReceiver::attach(0));
for (int i = 0; i < 127; i++)
TelEngine::destruct(m_layer2[i]);
}
bool ISDNQ921Management::initialize(const NamedList* config)
{
#ifdef DEBUG
String tmp;
if (config && debugAt(DebugAll))
config->dump(tmp,"\r\n ",'\'',true);
Debug(this,DebugInfo,"ISDNQ921Management::initialize(%p) [%p]%s",config,this,tmp.c_str());
#endif
if (config)
debugLevel(config->getIntValue(YSTRING("debuglevel_q921mgmt"),
config->getIntValue(YSTRING("debuglevel"),-1)));
if (config && !iface()) {
NamedList params("");
if (resolveConfig(YSTRING("sig"),params,config) ||
resolveConfig(YSTRING("basename"),params,config)) {
params.addParam("basename",params);
params.assign(params + "/D");
fixParams(params,config);
SignallingInterface* ifc = YSIGCREATE(SignallingInterface,&params);
if (!ifc)
return false;
SignallingReceiver::attach(ifc);
if (ifc->initialize(&params))
SignallingReceiver::control(SignallingInterface::Enable);
else
TelEngine::destruct(SignallingReceiver::attach(0));
}
}
return 0 != iface();
}
void ISDNQ921Management::engine(SignallingEngine* eng)
{
SignallingComponent::engine(eng);
for (int i = 0; i < 127; i++)
if (m_layer2[i])
m_layer2[i]->engine(eng);
}
void ISDNQ921Management::cleanup()
{
Lock lock(l2Mutex());
for (int i = 0;i < 127; i++)
if (m_layer2[i])
m_layer2[i]->cleanup();
}
bool ISDNQ921Management::multipleFrame(u_int8_t tei, bool establish, bool force)
{
if (tei >= 127)
return false;
m_sapi = Q921_SAPI_MANAGEMENT;
l2Mutex().lock();
RefPointer<ISDNQ921> q921 = m_layer2[network() ? tei : 0];
l2Mutex().unlock();
return q921 && q921->multipleFrame(tei,establish,force);
}
bool ISDNQ921Management::sendFrame(const ISDNFrame* frame, const ISDNQ921* q921)
{
if (!frame)
return false;
Lock lock(l2Mutex());
if (SignallingReceiver::transmitPacket(frame->buffer(),false,SignallingInterface::Q921)) {
dump(frame->buffer(),true);
return true;
}
return false;
}
bool ISDNQ921Management::sendData(const DataBlock& data, u_int8_t tei, bool ack)
{
if (tei > Q921_TEI_BROADCAST)
return false;
if (tei == Q921_TEI_BROADCAST)
ack = false;
int auxTei = tei;
Lock lock(l2Mutex());
if (!network()) {
if (m_layer2[0] && m_layer2[0]->teiAssigned())
auxTei = 0;
else
return false;
}
if (ack)
return m_layer2[auxTei] && m_layer2[auxTei]->sendData(data,tei,true);
// P/F bit is always false for UI frames. See Q.921 5.2.2
ISDNFrame* f = new ISDNFrame(false,network(),0,tei,false,data);
bool ok = sendFrame(f);
lock.drop();
TelEngine::destruct(f);
return ok;
}
void ISDNQ921Management::multipleFrameEstablished(u_int8_t tei, bool confirm, bool timeout, ISDNLayer2* layer2)
{
m_layer3Mutex.lock();
RefPointer<ISDNLayer3> l3 = m_layer3;
m_layer3Mutex.unlock();
if (l3)
l3->multipleFrameEstablished(tei,confirm,timeout,layer2);
else
Debug(this,DebugNote,"'Established' notification. No Layer 3 attached");
}
void ISDNQ921Management::multipleFrameReleased(u_int8_t tei, bool confirm, bool timeout, ISDNLayer2* layer2)
{
m_layer3Mutex.lock();
RefPointer<ISDNLayer3> l3 = m_layer3;
m_layer3Mutex.unlock();
if (l3)
l3->multipleFrameReleased(tei,confirm,timeout,layer2);
else
Debug(this,DebugNote,"'Released' notification. No Layer 3 attached");
}
void ISDNQ921Management::dataLinkState(u_int8_t tei, bool cmd, bool value, ISDNLayer2* layer2)
{
m_layer3Mutex.lock();
RefPointer<ISDNLayer3> l3 = m_layer3;
m_layer3Mutex.unlock();
if (l3)
l3->dataLinkState(tei,cmd,value,layer2);
else
Debug(this,DebugNote,"Data link notification. No Layer 3 attached");
}
void ISDNQ921Management::receiveData(const DataBlock& data, u_int8_t tei, ISDNLayer2* layer2)
{
m_layer3Mutex.lock();
RefPointer<ISDNLayer3> l3 = m_layer3;
m_layer3Mutex.unlock();
if (!network()) {
l2Mutex().lock();
if (m_layer2[0])
tei = m_layer2[0]->localTei();
l2Mutex().unlock();
}
if (l3)
l3->receiveData(data,tei,layer2);
else
Debug(this,DebugNote,"Data received. No Layer 3 attached");
}
// Process a Signalling Packet received by the interface
bool ISDNQ921Management::receivedPacket(const DataBlock& packet)
{
Lock lock(l2Mutex());
ISDNFrame* frame = parsePacket(packet);
if (!frame)
return false;
if (frame->type() < ISDNFrame::Invalid)
dump(frame->buffer(),false);
// Non UI frame (even invalid): send it to the appropriate Layer 2
if (frame->type() != ISDNFrame::UI) {
if (network()) {
if (m_layer2[frame->tei()] && m_layer2[frame->tei()]->m_ri) {
lock.drop();
return m_layer2[frame->tei()]->receivedFrame(frame);
}
sendTeiManagement(ISDNFrame::TeiRemove,0,frame->tei());
lock.drop();
TelEngine::destruct(frame);
return false;
}
else if (m_layer2[0] && m_layer2[0]->m_ri && m_layer2[0]->localTei() == frame->tei()) {
lock.drop();
return m_layer2[0]->receivedFrame(frame);
}
return false;
}
if (!processTeiManagement(frame)) {
DataBlock tmp;
frame->getData(tmp);
u_int8_t tei = frame->tei();
TelEngine::destruct(frame);
receiveData(tmp,tei,m_layer2[0]);
return true;
}
// FIXME
TelEngine::destruct(frame);
return true;
}
// Periodically called method to take care of timers
void ISDNQ921Management::timerTick(const Time& when)
{
if (network()) {
if (m_teiTimer.started() && m_teiTimer.timeout(when.msec())) {
for (u_int8_t i = 0; i < 127; i++) {
if (m_layer2[i] && !m_layer2[i]->m_checked) {
m_layer2[i]->setRi(0);
m_layer2[i]->teiAssigned(false);
multipleFrameReleased(i,false,true,this);
}
}
m_teiTimer.stop();
}
}
else if (m_layer2[0]) {
if (m_layer2[0]->teiAssigned())
m_teiManTimer.stop();
else if (!m_teiManTimer.started())
m_teiManTimer.start();
else if (m_teiManTimer.timeout(when.msec())) {
m_teiManTimer.stop();
u_int16_t ri = m_layer2[0]->m_ri;
while (!ri)
ri = (u_int16_t)Random::random();
m_layer2[0]->m_tei = 0;
m_layer2[0]->setRi(ri);
sendTeiManagement(ISDNFrame::TeiReq,ri,Q921_TEI_BROADCAST);
}
}
}
// Forward interface notifications to controlled Q.921
bool ISDNQ921Management::notify(SignallingInterface::Notification event)
{
DDebug(this,DebugInfo,"Received notification %u: '%s'",
event,lookup(event,SignallingInterface::s_notifName));
for (u_int8_t i = 0; i < 127; i++)
if (m_layer2[i])
m_layer2[i]->notify(event);
return true;
}
// Process TEI management frames according to their type
bool ISDNQ921Management::processTeiManagement(ISDNFrame* frame)
{
if (!frame)
return false;
if (!frame->checkTeiManagement())
return false;
DataBlock data;
frame->getData(data);
u_int8_t ai = ISDNFrame::getAi(data);
u_int16_t ri = ISDNFrame::getRi(data);
u_int8_t type = ISDNFrame::getType(data);
XDebug(this,DebugAll,"Management frame type=0x%02X ri=%u ai=%u",type,ri,ai);
switch (type) {
case ISDNFrame::TeiReq:
processTeiRequest(ri,ai,frame->poll());
break;
case ISDNFrame::TeiRemove:
processTeiRemove(ai);
break;
case ISDNFrame::TeiCheckReq:
processTeiCheckRequest(ai,frame->poll());
break;
case ISDNFrame::TeiAssigned:
processTeiAssigned(ri,ai);
break;
case ISDNFrame::TeiDenied:
processTeiDenied(ri);
break;
case ISDNFrame::TeiCheckRsp:
processTeiCheckResponse(ri,ai);
break;
case ISDNFrame::TeiVerify:
processTeiVerify(ai,frame->poll());
break;
default:
Debug(this,DebugNote,"Unknown management frame type 0x%02X",type);
}
return true;
}
// Build and send a TEI management frame
bool ISDNQ921Management::sendTeiManagement(ISDNFrame::TeiManagement type,
u_int16_t ri, u_int8_t ai, u_int8_t tei, bool pf)
{
DataBlock data;
if (!ISDNFrame::buildTeiManagement(data,type,ri,ai)) {
Debug(this,DebugNote,"Could not build TEI management frame");
return false;
}
ISDNFrame* frame = new ISDNFrame(false,network(),
Q921_SAPI_MANAGEMENT,tei,pf,data);
bool ok = sendFrame(frame);
TelEngine::destruct(frame);
return ok;
}
// We are NET, a CPE has requested a TEI assignment
void ISDNQ921Management::processTeiRequest(u_int16_t ri, u_int8_t ai, bool pf)
{
if (!network() || !ri)
return;
if (ai < 127 && m_layer2[ai] && m_layer2[ai]->m_ri == ri) {
// TEI already assigned to same reference number, confirm it
sendTeiManagement(ISDNFrame::TeiAssigned,ri,ai,Q921_TEI_BROADCAST,pf);
return;
}
u_int8_t i;
for (i = 0; i < 127; i++) {
if (!m_layer2[i])
continue;
if (m_layer2[i]->m_ri == ri) {
// Reference number already used for different TEI
sendTeiManagement(ISDNFrame::TeiDenied,ri,ai,Q921_TEI_BROADCAST,pf);
return;
}
}
for (i = 64; i < 127; i++) {
if (m_layer2[i]->m_ri != 0)
continue;
// Found a free dynamic TEI slot, assign to given reference number
if (sendTeiManagement(ISDNFrame::TeiAssigned,ri,i,Q921_TEI_BROADCAST,pf)) {
m_layer2[i]->setRi(ri);
m_layer2[i]->reset();
}
return;
}
// All dynamic TEI slots are in use, deny new request
sendTeiManagement(ISDNFrame::TeiDenied,ri,Q921_TEI_BROADCAST,pf);
m_teiTimer.stop();
// Mark all dynamic TEI slots as not checked and ask them to check
for (i = 64; i < 127; i++)
if (m_layer2[i])
m_layer2[i]->m_checked = false;
sendTeiManagement(ISDNFrame::TeiCheckReq,0,Q921_TEI_BROADCAST);
m_teiTimer.start();
}
// We are CPE, NET asked us to remove our TEI
void ISDNQ921Management::processTeiRemove(u_int8_t ai)
{
if (network())
return;
u_int8_t tei = m_layer2[0]->localTei();
if ((ai == tei) || (ai == Q921_TEI_BROADCAST && tei >= 64)) {
Debug(this,((tei < 64) ? DebugMild : DebugInfo),"Removing our TEI %u",tei);
m_layer2[0]->teiAssigned(false);
m_layer2[0]->setRi(0);
multipleFrameReleased(ai,false,false,this);
m_teiManTimer.start();
}
}
// We are CPE, NET is checking our TEI
void ISDNQ921Management::processTeiCheckRequest(u_int8_t ai, bool pf)
{
if (network())
return;
if (m_layer2[0]->m_ri && ((ai == Q921_TEI_BROADCAST) || (ai == m_layer2[0]->localTei())))
sendTeiManagement(ISDNFrame::TeiCheckRsp,m_layer2[0]->m_ri,ai,Q921_TEI_BROADCAST,pf);
}
// We are NET and received a TEI check response to our request
void ISDNQ921Management::processTeiCheckResponse(u_int16_t ri, u_int8_t ai)
{
if (!network())
return;
if ((ai >= 127) || !m_layer2[ai])
return;
if (m_layer2[ai]->m_ri == ri)
m_layer2[ai]->m_checked = true;
else if (sendTeiManagement(ISDNFrame::TeiRemove,ri,ai))
m_layer2[ai]->setRi(0);
}
// We are CPE and the NET assigned a TEI, possibly to us
void ISDNQ921Management::processTeiAssigned(u_int16_t ri, u_int8_t ai)
{
if (network())
return;
if (m_layer2[0]->m_ri != ri)
return;
m_teiManTimer.stop();
m_layer2[0]->m_tei = ai;
m_layer2[0]->teiAssigned(true);
multipleFrame(ai,true,true);
}
// We are CPE and the NET denied assigning a TEI, possibly to us
void ISDNQ921Management::processTeiDenied(u_int16_t ri)
{
if (network())
return;
if (m_layer2[0]->m_ri != ri)
return;
m_layer2[0]->setRi(0);
m_teiManTimer.start();
}
// We are NET, a CPE is asking to be verified
void ISDNQ921Management::processTeiVerify(u_int8_t ai, bool pf)
{
if (!network())
return;
if ((ai < 127) && m_layer2[ai] && m_layer2[ai]->m_ri)
sendTeiManagement(ISDNFrame::TeiCheckReq,0,ai,Q921_TEI_BROADCAST,pf);
}
/**
* ISDNQ921Passive
*/
// Constructor. Set data members. Print them
ISDNQ921Passive::ISDNQ921Passive(const NamedList& params, const char* name)
: SignallingComponent(name,&params,"isdn-q921-passive"),
ISDNLayer2(params,name),
SignallingReceiver(name),
SignallingDumpable(SignallingDumper::Q921,network()),
m_checkLinkSide(false),
m_idleTimer(0),
m_lastFrame(255),
m_rxFrames(0),
m_rxDroppedFrames(0),
m_hwErrors(0),
m_printFrames(true),
m_extendedDebug(false),
m_errorReceive(false)
{
#ifdef DEBUG
if (debugAt(DebugAll)) {
String tmp;
params.dump(tmp,"\r\n ",'\'',true);
Debug(this,DebugAll,"ISDNQ921Passive::ISDNQ921Passive(%p,'%s') [%p]%s",
&params,name,this,tmp.c_str());
}
#endif
m_idleTimer.interval(params,"idletimeout",4000,30000,false);
m_checkLinkSide = detectType();
setDebug(params.getBoolValue(YSTRING("print-frames"),false),
params.getBoolValue(YSTRING("extended-debug"),false));
DDebug(this,DebugInfo,
"ISDN Passive Data Link type=%s autodetect=%s idle-timeout=%u [%p]",
linkSide(network()),String::boolText(detectType()),
(unsigned int)m_idleTimer.interval(),this);
m_idleTimer.start();
// Try to dump from specific parameter, fall back to generic
const char* dump = network() ? "layer2dump-net" : "layer2dump-cpe";
setDumper(params.getValue(dump,params.getValue(YSTRING("layer2dump"))));
}
// Destructor
ISDNQ921Passive::~ISDNQ921Passive()
{
Lock lock(l2Mutex());
ISDNLayer2::attach(0);
TelEngine::destruct(SignallingReceiver::attach(0));
cleanup();
DDebug(this,DebugAll,
"ISDN Passive Data Link destroyed. Frames: recv=%u dropped=%u. HW errors=%u [%p]",
(unsigned int)m_rxFrames,(unsigned int)m_rxDroppedFrames,(unsigned int)m_hwErrors,this);
}
bool ISDNQ921Passive::initialize(const NamedList* config)
{
#ifdef DEBUG
String tmp;
if (config && debugAt(DebugAll))
config->dump(tmp,"\r\n ",'\'',true);
Debug(this,DebugInfo,"ISDNQ921Passive::initialize(%p) [%p]%s",config,this,tmp.c_str());
#endif
if (config) {
debugLevel(config->getIntValue(YSTRING("debuglevel_q921"),
config->getIntValue(YSTRING("debuglevel"),-1)));
setDebug(config->getBoolValue(YSTRING("print-frames"),false),
config->getBoolValue(YSTRING("extended-debug"),false));
}
if (config && !iface()) {
NamedList params("");
if (resolveConfig(YSTRING("sig"),params,config) ||
resolveConfig(YSTRING("basename"),params,config)) {
params.addParam("basename",params);
params.assign(params + "/D");
params.addParam("readonly",String::boolText(true));
fixParams(params,config);
SignallingInterface* ifc = YSIGCREATE(SignallingInterface,&params);
if (!ifc)
return false;
SignallingReceiver::attach(ifc);
if (ifc->initialize(&params))
SignallingReceiver::control(SignallingInterface::Enable);
else
TelEngine::destruct(SignallingReceiver::attach(0));
}
}
return 0 != iface();
}
// Reset data
void ISDNQ921Passive::cleanup()
{
Lock lock(l2Mutex());
m_idleTimer.start();
}
// Called periodically by the engine to check timeouts
// Check idle timer. Notify upper layer on timeout
void ISDNQ921Passive::timerTick(const Time& when)
{
Lock lock(l2Mutex(),SignallingEngine::maxLockWait());
if (!(lock.locked() && m_idleTimer.timeout(when.msec())))
return;
// Timeout. Notify layer 3. Restart timer
XDebug(this,DebugNote,"Timeout. Channel was idle for " FMT64 " ms",m_idleTimer.interval());
m_idleTimer.start(when.msec());
lock.drop();
idleTimeout();
}
// Process a packet received by the receiver's interface
bool ISDNQ921Passive::receivedPacket(const DataBlock& packet)
{
if (!packet.length())
return false;
Lock lock(l2Mutex());
XDebug(this,DebugAll,"Received packet (Length: %u)",packet.length());
ISDNFrame* frame = parsePacket(packet);
if (!frame) {
if (!m_errorReceive)
Debug(this,DebugNote,"Received invalid frame (Length: %u)",packet.length());
m_errorReceive = true;
return false;
}
m_errorReceive = false;
// Print & dump
if (debugAt(DebugInfo) && m_printFrames) {
String tmp;
frame->toString(tmp,m_extendedDebug);
Debug(this,DebugInfo,"Received frame (%p):%s",frame,tmp.c_str());
}
if (frame->type() < ISDNFrame::Invalid)
dump(frame->buffer(),false);
// Received enough data to parse. Assume the channel not idle (restart timer)
// If accepted, the frame is a data frame or a unnumbered (SABME,DISC,UA,DM) one
// Drop retransmissions of data frames
// Send data or notification to the upper layer
m_idleTimer.start();
lock.drop();
bool cmd,value;
if (acceptFrame(frame,cmd,value)) {
if (frame->category() == ISDNFrame::Data) {
if (m_lastFrame != frame->ns()) {
DataBlock tmp;
frame->getData(tmp);
m_lastFrame = frame->ns();
receiveData(tmp,localTei());
}
}
else
dataLinkState(localTei(),cmd,value);
}
TelEngine::destruct(frame);
return true;
}
// Process a notification generated by the attached interface
bool ISDNQ921Passive::notify(SignallingInterface::Notification event)
{
Lock lock(l2Mutex());
if (event != SignallingInterface::LinkUp)
m_hwErrors++;
else {
Debug(this,DebugInfo,"Received notification %u: '%s'",
event,lookup(event,SignallingInterface::s_notifName));
return true;
}
if (event == SignallingInterface::LinkDown)
Debug(this,DebugWarn,"Received notification %u: '%s'",
event,lookup(event,SignallingInterface::s_notifName));
#ifdef DEBUG
else if (!(m_hwErrors % 250))
Debug(this,DebugNote,"Received notification %u: '%s'. Total=%u",
event,lookup(event,SignallingInterface::s_notifName,"Undefined"),m_hwErrors);
#endif
return true;
}
// Accept frame according to Q.921 5.8.5
// Filter received frames. Accept only frames that would generate a notification to the upper layer:
// UI/I and valid SABME/DISC/UA/DM
bool ISDNQ921Passive::acceptFrame(ISDNFrame* frame, bool& cmd, bool& value)
{
// Update received frames
m_rxFrames++;
// Frame already invalid
if (frame->error() >= ISDNFrame::Invalid)
return dropFrame(frame);
// Check SAPI/TEI
if (frame->sapi() != localSapi() || frame->tei() != localTei())
return dropFrame(frame,ISDNFrame::typeName(ISDNFrame::ErrInvalidAddress));
// Valid UI/I
if (frame->category() == ISDNFrame::Data)
return true;
// Check DISC/SABME commands and UA/DM responses
cmd = (frame->type() == ISDNFrame::SABME || frame->type() == ISDNFrame::DISC);
bool response = (frame->type() == ISDNFrame::UA || frame->type() == ISDNFrame::DM);
if (m_checkLinkSide &&
((cmd && !frame->command()) || (response && frame->command()))) {
if (detectType()) {
m_checkLinkSide = false;
changeType();
}
else {
Debug(this,DebugMild,
"Received '%s': The remote peer has the same data link side type",
frame->name());
return dropFrame(frame,ISDNFrame::typeName(ISDNFrame::ErrInvalidCR));
}
}
// Normally, SABME/DISC commands and UA/DM responses should have the P/F bit set
if (cmd || response) {
if (!frame->poll())
#ifndef Q921_PASIVE_NOCHECK_PF
return dropFrame(frame,"P/F bit not set");
#else
DDebug(this,DebugNote,"Received '%s' without P/F bit set",frame->name());
#endif
m_checkLinkSide = detectType();
if (cmd)
value = (frame->type() == ISDNFrame::SABME);
else
value = (frame->type() == ISDNFrame::UA);
return true;
}
// Drop valid frames without debug message (it would be too much) and without counting them:
// Supervisory frames (Since we don't synchronize, we don't process them)
// Unsupported valid unnumbered frames (e.g. XID, UA/DM with P/F bit set ....)
if (frame->type() < ISDNFrame::Invalid)
return false;
return dropFrame(frame);
}
bool ISDNQ921Passive::dropFrame(const ISDNFrame* frame, const char* reason)
{
m_rxDroppedFrames++;
DDebug(this,DebugNote,"Dropping frame (%p): %s. Reason: %s",
frame,frame->name(),reason ? reason : ISDNFrame::typeName(frame->error()));
return false;
}
/**
* ISDNLayer2
*/
const TokenDict ISDNLayer2::m_states[] = {
{"Released", Released},
{"WaitEstablish", WaitEstablish},
{"Established", Established},
{"WaitRelease", WaitRelease},
{0,0}
};
ISDNLayer2::ISDNLayer2(const NamedList& params, const char* name, u_int8_t tei)
: SignallingComponent(name,&params),
m_layer3(0),
m_layerMutex(true,"ISDNLayer2::layer"),
m_layer3Mutex(true,"ISDNLayer2::layer3"),
m_state(Released),
m_network(false),
m_detectType(false),
m_sapi(0),
m_tei(0),
m_ri(0),
m_lastUp(0),
m_checked(false),
m_teiAssigned(false),
m_autoRestart(true),
m_maxUserData(260)
{
XDebug(this,DebugAll,"ISDNLayer2 '%s' comp=%p [%p]",name,static_cast<const SignallingComponent*>(this),this);
m_network = params.getBoolValue(YSTRING("network"),false);
m_detectType = params.getBoolValue(YSTRING("detect"),false);
int tmp = params.getIntValue(YSTRING("sapi"),0);
m_sapi = (tmp >= 0 && tmp <= Q921_SAPI_MANAGEMENT) ? tmp : 0;
tmp = params.getIntValue(YSTRING("tei"),tei);
m_tei = (tmp >= 0 && tmp < Q921_TEI_BROADCAST) ? tmp : 0;
teiAssigned(true);
m_autoRestart = params.getBoolValue(YSTRING("auto-restart"),true);
m_maxUserData = params.getIntValue(YSTRING("maxuserdata"),260);
if (!m_maxUserData)
m_maxUserData = 260;
}
ISDNLayer2::~ISDNLayer2()
{
if (m_layer3)
Debug(this,DebugCrit,"Destroyed with Layer 3 (%p) attached",m_layer3);
attach(0);
XDebug(this,DebugAll,"~ISDNLayer2");
}
// Attach an ISDN Q.931 Layer 3 if the given parameter is different from the one we have
void ISDNLayer2::attach(ISDNLayer3* layer3)
{
Lock lock(m_layer3Mutex);
if (m_layer3 == layer3)
return;
cleanup();
ISDNLayer3* tmp = m_layer3;
m_layer3 = layer3;
lock.drop();
if (tmp) {
if (engine() && engine()->find(tmp))
tmp->attach(0);
Debug(this,DebugAll,"Detached L3 (%p,'%s') [%p]",
tmp,tmp->toString().safe(),this);
}
if (!layer3)
return;
Debug(this,DebugAll,"Attached L3 (%p,'%s') [%p]",layer3,layer3->toString().safe(),this);
insert(layer3);
layer3->attach(this);
}
// Parse a received packet, create a frame from it
ISDNFrame* ISDNLayer2::parsePacket(const DataBlock& packet)
{
if (packet.null())
return 0;
Lock lock(m_layerMutex);
ISDNFrame* frame = ISDNFrame::parse(packet,this);
#ifdef XDEBUG
if (frame) {
if (debugAt(DebugAll)) {
String tmp;
frame->toString(tmp,true);
Debug(this,DebugInfo,"Parsed frame (%p):%s",frame,tmp.c_str());
}
}
else
Debug(this,DebugWarn,"Packet with length %u invalid [%p]",packet.length(),this);
#endif
return frame;
}
// Indication/confirmation of 'multiple frame acknowledged' mode established
void ISDNLayer2::multipleFrameEstablished(u_int8_t tei, bool confirmation, bool timeout)
{
m_layer3Mutex.lock();
RefPointer<ISDNLayer3> tmp = m_layer3;
m_layer3Mutex.unlock();
if (tmp)
tmp->multipleFrameEstablished(tei,confirmation,timeout,this);
else
Debug(this,DebugNote,"'Established' notification. No Layer 3 attached");
}
// Indication/confirmation of 'multiple frame acknowledged' mode released
void ISDNLayer2::multipleFrameReleased(u_int8_t tei, bool confirmation, bool timeout)
{
m_layer3Mutex.lock();
RefPointer<ISDNLayer3> tmp = m_layer3;
m_layer3Mutex.unlock();
if (tmp)
tmp->multipleFrameReleased(tei,confirmation,timeout,this);
else
Debug(this,DebugNote,"'Released' notification. No Layer 3 attached");
}
// Data link state change command/response
void ISDNLayer2::dataLinkState(u_int8_t tei, bool cmd, bool value)
{
m_layer3Mutex.lock();
RefPointer<ISDNLayer3> tmp = m_layer3;
m_layer3Mutex.unlock();
if (tmp)
tmp->dataLinkState(tei,cmd,value,this);
else
Debug(this,DebugNote,"Data link notification. No Layer 3 attached");
}
// Notify layer 3 of data link idle timeout
void ISDNLayer2::idleTimeout()
{
m_layer3Mutex.lock();
RefPointer<ISDNLayer3> tmp = m_layer3;
m_layer3Mutex.unlock();
if (tmp)
tmp->idleTimeout(this);
else
Debug(this,DebugNote,"Data link idle timeout. No Layer 3 attached");
}
// Indication of received data
void ISDNLayer2::receiveData(const DataBlock& data, u_int8_t tei)
{
m_layer3Mutex.lock();
RefPointer<ISDNLayer3> tmp = m_layer3;
m_layer3Mutex.unlock();
if (tmp)
tmp->receiveData(data,tei,this);
else
Debug(this,DebugNote,"Data received. No Layer 3 attached");
}
// Change TEI ASSIGNED state
void ISDNLayer2::teiAssigned(bool status)
{
Lock lock(m_layerMutex);
if (m_teiAssigned == status)
return;
m_teiAssigned = status;
DDebug(this,DebugAll,"%s 'TEI assigned' state",
m_teiAssigned ? "Enter" : "Exit from");
if (!m_teiAssigned)
cleanup();
}
// Change the data link status while in TEI ASSIGNED state
void ISDNLayer2::changeState(State newState, const char* reason)
{
Lock lock(m_layerMutex);
if (m_state == newState)
return;
if (Established != newState)
m_lastUp = 0;
else if (!m_lastUp)
m_lastUp = Time::secNow();
if (!m_teiAssigned && (newState != Released))
return;
DDebug(this,DebugInfo,"Changing state from '%s' to '%s'%s%s%s",
stateName(m_state),stateName(newState),
(reason ? " (" : ""),c_safe(reason),(reason ? ")" : ""));
m_state = newState;
}
// Change the interface type
bool ISDNLayer2::changeType()
{
Lock lock(m_layerMutex);
Debug(this,DebugNote,"Interface type changed from '%s' to '%s'",
linkSide(m_network),linkSide(!m_network));
m_network = !m_network;
return true;
}
/**
* ISDNFrame
*/
// Flags used to set/get frame type
#define Q921FRAME_U 0x03 // U frame
#define Q921FRAME_S 0x01 // S frame
// U frame: P/F bit
#define Q921FRAME_U_GET_PF 0x10 // Mask to get bit 4: the P/F bit
#define Q921FRAME_U_RESET_PF 0xef // Mask to reset bit 4: the P/F bit
// Masks used to set/get command/response bits
#define Q921FRAME_CR_RR 0x01 // S frame
#define Q921FRAME_CR_UI 0x03 // U frame
#define Q921FRAME_CR_RNR 0x05 // S frame
#define Q921FRAME_CR_REJ 0x09 // S frame
#define Q921FRAME_CR_DM 0x0f // U frame
#define Q921FRAME_CR_DISC 0x43 // U frame
#define Q921FRAME_CR_FRMR 0x87 // U frame
#define Q921FRAME_CR_UA 0x63 // U frame
#define Q921FRAME_CR_SABME 0x6f // U frame
#define Q921FRAME_CR_XID 0xaf // U frame
// Set the address field of a frame header
// buf Destination buffer
// cr Command/response type
// network True if the sender is the network side of the data link
// sapi SAPI value
// tei TEI value
static inline void setAddress(u_int8_t* buf, bool cr, bool network,
u_int8_t sapi, u_int8_t tei)
{
// Bit 0 is always 0. Set SAPI and C/R bit (bit 1)
cr = cr ? ISDNFrame::commandBit(network) : ISDNFrame::responseBit(network);
buf[0] = sapi << 2;
if (cr)
buf[0] |= 0x02;
// Bit 1 is always 1. Set TEI
buf[1] = (tei << 1) | 0x01;
}
// Set the control field of an U frame header
// buf Destination buffer
// cr Command/response value: P/F bit (bit 4) is 0
// pf P/F bit
static inline void setControlU(u_int8_t* buf, u_int8_t cr, bool pf)
{
if (pf)
buf[2] = cr | Q921FRAME_U_GET_PF;
else
buf[2] = cr;
}
// Set the control field of an S or I frame header
// buf Destination buffer
// cr_ns S frame: Command/response value (P/F bit (bit 4) is 0)
// I frame: N(S) value
// nr N(R) value to set
// pf P/F bit
static inline void setControl(u_int8_t* buf, u_int8_t cr_ns, u_int8_t nr, bool pf)
{
buf[2] = cr_ns;
buf[3] = nr << 1;
if (pf)
buf[3] |= 0x01;
}
const TokenDict ISDNFrame::s_types[] = {
{"DISC", DISC},
{"DM", DM},
{"FRMR", FRMR},
{"I", I},
{"REJ", REJ},
{"RNR", RNR},
{"RR", RR},
{"SABME", SABME},
{"UA", UA},
{"UI", UI},
{"XID", XID},
{"Invalid frame", Invalid},
{"Unknown command/response", ErrUnknownCR},
{"Invalid header length", ErrHdrLength},
{"Information field too long", ErrDataLength},
{"Invalid N(R) (transmiter receive) sequence number", ErrRxSeqNo},
{"Invalid N(S) (transmiter send) sequence number", ErrTxSeqNo},
{"Invalid 'extended address' bit(s)", ErrInvalidEA},
{"Invalid SAPI/TEI", ErrInvalidAddress},
{"Unsupported command/response", ErrUnsupported},
{"Invalid command/response flag", ErrInvalidCR},
{0,0}
};
// NOTE:
// In constructors, the values of SAPI, TEI, N(S), N(R) are not checked to be in their interval:
// this is done by the parser (when receiveing) and by ISDNLayer2 when assigning these values
// Constructs an undefined frame. Used by the parser
ISDNFrame::ISDNFrame(Type type)
: m_type(type),
m_error(type),
m_category(Error),
m_command(false),
m_sapi(0),
m_tei(0),
m_poll(false),
m_ns(0xFF),
m_nr(0xFF),
m_headerLength(0),
m_dataLength(0),
m_sent(false)
{
}
// Create U/S frames: SABME/DM/DISC/UA/FRMR/XID/RR/RNR/REJ
ISDNFrame::ISDNFrame(Type type, bool command, bool senderNetwork,
u_int8_t sapi, u_int8_t tei, bool pf, u_int8_t nr)
: m_type(type),
m_error(type),
m_category(Error),
m_command(command),
m_senderNetwork(senderNetwork),
m_sapi(sapi),
m_tei(tei),
m_poll(pf),
m_ns(0xFF),
m_nr(nr),
m_headerLength(3),
m_dataLength(0),
m_sent(false)
{
u_int8_t buf[4];
setAddress(buf,m_command,m_senderNetwork,m_sapi,m_tei);
u_int8_t cr = 0;
#define Q921_CASE_SET_CRMASK(compare,rvalue,hdrLen,category) \
case compare: cr = rvalue; m_headerLength = hdrLen; m_category = category; break;
switch (m_type) {
Q921_CASE_SET_CRMASK(SABME,Q921FRAME_CR_SABME,3,Unnumbered)
Q921_CASE_SET_CRMASK(DM,Q921FRAME_CR_DM,3,Unnumbered)
Q921_CASE_SET_CRMASK(DISC,Q921FRAME_CR_DISC,3,Unnumbered)
Q921_CASE_SET_CRMASK(UA,Q921FRAME_CR_UA,3,Unnumbered)
Q921_CASE_SET_CRMASK(FRMR,Q921FRAME_CR_FRMR,3,Unnumbered)
Q921_CASE_SET_CRMASK(RR,Q921FRAME_CR_RR,4,Supervisory)
Q921_CASE_SET_CRMASK(RNR,Q921FRAME_CR_RNR,4,Supervisory)
Q921_CASE_SET_CRMASK(REJ,Q921FRAME_CR_REJ,4,Supervisory)
Q921_CASE_SET_CRMASK(XID,Q921FRAME_CR_XID,3,Unnumbered)
default:
return;
}
#undef Q921_CASE_SET_CRMASK
// Set control field
if (m_headerLength == 3)
setControlU(buf,cr,m_poll);
else
setControl(buf,cr,m_nr,m_poll);
// Set frame buffer
m_buffer.assign(buf,m_headerLength);
}
// Create I/UI frames
ISDNFrame::ISDNFrame(bool ack, bool senderNetwork, u_int8_t sapi, u_int8_t tei,
bool pf, const DataBlock& data)
: m_type(I),
m_error(I),
m_category(Data),
m_command(true),
m_senderNetwork(senderNetwork),
m_sapi(sapi),
m_tei(tei),
m_poll(pf),
m_ns(0),
m_nr(0),
m_headerLength(4),
m_dataLength(data.length()),
m_sent(false)
{
if (!ack) {
m_type = m_error = UI;
m_headerLength = 3;
m_ns = m_nr = 0xff;
}
u_int8_t buf[4];
setAddress(buf,m_command,m_senderNetwork,m_sapi,m_tei);
if (m_type == I)
setControl(buf,m_ns << 1,m_nr << 1,m_poll);
else
setControlU(buf,Q921FRAME_CR_UI,m_poll);
m_buffer.assign(buf,m_headerLength);
m_buffer += data;
}
ISDNFrame::~ISDNFrame()
{
}
// Update transmitter send and transmitter receive values for I (data) frames
void ISDNFrame::update(u_int8_t* ns, u_int8_t* nr)
{
#define NS (((u_int8_t*)(m_buffer.data()))[2])
#define NR (((u_int8_t*)(m_buffer.data()))[3])
if (m_type != I)
return;
if (ns) {
m_ns = *ns;
// For I frames bit 0 of N(S) is always 0
NS = m_ns << 1;
}
if (nr) {
m_nr = *nr;
// Keep the P/F bit (bit 0)
NR = (m_nr << 1) | (NR & 0x01);
}
#undef NR
#undef NS
}
// Put the frame in a string for debug purposes
void ISDNFrame::toString(String& dest, bool extendedDebug) const
{
#define STARTLINE(indent) "\r\n" << indent
const char* enclose = "\r\n-----";
const char* ind = " ";
dest << enclose;
dest << STARTLINE("") << name();
// Dump header
if (extendedDebug) {
String tmp;
tmp.hexify((void*)buffer().data(),headerLength(),' ');
dest << " - Header dump: " << tmp;
}
if (m_error >= Invalid)
dest << STARTLINE(ind) << "Error: " << typeName(m_error);
// Address
dest << STARTLINE(ind) << "SAPI=" << (unsigned int)m_sapi;
dest << " TEI=" << (unsigned int)m_tei;
dest << " Type=" << (m_command ? "Command" : "Response");
// Control
dest << " Poll/Final=" << (m_poll ? '1' : '0');
dest << " Sequence numbers: ";
switch (m_type) {
case I:
dest << "Send=" << (unsigned int)m_ns;
dest << " Recv=" << (unsigned int)m_nr;
break;
case RR:
case RNR:
case REJ:
dest << "Send=N/A Recv=" << (unsigned int)m_nr;
break;
default: ;
dest << "Send=N/A Recv=N/A";
}
// Data
dest << STARTLINE(ind) << "Retransmission=" << String::boolText(m_sent);
dest << " Length: Header=" << (unsigned int)m_headerLength;
dest << " Data=" << (unsigned int)m_dataLength;
// Dump data
if (extendedDebug && m_dataLength) {
String tmp;
tmp.hexify((char*)buffer().data() + headerLength(),m_dataLength,' ');
dest << STARTLINE(ind) << "Data dump: " << tmp;
}
dest << enclose;
#undef STARTLINE
}
// Parse received buffer. Set frame data. Header description:
// Address: 2 bytes
// Control: 1 or 2 bytes
// Data: Variable
//
// Address field: 2 bytes (1 and 2)
// Check EA bits: bit 0 of byte 0 must be 0; bit 0 of byte 1 must be 1
// C/R (command/response) bit: bit 1 of byte 0
// SAPI: Bits 2-7 of byte 0
// TEI: Bits 1-7 of byte 1
// Control field: 1 byte (byte 2) for U frames and 2 bytes (bytes 2 and 3) for I/S frames
// Frame type: Bits 0,1 of of byte 2
// P/F (Poll/Final) bit: I/S frame: bit 0 of byte 3. U frame: bit 4 of the byte 2
// Command/response code: I frame: none. S frame: byte 2. U frame: byte 2 with P/F bit reset
ISDNFrame* ISDNFrame::parse(const DataBlock& data, ISDNLayer2* receiver)
{
// We MUST have 2 bytes for address and at least 1 byte for control field
if (!receiver || data.length() < 3)
return 0;
ISDNFrame* frame = new ISDNFrame(Invalid);
const u_int8_t* buf = (const u_int8_t*)(data.data());
// *** Address field: 2 bytes
// Check EA bits
if ((buf[0] & 0x01) || !(buf[1] & 0x01)) {
frame->m_buffer = data;
frame->m_headerLength = frame->m_buffer.length();
frame->m_error = ErrInvalidEA;
return frame;
}
// Get C/R bit, SAPI, TEI
// C/R: (Q.921 Table 1):
// network --> user Command: 1 Response: 0
// user --> network Command: 0 Response: 1
// The sender of this frame is the other side of the receiver
frame->m_senderNetwork = !receiver->network();
frame->m_command = isCommand(buf[0] & 0x02,frame->m_senderNetwork);
frame->m_sapi = buf[0] >> 2;
frame->m_tei = buf[1] >> 1;
// *** Control field: 1 (U frame) or 2 (I/S frame) bytes
// Get frame type: I/U/S. I/S frame type control field is 2 bytes long
u_int8_t type = buf[2] & 0x03;
if (type != Q921FRAME_U && data.length() < 4) {
frame->m_buffer = data;
frame->m_headerLength = 3;
frame->m_error = ErrHdrLength;
return frame;
}
// Adjust frame header length. Get P/F bit
// Get counters. Set frame type
#define Q921_CASE_SETTYPE(compare,rvalue,category)\
case compare: frame->m_type = frame->m_error = rvalue; frame->m_category = category; break;
switch (type) {
case Q921FRAME_U:
frame->m_headerLength = 3;
frame->m_poll = (buf[2] & Q921FRAME_U_GET_PF) ? true : false;
switch (buf[2] & Q921FRAME_U_RESET_PF) {
Q921_CASE_SETTYPE(Q921FRAME_CR_UA,UA,Unnumbered)
Q921_CASE_SETTYPE(Q921FRAME_CR_DM,DM,Unnumbered)
Q921_CASE_SETTYPE(Q921FRAME_CR_DISC,DISC,Unnumbered)
Q921_CASE_SETTYPE(Q921FRAME_CR_SABME,SABME,Unnumbered)
Q921_CASE_SETTYPE(Q921FRAME_CR_UI,UI,Data)
Q921_CASE_SETTYPE(Q921FRAME_CR_FRMR,FRMR,Unnumbered)
Q921_CASE_SETTYPE(Q921FRAME_CR_XID,XID,Unnumbered)
default:
frame->m_type = Invalid;
frame->m_error = ErrUnknownCR;
}
break;
case Q921FRAME_S:
frame->m_headerLength = 4;
frame->m_poll = (buf[3] & 0x01) ? true : false;
frame->m_nr = buf[3] >> 1;
switch (buf[2]) {
Q921_CASE_SETTYPE(Q921FRAME_CR_RR,RR,Supervisory)
Q921_CASE_SETTYPE(Q921FRAME_CR_RNR,RNR,Supervisory)
Q921_CASE_SETTYPE(Q921FRAME_CR_REJ,REJ,Supervisory)
default:
frame->m_type = Invalid;
frame->m_error = ErrUnknownCR;
}
break;
default: // I frame
frame->m_type = frame->m_error = I;
frame->m_category = Data;
frame->m_headerLength = 4;
frame->m_poll = (buf[3] & 0x01) ? true : false;
frame->m_ns = buf[2] >> 1;
frame->m_nr = buf[3] >> 1;
}
#undef Q921_CASE_SETTYPE
// Copy buffer. Set data length
frame->m_buffer = data;
frame->m_dataLength = data.length() - frame->m_headerLength;
return frame;
}
// Get the Reference number from a frame data block
u_int16_t ISDNFrame::getRi(const DataBlock& data)
{
int i = data.at(2);
if (i < 0)
return 0;
return (u_int16_t)((data.at(1) << 8) | i);
}
// Build a TEI management message buffer
bool ISDNFrame::buildTeiManagement(DataBlock& data, u_int8_t type, u_int16_t ri, u_int8_t ai)
{
u_int8_t d[5] = { Q921_MANAGEMENT_TEI, (u_int8_t)(ri >> 8), (u_int8_t)ri,
type, (u_int8_t)((ai << 1) | 1) };
data.assign(d,5);
return true;
}
// Check if a message buffer holds a TEI management frame
bool ISDNFrame::checkTeiManagement() const
{
const u_int8_t* d = m_buffer.data(m_headerLength);
return (d && (type() == UI) && (m_dataLength >= 5) && (d[0] == Q921_MANAGEMENT_TEI));
}
/* vi: set ts=8 sw=4 sts=4 noet: */
Reference in New Issue View Git Blame Copy Permalink