482 lines
11 KiB
C++
482 lines
11 KiB
C++
/** @file Call Control messags, GSM 04.08 9.3. */
|
|
|
|
/*
|
|
* Copyright 2008, 2009 Free Software Foundation, Inc.
|
|
*
|
|
* This software is distributed under the terms of the GNU Affero Public License.
|
|
* See the COPYING file in the main directory for details.
|
|
*
|
|
* This use of this software may be subject to additional restrictions.
|
|
* See the LEGAL file in the main directory for details.
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
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. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <iostream>
|
|
#include "GSML3CCMessages.h"
|
|
#include <Logger.h>
|
|
|
|
|
|
|
|
using namespace std;
|
|
using namespace GSM;
|
|
|
|
|
|
|
|
ostream& GSM::operator<<(ostream& os, L3CCMessage::MessageType val)
|
|
{
|
|
switch (val) {
|
|
case L3CCMessage::Alerting:
|
|
os << "Alerting"; break;
|
|
case L3CCMessage::Connect:
|
|
os << "Connect"; break;
|
|
case L3CCMessage::Disconnect:
|
|
os << "Disconnect"; break;
|
|
case L3CCMessage::ConnectAcknowledge:
|
|
os << "Connect Acknowledge"; break;
|
|
case L3CCMessage::Release:
|
|
os << "Release"; break;
|
|
case L3CCMessage::ReleaseComplete:
|
|
os << "Release Complete"; break;
|
|
case L3CCMessage::Setup:
|
|
os << "Setup"; break;
|
|
case L3CCMessage::EmergencySetup:
|
|
os << "Emergency Setup"; break;
|
|
case L3CCMessage::CCStatus:
|
|
os <<"CC Status"; break;
|
|
case L3CCMessage::CallConfirmed:
|
|
os <<"Call Confirmed"; break;
|
|
case L3CCMessage::CallProceeding:
|
|
os <<"Call Proceeding"; break;
|
|
case L3CCMessage::StartDTMF:
|
|
os << "Start DTMF"; break;
|
|
case L3CCMessage::StartDTMFReject:
|
|
os << "Start DTMF Reject"; break;
|
|
case L3CCMessage::StartDTMFAcknowledge:
|
|
os << "Start DTMF Acknowledge"; break;
|
|
case L3CCMessage::StopDTMF:
|
|
os << "Stop DTMF"; break;
|
|
case L3CCMessage::StopDTMFAcknowledge:
|
|
os << "Stop DTMF Acknowledge"; break;
|
|
case L3CCMessage::Hold:
|
|
os << "Hold"; break;
|
|
case L3CCMessage::HoldReject:
|
|
os << "Hold Reject"; break;
|
|
default: os << hex << "0x" << (int)val << dec;
|
|
}
|
|
return os;
|
|
}
|
|
|
|
|
|
|
|
L3CCMessage * GSM::L3CCFactory(L3CCMessage::MessageType MTI)
|
|
{
|
|
switch (MTI) {
|
|
case L3CCMessage::Connect: return new L3Connect();
|
|
case L3CCMessage::Alerting: return new L3Alerting();
|
|
case L3CCMessage::Setup: return new L3Setup();
|
|
case L3CCMessage::EmergencySetup: return new L3EmergencySetup();
|
|
case L3CCMessage::Disconnect: return new L3Disconnect();
|
|
case L3CCMessage::CallProceeding: return new L3CallProceeding();
|
|
case L3CCMessage::Release: return new L3Release();
|
|
case L3CCMessage::ReleaseComplete: return new L3ReleaseComplete();
|
|
case L3CCMessage::ConnectAcknowledge: return new L3ConnectAcknowledge();
|
|
case L3CCMessage::CCStatus: return new L3CCStatus();
|
|
case L3CCMessage::CallConfirmed: return new L3CallConfirmed();
|
|
case L3CCMessage::StartDTMF: return new L3StartDTMF();
|
|
case L3CCMessage::StartDTMFReject: return new L3StartDTMFReject();
|
|
case L3CCMessage::StopDTMF: return new L3StopDTMF();
|
|
case L3CCMessage::Hold: return new L3Hold();
|
|
case L3CCMessage::HoldReject: return new L3HoldReject();
|
|
default: {
|
|
LOG(NOTICE) << "no L3 CC factory support for message "<< MTI;
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/* parser for Call control messages, will only parse uplink */
|
|
L3CCMessage * GSM::parseL3CC(const L3Frame& source)
|
|
{
|
|
// mask out bit #7 (1011 1111) so use 0xbf, see GSM 04.08 Table 10.3/3.
|
|
L3CCMessage::MessageType MTI = (L3CCMessage::MessageType)(0xbf & source.MTI());
|
|
LOG(DEBUG) << "parseL3CC MTI="<<MTI;
|
|
|
|
L3CCMessage *retVal = L3CCFactory(MTI);
|
|
if (retVal==NULL) return NULL;
|
|
|
|
retVal->TIValue(source.TIValue());
|
|
retVal->parse(source);
|
|
LOG(DEBUG) << "parseL3CC " << *retVal;
|
|
return retVal;
|
|
}
|
|
|
|
|
|
void L3CCMessage::write(L3Frame& dest) const
|
|
{
|
|
// We override L3Message::write for the transaction identifier.
|
|
size_t l3len = bitsNeeded();
|
|
if (dest.size()!=l3len) dest.resize(l3len);
|
|
size_t wp = 0;
|
|
dest.writeField(wp,mTIFlag,1);
|
|
dest.writeField(wp,mTIValue,3);
|
|
dest.writeField(wp,PD(),4);
|
|
dest.writeField(wp,MTI(),8);
|
|
|
|
writeBody(dest,wp);
|
|
}
|
|
|
|
|
|
|
|
|
|
void L3CCMessage::text(ostream& os) const
|
|
{
|
|
os << "CC " << (MessageType) MTI();
|
|
os << " TI=(" << mTIFlag << "," << mTIValue << ") ";;
|
|
}
|
|
|
|
|
|
size_t L3Alerting::bodyLength() const
|
|
{
|
|
size_t sum=0;
|
|
if (mHaveProgress) sum += mProgress.lengthTLV();
|
|
return sum;
|
|
}
|
|
|
|
void L3Alerting::writeBody(L3Frame &dest, size_t &wp) const
|
|
{
|
|
if (mHaveProgress) mProgress.writeTLV(0x1E,dest,wp);
|
|
}
|
|
|
|
void L3Alerting::parseBody(const L3Frame& src, size_t &rp)
|
|
{
|
|
skipTLV(0x1C,src,rp); // skip facility
|
|
mHaveProgress = mProgress.parseTLV(0x1E,src,rp);
|
|
// ignore the rest
|
|
}
|
|
|
|
void L3Alerting::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
if (mHaveProgress) os << "progress=(" << mProgress << ")";
|
|
}
|
|
|
|
|
|
size_t L3CallProceeding::bodyLength() const
|
|
{
|
|
size_t sum=0;
|
|
if (mHaveProgress) sum += mProgress.lengthTLV();
|
|
if( mHaveBearerCapability) sum += mBearerCapability.lengthTLV();
|
|
return sum;
|
|
}
|
|
|
|
|
|
void L3CallProceeding::writeBody(L3Frame &dest, size_t &wp) const
|
|
{
|
|
if( mHaveBearerCapability) mBearerCapability.writeTLV(0x04, dest, wp);
|
|
if (mHaveProgress) mProgress.writeTLV(0x1E, dest, wp);
|
|
|
|
}
|
|
|
|
void L3CallProceeding::parseBody(const L3Frame& src, size_t &rp)
|
|
{
|
|
skipTV(0x0D,4,src,rp); // skip repeat indicator
|
|
skipTLV(0x04,src,rp); // skip bearer capability 1
|
|
skipTLV(0x04,src,rp); // skip bearer capability 2
|
|
skipTLV(0x1C,src,rp); // skip facility
|
|
mHaveProgress = mProgress.parseTLV(0x1E,src,rp);
|
|
}
|
|
|
|
void L3CallProceeding::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
if (mHaveProgress) os << "progress=(" << mProgress << ")";
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
size_t L3Connect::bodyLength() const
|
|
{
|
|
size_t len=0;
|
|
if (mHaveProgress) len += mProgress.lengthTLV();
|
|
return len;
|
|
}
|
|
|
|
void L3Connect::writeBody(L3Frame &dest, size_t &wp) const
|
|
{
|
|
if (mHaveProgress) mProgress.writeTLV(0x1E,dest,wp);
|
|
}
|
|
|
|
void L3Connect::parseBody(const L3Frame& src, size_t &rp)
|
|
{
|
|
skipTLV(0x1c,src,rp); // facility
|
|
mHaveProgress = mProgress.parseTLV(0x1e,src,rp);
|
|
// ignore the rest
|
|
}
|
|
|
|
|
|
void L3Connect::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
if (mHaveProgress) os << "progress=(" << mProgress << ")";
|
|
}
|
|
|
|
|
|
|
|
|
|
size_t L3Release::bodyLength() const
|
|
{
|
|
size_t sum = 0;
|
|
if (mHaveCause) sum += mCause.lengthTLV();
|
|
return sum;
|
|
}
|
|
|
|
|
|
void L3Release::writeBody(L3Frame& dest, size_t &wp) const
|
|
{
|
|
if (mHaveCause) mCause.writeTLV(0x08,dest,wp);
|
|
}
|
|
|
|
|
|
void L3Release::parseBody(const L3Frame& src, size_t &rp)
|
|
{
|
|
mHaveCause = mCause.parseTLV(0x08,src,rp);
|
|
// ignore the rest
|
|
}
|
|
|
|
|
|
void L3Release::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
if (mHaveCause) os << "cause=(" << mCause << ")";
|
|
}
|
|
|
|
|
|
|
|
size_t L3ReleaseComplete::bodyLength() const
|
|
{
|
|
size_t sum = 0;
|
|
if (mHaveCause) sum += mCause.lengthTLV();
|
|
return sum;
|
|
}
|
|
|
|
|
|
void L3ReleaseComplete::writeBody(L3Frame& dest, size_t &wp) const
|
|
{
|
|
if (mHaveCause) mCause.writeTLV(0x08,dest,wp);
|
|
}
|
|
|
|
|
|
void L3ReleaseComplete::parseBody(const L3Frame& src, size_t &rp)
|
|
{
|
|
mHaveCause = mCause.parseTLV(0x08,src,rp);
|
|
// ignore the rest
|
|
}
|
|
|
|
|
|
void L3ReleaseComplete::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
if (mHaveCause) os << "cause=(" << mCause << ")";
|
|
}
|
|
|
|
|
|
|
|
|
|
void L3Setup::writeBody( L3Frame &dest, size_t &wp ) const
|
|
{
|
|
if (mHaveBearerCapability) mBearerCapability.writeTLV(0x04, dest, wp);
|
|
if (mHaveCallingPartyBCDNumber) mCallingPartyBCDNumber.writeTLV(0x5C,dest, wp);
|
|
if (mHaveCalledPartyBCDNumber) mCalledPartyBCDNumber.writeTLV(0x5E,dest, wp);
|
|
}
|
|
|
|
|
|
|
|
|
|
void L3Setup::parseBody( const L3Frame &src, size_t &rp )
|
|
{
|
|
skipTV(0x0D,4,src,rp); // skip Repeat Indicator.
|
|
skipTLV(0x04,src,rp); // skip Bearer Capability 1.
|
|
skipTLV(0x04,src,rp); // skip Bearer Capability 2.
|
|
skipTLV(0x1C,src,rp); // skip Facility.
|
|
skipTLV(0x1E,src,rp); // skip Progress.
|
|
skipTLV(0x34,src,rp); // skip Signal.
|
|
mHaveCallingPartyBCDNumber = mCallingPartyBCDNumber.parseTLV(0x5C,src,rp);
|
|
skipTLV(0x5D,src,rp); // skip Calling Party Subaddress
|
|
mHaveCalledPartyBCDNumber = mCalledPartyBCDNumber.parseTLV(0x5E,src,rp);
|
|
// ignore the rest
|
|
}
|
|
|
|
size_t L3Setup::bodyLength() const
|
|
{
|
|
int len = 0;
|
|
if(mHaveBearerCapability) len += mBearerCapability.lengthTLV();
|
|
if(mHaveCalledPartyBCDNumber) len += mCalledPartyBCDNumber.lengthTLV();
|
|
if(mHaveCallingPartyBCDNumber) len += mCallingPartyBCDNumber.lengthTLV();
|
|
return len;
|
|
}
|
|
|
|
|
|
void L3Setup::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
if(mHaveCallingPartyBCDNumber)
|
|
os <<"CallingPartyBCDNumber=("<<mCallingPartyBCDNumber<<")";
|
|
if(mHaveCalledPartyBCDNumber)
|
|
os <<"CalledPartyBCDNumber=("<<mCalledPartyBCDNumber<<")";
|
|
}
|
|
|
|
|
|
void L3CCStatus::parseBody( const L3Frame &src, size_t &rp )
|
|
{
|
|
mCause.parseLV(src, rp);
|
|
mCallState.parseV(src, rp);
|
|
}
|
|
|
|
void L3CCStatus::writeBody(L3Frame &dest, size_t &wp ) const
|
|
{
|
|
mCause.writeLV(dest, wp);
|
|
mCallState.writeV(dest, wp);
|
|
}
|
|
|
|
void L3CCStatus::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
os << "cause=(" << mCause << ")";
|
|
os << " callState=" << mCallState;
|
|
}
|
|
|
|
|
|
|
|
void L3Disconnect::writeBody(L3Frame& dest, size_t &wp) const
|
|
{
|
|
mCause.writeLV(dest,wp);
|
|
}
|
|
|
|
|
|
void L3Disconnect::parseBody(const L3Frame& src, size_t &rp)
|
|
{
|
|
mCause.parseLV(src,rp);
|
|
}
|
|
|
|
|
|
void L3Disconnect::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
os << "cause=(" << mCause << ")";
|
|
}
|
|
|
|
|
|
|
|
|
|
void L3CallConfirmed::parseBody(const L3Frame& src, size_t &rp)
|
|
{
|
|
skipTV(0x0D,4,src,rp); // skip repeat indicator
|
|
skipTLV(0x04,src,rp); // skip bearer capability 1
|
|
skipTLV(0x04,src,rp); // skip bearer capability 2
|
|
mHaveCause = mCause.parseTLV(0x08,src,rp);
|
|
// ignore call control capabilities
|
|
}
|
|
|
|
|
|
size_t L3CallConfirmed::bodyLength() const
|
|
{
|
|
size_t sum=0;
|
|
if (mHaveCause) sum += mCause.lengthTLV();
|
|
return sum;
|
|
}
|
|
|
|
|
|
void L3CallConfirmed::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
if (mHaveCause) os << "cause=(" << mCause << ")";
|
|
}
|
|
|
|
|
|
|
|
void L3StartDTMF::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
os << "key=" << mKey;
|
|
}
|
|
|
|
|
|
|
|
void L3StartDTMFAcknowledge::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
os << "key=" << mKey;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void L3StartDTMFReject::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
os << "cause=(" << mCause << ")";
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
size_t L3Progress::bodyLength() const
|
|
{
|
|
return mProgress.lengthLV();
|
|
}
|
|
|
|
void L3Progress::writeBody(L3Frame &dest, size_t &wp) const
|
|
{
|
|
mProgress.writeLV(dest,wp);
|
|
}
|
|
|
|
void L3Progress::parseBody(const L3Frame& src, size_t &rp)
|
|
{
|
|
mProgress.parseLV(src,rp);
|
|
// ignore the rest
|
|
}
|
|
|
|
void L3Progress::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
os << "prog_ind=(" << mProgress << ")";
|
|
}
|
|
|
|
|
|
|
|
void L3HoldReject::text(ostream& os) const
|
|
{
|
|
L3CCMessage::text(os);
|
|
os << "cause=(" << mCause << ")";
|
|
}
|
|
|
|
|
|
|
|
|
|
// vim: ts=4 sw=4
|