binary_raw_size.cpp

Go to the documentation of this file.

#include <opc/ua/protocol/binary/stream.h>
#include <opc/ua/protocol/secure_channel.h>
#include <opc/ua/protocol/types.h>

#include <algorithm>
#include <stdexcept>

namespace OpcUa
{
namespace Binary
{
template<>
std::size_t RawSize<bool>(const bool &)
{
  return 1;
}

template<>
std::size_t RawSize<uint8_t>(const uint8_t &)
{
  return 1;
}

template<>
std::size_t RawSize<int8_t>(const int8_t &)
{
  return 1;
}

template<>
std::size_t RawSize<uint16_t>(const uint16_t &)
{
  return 2;
}

template<>
std::size_t RawSize<int16_t>(const int16_t &)
{
  return 2;
}

template<>
std::size_t RawSize<uint32_t>(const uint32_t &)
{
  return 4;
}

template<>
std::size_t RawSize<int32_t>(const int32_t &)
{
  return 4;
}


template<>
std::size_t RawSize<uint64_t>(const uint64_t &)
{
  return 8;
}

template<>
std::size_t RawSize<int64_t>(const int64_t &)
{
  return 8;
}

template<>
std::size_t RawSize<float>(const float &)
{
  return 4;
}

template<>
std::size_t RawSize<double>(const double &)
{
  return 8;
}

template<>
std::size_t RawSize<Guid>(const Guid &)
{
  return 16;
}

template<>
std::size_t RawSize<StatusCode>(const StatusCode &)
{
  return 4;
}

template<>
std::size_t RawSize<std::string>(const std::string & str)
{
  const std::size_t headerSize = 4;
  return headerSize + str.size();
}

template<>
std::size_t RawSize<ByteString>(const ByteString & str)
{
  const std::size_t headerSize = 4;
  return headerSize + str.Data.size();
}

template<>
std::size_t RawSize<DateTime>(const DateTime & date)
{
  return RawSize(date.Value);
}

template<>
std::size_t RawSize<std::vector<uint8_t>>(const std::vector<uint8_t> & vec)
{
  const std::size_t headerSize = 4;
  return headerSize + vec.size();
}

template<>
std::size_t RawSize<std::vector<std::vector<uint8_t>>>(const std::vector<std::vector<uint8_t>> & vec)
{
  const std::size_t headerSize = 4;
  std::size_t totalSize = headerSize;
  std::for_each(vec.begin(), vec.end(), [&](const std::vector<uint8_t> & v) {totalSize += RawSize(v);});
  return totalSize;
}


template<>
std::size_t RawSize<std::vector<std::string>>(const std::vector<std::string> & vec)
{
  const std::size_t headerSize = 4;
  std::size_t totalSize = headerSize;
  std::for_each(vec.begin(), vec.end(), [&](const std::string & str) {totalSize += RawSize(str);});
  return totalSize;
}


template<>
std::size_t RawSize<Header>(const Header &)
{
  const std::size_t sizeofType = 3;  // 'H', 'E', 'L'
  const std::size_t sizeofChunk = 1; // 'F'
  const std::size_t sizeofSize = 4;
  return sizeofType + sizeofChunk + sizeofSize;
}

template<>
std::size_t RawSize<SecureHeader>(const SecureHeader &)
{
  const std::size_t sizeofType = 3;  // 'H', 'E', 'L'
  const std::size_t sizeofChunk = 1; // 'F'
  const std::size_t sizeofSize = 4;
  const std::size_t sizeofChannelId = 4;
  return sizeofType + sizeofChunk + sizeofSize + sizeofChannelId;
}

template<>
std::size_t RawSize<Hello>(const Hello & hello)
{
  const std::size_t sizeOfProtocolVersion = 4;
  const std::size_t sizeOfReceiveBufferSize = 4;
  const std::size_t sizeOfSendBufferSize = 4;
  const std::size_t sizeOfMaxMessageSize = 4;
  const std::size_t sizeOfMaxChunkCount = 4;

  return sizeOfProtocolVersion +
         sizeOfReceiveBufferSize +
         sizeOfSendBufferSize +
         sizeOfMaxMessageSize +
         sizeOfMaxChunkCount +
         RawSize(hello.EndpointUrl);
}

template<>
std::size_t RawSize<Acknowledge>(const Acknowledge &)
{
  const std::size_t sizeofProtocolVersion = 4;
  const std::size_t sizeofReceiveBufferSize = 4;
  const std::size_t sizeofSendBufferSize = 4;
  const std::size_t sizeofMaxMessageSize = 4;
  const std::size_t sizeofMaxChunkCount = 4;

  return sizeofProtocolVersion + sizeofReceiveBufferSize + sizeofSendBufferSize + sizeofMaxMessageSize + sizeofMaxChunkCount;
}

template<>
std::size_t RawSize<Error>(const Error & err)
{
  const std::size_t sizeofCode = 4;
  return sizeofCode + RawSize(err.Reason);
}

template<>
std::size_t RawSize<AsymmetricAlgorithmHeader>(const AsymmetricAlgorithmHeader & ack)
{
  const std::size_t sizeofUri = RawSize(ack.SecurityPolicyUri);
  const std::size_t sizeofCertificate = RawSize(ack.SenderCertificate);
  const std::size_t sizeofThumbprint = RawSize(ack.ReceiverCertificateThumbPrint);
  return sizeofUri + sizeofCertificate +  sizeofThumbprint;
}

template<>
std::size_t RawSize<SequenceHeader>(const SequenceHeader &)
{
  const std::size_t sizeofSequenceNumber = 4;
  const std::size_t sizeofRequestId = 4;

  return sizeofSequenceNumber + sizeofRequestId;
}

template<>
std::size_t RawSize<AdditionalHeader>(const AdditionalHeader & header)
{
  const std::size_t sizeofTypeId = RawSize(header.TypeId);
  const std::size_t sizeofEncoding = 1;
  return sizeofTypeId + sizeofEncoding;
}

template<>
std::size_t RawSize<RequestHeader>(const RequestHeader & header)
{
  const std::size_t sizeofSessionAuthenticationToken = RawSize(header.SessionAuthenticationToken);
  const std::size_t sizeofUtcTime = 8;
  const std::size_t sizeofRequestHandle = 4;
  const std::size_t sizeofReturnDiagnostics = 4;
  const std::size_t sizeofAuditEntryId = 4 + header.AuditEntryId.size();
  const std::size_t sizeofTimeout = 4;
  const std::size_t sizeofAdditional = RawSize(header.Additional);

  return sizeofSessionAuthenticationToken + sizeofUtcTime + sizeofRequestHandle + sizeofReturnDiagnostics + sizeofAuditEntryId + sizeofTimeout + sizeofAdditional;
}

template<>
std::size_t RawSize<OpenSecureChannelRequest>(const OpenSecureChannelRequest & request)
{
  const std::size_t sizeofTypeId = RawSize(request.TypeId);
  const std::size_t sizeofHeader = RawSize(request.Header);
  const std::size_t sizeofClientProtocolVersion = 4;
  const std::size_t sizeofRequestType = 4;
  const std::size_t sizeofSecurityMode = 4;
  const std::size_t sizeofClientNonce = 4 + request.Parameters.ClientNonce.size();
  const std::size_t sizeofRequestLifeTime = 4;

  return sizeofTypeId + sizeofHeader + sizeofClientProtocolVersion + sizeofRequestType + sizeofSecurityMode + sizeofClientNonce + sizeofRequestLifeTime;
}

template<>
std::size_t RawSize<SymmetricAlgorithmHeader>(const SymmetricAlgorithmHeader & header)
{
  const std::size_t sizeofTokenId = 4;
  return sizeofTokenId;
}

template<>
std::size_t RawSize<DiagnosticInfo>(const DiagnosticInfo & info)
{
  const std::size_t sizeofEncodingMask = 1;
  size_t size = sizeofEncodingMask;

  if (info.EncodingMask & DIM_SYMBOLIC_Id)
    {
      const std::size_t sizeofSymbolicId = 4;
      size += sizeofSymbolicId;
    }

  if (info.EncodingMask & DIM_NAMESPACE)
    {
      const std::size_t sizeofNamespace = 4;
      size += sizeofNamespace;
    }

  if (info.EncodingMask & DIM_LOCALIZED_TEXT)
    {
      const std::size_t sizeofLocalizedText = 4;
      size += sizeofLocalizedText;
    }

  if (info.EncodingMask & DIM_LOCALE)
    {
      const std::size_t sizeofLocale = 4;
      size += sizeofLocale;
    }

  if (info.EncodingMask & DIM_ADDITIONAL_INFO)
    {
      const std::size_t sizeofAdditionalInfo = 4 + info.AdditionalInfo.size();
      size += sizeofAdditionalInfo;
    }

  if (info.EncodingMask & DIM_INNER_STATUS_CODE)
    {
      const std::size_t sizeofInnerStatusCode = 4;
      size += sizeofInnerStatusCode;
    }

  if ((info.EncodingMask & DIM_INNER_DIAGNOSTIC_INFO) && info.InnerDiagnostics)
    {
      size += RawSize(*info.InnerDiagnostics);
    }

  return size;
}

template<>
std::size_t RawSize<DiagnosticInfoList>(const DiagnosticInfoList & infos)
{
  return RawSizeContainer(infos);
}

template<>
std::size_t RawSize<ResponseHeader>(const ResponseHeader & header)
{
  const std::size_t sizeofTimestamp = 8;
  const std::size_t sizeofRequestHandle = 4;
  const std::size_t sizeofServiceResult = 4;

  std::size_t sizeofDiagnostics = RawSize(header.InnerDiagnostics);
  std::size_t sizeofStringTable = 4;
  std::for_each(header.StringTable.begin(), header.StringTable.end(), [&](const std::string & str) {sizeofStringTable += RawSize(str);});

  const std::size_t sizeofAdditional = RawSize(header.Additional);
  return sizeofTimestamp + sizeofRequestHandle + sizeofServiceResult + sizeofDiagnostics + sizeofStringTable + sizeofAdditional;
}

template<>
std::size_t RawSize<SecurityToken>(const SecurityToken &)
{
  const std::size_t sizeofSecureChannelId = 4;
  const std::size_t sizeofTokenId = 4;
  const std::size_t sizeofCreatedAt = 8;
  const std::size_t sizeofRevisedLifetime = 4;

  return sizeofSecureChannelId + sizeofTokenId + sizeofCreatedAt + sizeofRevisedLifetime;
}

template<>
std::size_t RawSize<OpenSecureChannelResponse>(const OpenSecureChannelResponse & response)
{
  const std::size_t sizeofTypeId = RawSize(response.TypeId);
  const std::size_t sizeofHeader = RawSize(response.Header);
  const std::size_t sizeofServerProtocolVersion = 4;
  const std::size_t sizeofChannelSecurityToken = RawSize(response.ChannelSecurityToken);
  const std::size_t sizeofServerNonce = 4 + response.ServerNonce.size();

  return sizeofTypeId + sizeofHeader + sizeofServerProtocolVersion + sizeofChannelSecurityToken + sizeofServerNonce;
}

template<>
std::size_t RawSize<CloseSecureChannelRequest>(const CloseSecureChannelRequest & request)
{
  const std::size_t sizeofTypeId = RawSize(request.TypeId);
  const std::size_t sizeofHeader = RawSize(request.Header);
  return sizeofTypeId + sizeofHeader;
}


template<>
std::size_t RawSize<LocalizedText>(const LocalizedText & text)
{
  std::size_t size = RawSize(text.Encoding);

  if (text.Encoding & HAS_LOCALE)
    {
      size += RawSize(text.Locale);
    }

  if (text.Encoding & HAS_TEXT)
    {
      size += RawSize(text.Text);
    }

  return size;
}

//     template<>
//     std::size_t RawSize<SignatureData>(const SignatureData& s)
//     {
//       return RawSize(s.Signature) + RawSize(s.Algorithm);
//     }

template<>
std::size_t RawSize<ExtensionObjectHeader>(const ExtensionObjectHeader & header)
{
  const std::size_t sizeofEncoding = 1;
  return RawSize(header.TypeId) + sizeofEncoding;
}

template<>
std::size_t RawSize<QualifiedName>(const QualifiedName & name)
{
  return RawSize(name.NamespaceIndex) + RawSize(name.Name);
}

template<>
std::size_t RawSize<IntegerId>(const IntegerId &)
{
  return 4;
}

}
}