341 lines
6.8 KiB
C++
341 lines
6.8 KiB
C++
/*
|
|
pdu.cpp
|
|
|
|
Copyright (c) 2020 Kevin Matz (kevin.matz@gmail.com)
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
*/
|
|
|
|
#include "pdu.h"
|
|
|
|
#include <cmath>
|
|
|
|
namespace ACN {
|
|
namespace PDU {
|
|
|
|
/**
|
|
* @brief Pdu::Pdu
|
|
* @param vector_size
|
|
*/
|
|
Pdu::Pdu(size_t vector_size)
|
|
: vector_size_(vector_size)
|
|
{
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::vector
|
|
* @return
|
|
*/
|
|
uint32_t Pdu::vector()
|
|
{
|
|
if (flags_.hasVector)
|
|
return vector_;
|
|
if (inherit_)
|
|
return inherit_->vector();
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::header
|
|
* @return
|
|
*/
|
|
std::shared_ptr<pdu_header> Pdu::header()
|
|
{
|
|
if (flags_.hasHeader)
|
|
return header_;
|
|
if (inherit_)
|
|
return inherit_->header();
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::data
|
|
* @return
|
|
*/
|
|
std::shared_ptr<pdu_data> Pdu::data()
|
|
{
|
|
if (flags_.hasData)
|
|
return data_;
|
|
if (inherit_)
|
|
return inherit_->data();
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::parent
|
|
* @return
|
|
*/
|
|
Message<Pdu> Pdu::parent()
|
|
{
|
|
return parent_;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::stream
|
|
* @return
|
|
*/
|
|
Stream Pdu::stream()
|
|
{
|
|
return stream_;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::streamSize
|
|
* @return
|
|
*
|
|
* The maximum buffer size that could be required to buffer this PDU
|
|
*/
|
|
size_t Pdu::streamSize() const
|
|
{
|
|
size_t s = 2; // flength is at least 2 octets
|
|
|
|
// plus the length of the vector
|
|
if (flags_.hasVector) {
|
|
if (inherit_) {
|
|
if (vector_ != inherit_->vector())
|
|
s += vector_size_;
|
|
} else {
|
|
s += vector_size_;
|
|
}
|
|
}
|
|
|
|
// plus the length of the header
|
|
if (header_) {
|
|
if (inherit_) {
|
|
if (header_ != inherit_->header())
|
|
s += header_->streamSize();
|
|
} else {
|
|
s += header_->streamSize();
|
|
}
|
|
}
|
|
|
|
// plus the lenth of the data
|
|
if (data_) {
|
|
if (inherit_) {
|
|
if (data_ != inherit_->data())
|
|
s += data_->streamSize();
|
|
} else {
|
|
s += data_->streamSize();
|
|
}
|
|
}
|
|
|
|
// and another bit if the length needs it
|
|
if (s > 0x0fff)
|
|
s++;
|
|
return s;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::iStream
|
|
* @param stream
|
|
*/
|
|
void Pdu::iStream(Stream stream)
|
|
{
|
|
// get the flags
|
|
flags_.set(stream->peek());
|
|
|
|
// get the length
|
|
size_t length;
|
|
length = stream->readType<uint16_t>() & 0x0fff; // high 4 bits are flags
|
|
if (flags_.hasLength)
|
|
length = (length << 8 ) | stream->readType<uint8_t>();
|
|
|
|
// get the vector
|
|
if (flags_.hasVector)
|
|
switch (vector_size_) {
|
|
case 1:
|
|
vector_ = stream->readType<uint8_t>();
|
|
break;
|
|
case 2:
|
|
vector_ = stream->readType<uint16_t>();
|
|
break;
|
|
case 4:
|
|
vector_ = stream->readType<uint32_t>();
|
|
break;
|
|
default:
|
|
stream->setstate(std::ios_base::failbit);
|
|
return;
|
|
}
|
|
|
|
// length includes the flags, length, and vector.
|
|
// the remainder of the length of header and data
|
|
unsigned int hd_length = length - (flags_.hasLength ? 3 : 2) - vector_size_;
|
|
|
|
// abort if the remaining PDU length isn't available
|
|
if (!stream->good() || stream->available() < hd_length)
|
|
return stream->setstate(std::ios_base::failbit);
|
|
|
|
// create a stream buffer for the header and data
|
|
stream_ = Stream(new pdu_stream(stream->data(), hd_length));
|
|
if (stream_->available() != hd_length)
|
|
return stream->setstate(std::ios_base::failbit);
|
|
|
|
// fast-forward the input stream
|
|
stream->ignore(hd_length);
|
|
|
|
if (!stream->available())
|
|
return stream->setstate(std::ios_base::eofbit);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::oStream
|
|
* @param stream
|
|
*/
|
|
void Pdu::oStream(Stream stream) const
|
|
{
|
|
pdu_flags flags = flags_;
|
|
size_t length = streamSize();
|
|
|
|
// check if length flag need to be set
|
|
if (length > 0x0fff)
|
|
flags.hasLength = true;
|
|
|
|
// see if we can inherit members
|
|
if (inherit_) {
|
|
if (flags.hasVector)
|
|
if (vector_ == inherit_->vector())
|
|
flags.hasVector = false;
|
|
if (flags.hasHeader)
|
|
if (header_ == inherit_->header())
|
|
flags.hasHeader = false;
|
|
if (flags.hasData)
|
|
if (data_ == inherit_->data())
|
|
flags.hasData = false;
|
|
}
|
|
|
|
// inject flags onto the high 4 bits of the length
|
|
if (flags.hasLength)
|
|
{
|
|
uint8_t flength[3];
|
|
flength[0] = ((length >> 16) & 0x0f) | (uint8_t)flags;
|
|
flength[1] = length >> 8;
|
|
flength[2] = length;
|
|
stream->write(flength, sizeof(flength));
|
|
}
|
|
else
|
|
{
|
|
uint8_t flength[2];
|
|
flength[0] = ((length >> 8) & 0x0f) | (uint8_t)flags;
|
|
flength[1] = length;
|
|
stream->write(flength, sizeof(flength));
|
|
}
|
|
|
|
// write the vector to stream
|
|
if (flags.hasVector)
|
|
switch (vector_size_) {
|
|
case 1:
|
|
stream->writeType<uint8_t>(vector_);
|
|
break;
|
|
case 2:
|
|
stream->writeType<uint16_t>(vector_);
|
|
break;
|
|
case 4:
|
|
stream->writeType<uint32_t>(vector_);
|
|
break;
|
|
default:
|
|
stream->setstate(std::ios_base::failbit);
|
|
return;
|
|
}
|
|
|
|
// write the header to stream
|
|
if (flags.hasHeader)
|
|
header_->oStream(stream);
|
|
|
|
// write the data to steam
|
|
if (flags.hasData)
|
|
data_->oStream(stream);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::setVector
|
|
* @param v
|
|
*/
|
|
void Pdu::setVector (const uint32_t v)
|
|
{
|
|
vector_ = v; flags_.hasVector = true;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::setHeader
|
|
* @param h
|
|
*/
|
|
void Pdu::setHeader (std::shared_ptr<pdu_header> h)
|
|
{
|
|
header_ = h;
|
|
flags_.hasHeader = true;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::setData
|
|
* @param d
|
|
*/
|
|
void Pdu::setData (std::shared_ptr<pdu_data> d)
|
|
{
|
|
data_ = d;
|
|
flags_.hasData = true;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::setParent
|
|
* @param pdu
|
|
*/
|
|
void Pdu::setParent (Message<Pdu> pdu)
|
|
{
|
|
parent_ = pdu;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Pdu::setInherit
|
|
* @param pdu
|
|
*/
|
|
void Pdu::setInherit(Message<Pdu> pdu)
|
|
{
|
|
inherit_ = pdu;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief pdu_flags::set
|
|
* @param val
|
|
*/
|
|
void pdu_flags::set(const uint8_t val)
|
|
{
|
|
hasLength = (val >> 7) & 0b1;
|
|
hasVector = (val >> 6) & 0b1;
|
|
hasHeader = (val >> 5) & 0b1;
|
|
hasData = (val >> 4) & 0b1;
|
|
};
|
|
|
|
} // PDU
|
|
} // ACN
|