You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@nifi.apache.org by al...@apache.org on 2017/11/14 01:48:25 UTC
[11/25] nifi-minifi-cpp git commit: MINIFICPP-250: Initial
implementation fo CapturePacket Processor that uses lipcap.
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/c0a788b3/thirdparty/pcap++/Packet++/src/SSLLayer.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/pcap++/Packet++/src/SSLLayer.cpp b/thirdparty/pcap++/Packet++/src/SSLLayer.cpp
new file mode 100644
index 0000000..0f5b31f
--- /dev/null
+++ b/thirdparty/pcap++/Packet++/src/SSLLayer.cpp
@@ -0,0 +1,314 @@
+#define LOG_MODULE PacketLogModuleSSLLayer
+
+#include <Logger.h>
+#include <SSLLayer.h>
+#if defined(WIN32) || defined(WINx64) //for using ntohl, ntohs, etc.
+#include <winsock2.h>
+#elif LINUX
+#include <in.h> //for using ntohl, ntohs, etc.
+#elif MAC_OS_X
+#include <arpa/inet.h> //for using ntohl, ntohs, etc.
+#endif
+#include <sstream>
+#include <map>
+
+
+namespace pcpp
+{
+
+static std::map<uint16_t, bool> createSSLPortMap()
+{
+ std::map<uint16_t, bool> result;
+
+ result[0] = true; //default
+ result[443] = true; //HTTPS
+ result[465] = true; //SMTPS
+ result[636] = true; //LDAPS
+ result[989] = true; //FTPS - data
+ result[990] = true; //FTPS - control
+ result[992] = true; //Telnet over TLS/SSL
+ result[993] = true; //IMAPS
+ result[995] = true; //POP3S
+
+ return result;
+}
+
+static const std::map<uint16_t, bool> SSLPortMap = createSSLPortMap();
+
+
+// ----------------
+// SSLLayer methods
+// ----------------
+
+bool SSLLayer::IsSSLMessage(uint16_t srcPort, uint16_t dstPort, uint8_t* data, size_t dataLen)
+{
+ // check the port map first
+ if (SSLPortMap.find(srcPort) == SSLPortMap.end() && SSLPortMap.find(dstPort) == SSLPortMap.end())
+ return false;
+
+ if (dataLen < sizeof(ssl_tls_record_layer))
+ return false;
+
+ ssl_tls_record_layer* recordLayer = (ssl_tls_record_layer*)data;
+
+ // there is no SSL message with length 0
+ if (recordLayer->length == 0)
+ return false;
+
+ if (recordLayer->recordType < 20 || recordLayer->recordType > 23)
+ return false;
+
+ uint16_t recordVersion = ntohs(recordLayer->recordVersion);
+
+ if (recordVersion != SSL3 &&
+ recordVersion != TLS1_0 &&
+ recordVersion != TLS1_1 &&
+ recordVersion != TLS1_2)
+ return false;
+
+ return true;
+}
+
+SSLLayer* SSLLayer::createSSLMessage(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
+{
+ ssl_tls_record_layer* recordLayer = (ssl_tls_record_layer*)data;
+ switch (recordLayer->recordType)
+ {
+ case SSL_HANDSHAKE:
+ {
+ return new SSLHandshakeLayer(data, dataLen, prevLayer, packet);
+ }
+
+ case SSL_ALERT:
+ {
+ return new SSLAlertLayer(data, dataLen, prevLayer, packet);
+ }
+
+ case SSL_CHANGE_CIPHER_SPEC:
+ {
+ return new SSLChangeCipherSpecLayer(data, dataLen, prevLayer, packet);
+ }
+
+ case SSL_APPLICATION_DATA:
+ {
+ return new SSLApplicationDataLayer(data, dataLen, prevLayer, packet);
+ }
+
+ default:
+ return NULL;
+ }
+}
+
+std::string SSLLayer::sslVersionToString(SSLVersion ver)
+{
+ switch (ver)
+ {
+ case SSL2:
+ return "SSLv2";
+ case SSL3:
+ return "SSLv3";
+ case TLS1_0:
+ return "TLSv1.0";
+ case TLS1_1:
+ return "TLSv1.1";
+ case TLS1_2:
+ return "TLSv1.2";
+ default:
+ return "SSL/TLS unknown";
+ }
+}
+
+const std::map<uint16_t, bool>* SSLLayer::getSSLPortMap()
+{
+ return &SSLPortMap;
+}
+
+SSLVersion SSLLayer::getRecordVersion()
+{
+ uint16_t recordVersion = ntohs(getRecordLayer()->recordVersion);
+ return (SSLVersion)recordVersion;
+}
+
+SSLRecordType SSLLayer::getRecordType()
+{
+ return (SSLRecordType)(getRecordLayer()->recordType);
+}
+
+size_t SSLLayer::getHeaderLen()
+{
+ size_t len = sizeof(ssl_tls_record_layer) + ntohs(getRecordLayer()->length);
+ if (len > m_DataLen)
+ return m_DataLen;
+ return len;
+}
+
+void SSLLayer::parseNextLayer()
+{
+ size_t headerLen = getHeaderLen();
+ if (m_DataLen <= headerLen)
+ return;
+
+ if (SSLLayer::IsSSLMessage(0, 0, m_Data + headerLen, m_DataLen - headerLen))
+ m_NextLayer = SSLLayer::createSSLMessage(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
+}
+
+
+// -------------------------
+// SSLHandshakeLayer methods
+// -------------------------
+
+std::string SSLHandshakeLayer::toString()
+{
+ std::stringstream result;
+ result << sslVersionToString(getRecordVersion()) << " Layer, Handshake:";
+ for(size_t i = 0; i < m_MessageList.size(); i++)
+ {
+ if (i == 0)
+ result << " " << m_MessageList.at(i)->toString();
+ else
+ result << ", " << m_MessageList.at(i)->toString();
+ }
+ return result.str();
+}
+
+SSLHandshakeLayer::SSLHandshakeLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
+ : SSLLayer(data, dataLen, prevLayer, packet)
+{
+ uint8_t* curPos = m_Data + sizeof(ssl_tls_record_layer);
+ size_t recordDataLen = ntohs(getRecordLayer()->length);
+ if (recordDataLen > m_DataLen - sizeof(ssl_tls_record_layer))
+ recordDataLen = m_DataLen - sizeof(ssl_tls_record_layer);
+
+ size_t curPosIndex = 0;
+ while (true)
+ {
+ SSLHandshakeMessage* message = SSLHandshakeMessage::createHandhakeMessage(curPos, recordDataLen-curPosIndex, this);
+ if (message == NULL)
+ break;
+
+ m_MessageList.pushBack(message);
+ curPos += message->getMessageLength();
+ curPosIndex += message->getMessageLength();
+ }
+}
+
+size_t SSLHandshakeLayer::getHandshakeMessagesCount()
+{
+ return m_MessageList.size();
+}
+
+SSLHandshakeMessage* SSLHandshakeLayer::getHandshakeMessageAt(int index)
+{
+ if (index < 0 || index >= (int)(m_MessageList.size()))
+ return NULL;
+
+ return m_MessageList.at(index);
+}
+
+
+// --------------------------------
+// SSLChangeCipherSpecLayer methods
+// --------------------------------
+
+std::string SSLChangeCipherSpecLayer::toString()
+{
+ std::stringstream result;
+ result << sslVersionToString(getRecordVersion()) << " Layer, Change Cipher Spec";
+ return result.str();
+}
+
+// ---------------------
+// SSLAlertLayer methods
+// ---------------------
+
+SSLAlertLevel SSLAlertLayer::getAlertLevel()
+{
+ uint8_t* pos = m_Data + sizeof(ssl_tls_record_layer);
+ uint8_t alertLevel = *pos;
+ if (alertLevel == SSL_ALERT_LEVEL_WARNING || alertLevel == SSL_ALERT_LEVEL_FATAL)
+ return (SSLAlertLevel)alertLevel;
+ else
+ return SSL_ALERT_LEVEL_ENCRYPTED;
+
+}
+
+SSLAlertDescription SSLAlertLayer::getAlertDescription()
+{
+ if (getAlertLevel() == SSL_ALERT_LEVEL_ENCRYPTED)
+ return SSL_ALERT_ENCRYPRED;
+
+ uint8_t* pos = m_Data + sizeof(ssl_tls_record_layer) + sizeof(uint8_t);
+ uint8_t alertDesc = *pos;
+
+ switch (alertDesc)
+ {
+ case SSL_ALERT_CLOSE_NOTIFY:
+ case SSL_ALERT_UNEXPECTED_MESSAGE:
+ case SSL_ALERT_BAD_RECORD_MAC:
+ case SSL_ALERT_DECRYPTION_FAILED:
+ case SSL_ALERT_RECORD_OVERFLOW:
+ case SSL_ALERT_DECOMPRESSION_FAILURE:
+ case SSL_ALERT_HANDSHAKE_FAILURE:
+ case SSL_ALERT_NO_CERTIFICATE:
+ case SSL_ALERT_BAD_CERTIFICATE:
+ case SSL_ALERT_UNSUPPORTED_CERTIFICATE:
+ case SSL_ALERT_CERTIFICATE_REVOKED:
+ case SSL_ALERT_CERTIFICATE_EXPIRED:
+ case SSL_ALERT_CERTIFICATE_UNKNOWN:
+ case SSL_ALERT_ILLEGAL_PARAMETER:
+ case SSL_ALERT_UNKNOWN_CA:
+ case SSL_ALERT_ACCESS_DENIED:
+ case SSL_ALERT_DECODE_ERROR:
+ case SSL_ALERT_DECRYPT_ERROR:
+ case SSL_ALERT_EXPORT_RESTRICTION:
+ case SSL_ALERT_PROTOCOL_VERSION:
+ case SSL_ALERT_INSUFFICIENT_SECURITY:
+ case SSL_ALERT_INTERNAL_ERROR:
+ case SSL_ALERT_USER_CANCELLED:
+ case SSL_ALERT_NO_RENEGOTIATION:
+ return (SSLAlertDescription)alertDesc;
+ break;
+ default:
+ return SSL_ALERT_ENCRYPRED;
+ }
+}
+
+std::string SSLAlertLayer::toString()
+{
+ std::stringstream result;
+ result << sslVersionToString(getRecordVersion()) << " Layer, ";
+ if (getAlertLevel() == SSL_ALERT_LEVEL_ENCRYPTED)
+ result << "Encrypted Alert";
+ else
+ //TODO: add alert level and description here
+ result << "Alert";
+ return result.str();
+}
+
+// -------------------------------
+// SSLApplicationDataLayer methods
+// -------------------------------
+
+uint8_t* SSLApplicationDataLayer::getEncrpytedData()
+{
+ if (getHeaderLen() <= sizeof(ssl_tls_record_layer))
+ return NULL;
+
+ return m_Data + sizeof(ssl_tls_record_layer);
+}
+
+size_t SSLApplicationDataLayer::getEncrpytedDataLen()
+{
+ int result = (int)getHeaderLen() - (int)sizeof(ssl_tls_record_layer);
+ if (result < 0)
+ return 0;
+
+ return (size_t)result;
+}
+
+std::string SSLApplicationDataLayer::toString()
+{
+ return sslVersionToString(getRecordVersion()) + " Layer, Application Data";
+}
+
+} // namespace pcpp
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/c0a788b3/thirdparty/pcap++/Packet++/src/SdpLayer.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/pcap++/Packet++/src/SdpLayer.cpp b/thirdparty/pcap++/Packet++/src/SdpLayer.cpp
new file mode 100644
index 0000000..9184640
--- /dev/null
+++ b/thirdparty/pcap++/Packet++/src/SdpLayer.cpp
@@ -0,0 +1,136 @@
+#define LOG_MODULE PacketLogModuleSdpLayer
+
+
+#include "SdpLayer.h"
+#include "Logger.h"
+#include <stdlib.h>
+#include <string>
+#include <sstream>
+
+namespace pcpp
+{
+
+std::vector<std::string> splitByWhiteSpaces(std::string str)
+{
+ std::string buf;
+ std::stringstream stream(str);
+ std::vector<std::string> result;
+ while (stream >> buf)
+ result.push_back(buf);
+
+ return result;
+}
+
+
+SdpLayer::SdpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) : TextBasedProtocolMessage(data, dataLen, prevLayer, packet)
+{
+ m_Protocol = SDP;
+ m_FieldsOffset = 0;
+ parseFields();
+}
+
+SdpLayer::SdpLayer()
+{
+ m_Protocol = SDP;
+ m_FieldsOffset = 0;
+}
+
+SdpLayer::SdpLayer(std::string username, long sessionID, long sessionVersion, IPv4Address ipAddress, std::string sessionName, long startTime, long stopTime)
+{
+ m_Protocol = SDP;
+ m_FieldsOffset = 0;
+
+ // must initialize m_Data otherwise addField() will fail while trying to extend the layer
+ // initializing in length of 1 but keeping m_DataLen with value of 0.
+ // when extending the field m_Data is purged so there isn't a memory leak here
+ m_Data = new uint8_t[1];
+ m_DataLen = 0;
+
+ addField(PCPP_SDP_PROTOCOL_VERSION_FIELD, "0");
+
+ std::stringstream sessionIDStream;
+ sessionIDStream << sessionID;
+ std::stringstream sessionVersionStream;
+ sessionVersionStream << sessionVersion;
+ std::string networkInfo = "IN IP4 " + ipAddress.toString();
+ std::string originatorFieldValue = username + " " + sessionIDStream.str() + " " + sessionVersionStream.str() + " " + networkInfo;
+ addField(PCPP_SDP_ORIGINATOR_FIELD, originatorFieldValue);
+
+ addField(PCPP_SDP_SESSION_NAME_FIELD, sessionName);
+
+ addField(PCPP_SDP_CONNECTION_INFO_FIELD, networkInfo);
+
+ std::stringstream startTimeStream;
+ startTimeStream << startTime;
+ std::stringstream stopTimeStream;
+ stopTimeStream << stopTime;
+ addField(PCPP_SDP_TIME_FIELD, startTimeStream.str() + " " + stopTimeStream.str());
+}
+
+std::string SdpLayer::toString()
+{
+ return "SDP Layer";
+}
+
+IPv4Address SdpLayer::getOwnerIPv4Address()
+{
+ HeaderField* originator = getFieldByName(PCPP_SDP_ORIGINATOR_FIELD);
+ if (originator == NULL)
+ return IPv4Address::Zero;
+
+ std::vector<std::string> tokens = splitByWhiteSpaces(originator->getFieldValue());
+ if (tokens.size() < 6)
+ return IPv4Address::Zero;
+
+ if (tokens[3] != "IN" || tokens[4] != "IP4")
+ return IPv4Address::Zero;
+
+ return IPv4Address(tokens[5]);
+}
+
+uint16_t SdpLayer::getMediaPort(std::string mediaType)
+{
+ int mediaFieldIndex = 0;
+ HeaderField* mediaDesc = getFieldByName(PCPP_SDP_MEDIA_NAME_FIELD, mediaFieldIndex);
+
+ while (mediaDesc != NULL)
+ {
+ std::vector<std::string> tokens = splitByWhiteSpaces(mediaDesc->getFieldValue());
+
+ if (tokens.size() >= 2 && tokens[0] == mediaType)
+ return atoi(tokens[1].c_str());
+
+ mediaFieldIndex++;
+ mediaDesc = getFieldByName(PCPP_SDP_MEDIA_NAME_FIELD, mediaFieldIndex);
+ }
+
+ return 0;
+}
+
+bool SdpLayer::addMediaDescription(std::string mediaType, uint16_t mediaPort, std::string mediaProtocol, std::string mediaFormat, std::vector<std::string> mediaAttributes)
+{
+ std::stringstream portStream;
+ portStream << mediaPort;
+
+ std::string mediaFieldValue = mediaType + " " + portStream.str() + " " + mediaProtocol + " " + mediaFormat;
+ if (addField(PCPP_SDP_MEDIA_NAME_FIELD, mediaFieldValue) == NULL)
+ {
+ LOG_ERROR("Failed to add media description field");
+ return false;
+ }
+
+
+ for (std::vector<std::string>::iterator iter = mediaAttributes.begin(); iter != mediaAttributes.end(); iter++)
+ {
+ if (addField(PCPP_SDP_MEDIA_ATTRIBUTE_FIELD, *iter) == NULL)
+ {
+ LOG_ERROR("Faild to add media attribute '%s'", iter->c_str());
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
+}
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/c0a788b3/thirdparty/pcap++/Packet++/src/SipLayer.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/pcap++/Packet++/src/SipLayer.cpp b/thirdparty/pcap++/Packet++/src/SipLayer.cpp
new file mode 100644
index 0000000..938f433
--- /dev/null
+++ b/thirdparty/pcap++/Packet++/src/SipLayer.cpp
@@ -0,0 +1,1261 @@
+#define LOG_MODULE PacketLogModuleSipLayer
+
+#include "SipLayer.h"
+#include "SdpLayer.h"
+#include "PayloadLayer.h"
+#include "Logger.h"
+#include <string.h>
+#include <algorithm>
+#include <stdlib.h>
+
+namespace pcpp
+{
+
+const std::string SipMethodEnumToString[14] = {
+ "INVITE",
+ "ACK",
+ "BYE",
+ "CANCEL",
+ "REGISTER",
+ "PRACK",
+ "OPTIONS",
+ "SUBSCRIBE",
+ "NOTIFY",
+ "PUBLISH",
+ "INFO",
+ "REFER",
+ "MESSAGE",
+ "UPDATE"
+};
+
+
+
+
+// -------- Class SipLayer -----------------
+
+int SipLayer::getContentLength()
+{
+ std::string contentLengthFieldName(PCPP_SIP_CONTENT_LENGTH_FIELD);
+ std::transform(contentLengthFieldName.begin(), contentLengthFieldName.end(), contentLengthFieldName.begin(), ::tolower);
+ HeaderField* contentLengthField = getFieldByName(contentLengthFieldName);
+ if (contentLengthField != NULL)
+ return atoi(contentLengthField->getFieldValue().c_str());
+ return 0;
+}
+
+HeaderField* SipLayer::setContentLength(int contentLength, const std::string prevFieldName)
+{
+ char contentLengthAsString[20];
+ snprintf (contentLengthAsString, sizeof(contentLengthAsString), "%d",contentLength);
+ std::string contentLengthFieldName(PCPP_SIP_CONTENT_LENGTH_FIELD);
+ HeaderField* contentLengthField = getFieldByName(contentLengthFieldName);
+ if (contentLengthField == NULL)
+ {
+ HeaderField* prevField = getFieldByName(prevFieldName);
+ contentLengthField = insertField(prevField, PCPP_SIP_CONTENT_LENGTH_FIELD, contentLengthAsString);
+ }
+ else
+ contentLengthField->setFieldValue(std::string(contentLengthAsString));
+
+ return contentLengthField;
+}
+
+void SipLayer::parseNextLayer()
+{
+ if (getLayerPayloadSize() == 0)
+ return;
+
+ size_t headerLen = getHeaderLen();
+ if (getContentLength() > 0)
+ {
+ m_NextLayer = new SdpLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
+ }
+ else
+ {
+ m_NextLayer = new PayloadLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
+ }
+}
+
+void SipLayer::computeCalculateFields()
+{
+ HeaderField* contentLengthField = getFieldByName(PCPP_SIP_CONTENT_LENGTH_FIELD);
+ if (contentLengthField == NULL)
+ return;
+
+ size_t headerLen = getHeaderLen();
+ if (m_DataLen > headerLen)
+ {
+ int currentContentLength = getContentLength();
+ if (currentContentLength != (int)(m_DataLen - headerLen))
+ setContentLength(m_DataLen - headerLen);
+ }
+}
+
+
+
+
+
+
+
+
+// -------- Class SipRequestFirstLine -----------------
+
+SipRequestFirstLine::SipRequestFirstLine(SipRequestLayer* sipRequest) : m_SipRequest(sipRequest)
+{
+ m_Method = parseMethod((char*)m_SipRequest->m_Data, m_SipRequest->getDataLen());
+ if (m_Method == SipRequestLayer::SipMethodUnknown)
+ {
+ m_UriOffset = -1;
+ LOG_DEBUG("Couldn't resolve SIP request method");
+ }
+ else
+ m_UriOffset = SipMethodEnumToString[m_Method].length() + 1;
+
+ parseVersion();
+
+ char* endOfFirstLine;
+ if ((endOfFirstLine = (char *)memchr((char*)(m_SipRequest->m_Data + m_VersionOffset), '\n', m_SipRequest->m_DataLen-(size_t)m_VersionOffset)) != NULL)
+ {
+ m_FirstLineEndOffset = endOfFirstLine - (char*)m_SipRequest->m_Data + 1;
+ m_IsComplete = true;
+ }
+ else
+ {
+ m_FirstLineEndOffset = m_SipRequest->getDataLen();
+ m_IsComplete = false;
+ }
+
+ LOG_DEBUG("Method='%s'; SIP version='%s'; URI='%s'", SipMethodEnumToString[m_Method].c_str(), m_Version.c_str(), getUri().c_str());
+}
+
+SipRequestFirstLine::SipRequestFirstLine(SipRequestLayer* sipRequest, SipRequestLayer::SipMethod method, std::string version, std::string uri)
+ throw(SipRequestFirstLineException)
+{
+ if (method == SipRequestLayer::SipMethodUnknown)
+ {
+ m_Exception.setMessage("Method supplied was SipMethodUnknown");
+ throw m_Exception;
+ }
+
+ if (version == "")
+ {
+ m_Exception.setMessage("Version supplied was empty string");
+ throw m_Exception;
+ }
+
+ m_SipRequest = sipRequest;
+
+ m_Method = method;
+ m_Version = version;
+
+ std::string firstLine = SipMethodEnumToString[m_Method] + " " + uri + " " + version + "\r\n";
+
+ m_UriOffset = SipMethodEnumToString[m_Method].length() + 1;
+ m_FirstLineEndOffset = firstLine.length();
+ m_VersionOffset = m_UriOffset + uri.length() + 6;
+
+ m_SipRequest->m_DataLen = firstLine.length();
+ m_SipRequest->m_Data = new uint8_t[m_SipRequest->m_DataLen];
+ memcpy(m_SipRequest->m_Data, firstLine.c_str(), m_SipRequest->m_DataLen);
+
+ m_IsComplete = true;
+}
+
+
+SipRequestLayer::SipMethod SipRequestFirstLine::parseMethod(char* data, size_t dataLen)
+{
+ if (dataLen < 4)
+ {
+ return SipRequestLayer::SipMethodUnknown;
+ }
+
+ switch (data[0])
+ {
+ case 'A':
+ if (data[1] == 'C' && data[2] == 'K' && data[3] == ' ')
+ return SipRequestLayer::SipACK;
+ else
+ return SipRequestLayer::SipMethodUnknown;
+ break;
+
+ case 'B':
+ if (data[1] == 'Y' && data[2] == 'E' && data[3] == ' ')
+ return SipRequestLayer::SipBYE;
+ else
+ return SipRequestLayer::SipMethodUnknown;
+ break;
+
+ case 'C':
+ if (dataLen < 7)
+ return SipRequestLayer::SipMethodUnknown;
+ else if (data[1] == 'A' && data[2] == 'N' && data[3] == 'C' && data[4] == 'E' && data[5] == 'L' && data[6] == ' ')
+ return SipRequestLayer::SipCANCEL;
+ else
+ return SipRequestLayer::SipMethodUnknown;
+ break;
+
+ case 'O':
+ if (dataLen < 8)
+ return SipRequestLayer::SipMethodUnknown;
+ else if (data[1] == 'P' && data[2] == 'T' && data[3] == 'I' && data[4] == 'O' && data[5] == 'N' && data[6] == 'S' && data[7] == ' ')
+ return SipRequestLayer::SipOPTIONS;
+ else
+ return SipRequestLayer::SipMethodUnknown;
+ break;
+
+
+ case 'R':
+ if (dataLen < 6)
+ return SipRequestLayer::SipMethodUnknown;
+ else if (data[1] == 'E' && data[2] == 'F' && data[3] == 'E' && data[4] == 'R' && data[5] == ' ')
+ return SipRequestLayer::SipREFER;
+ else if (dataLen < 9)
+ return SipRequestLayer::SipMethodUnknown;
+ else if (data[1] == 'E' && data[2] == 'G' && data[3] == 'I' && data[4] == 'S' && data[5] == 'T' && data[6] == 'E' && data[7] == 'R' && data[8] == ' ')
+ return SipRequestLayer::SipREGISTER;
+ else
+ return SipRequestLayer::SipMethodUnknown;
+ break;
+
+ case 'P':
+ if (dataLen < 6)
+ return SipRequestLayer::SipMethodUnknown;
+ else if (data[1] == 'R' && data[2] == 'A' && data[3] == 'C' && data[4] == 'K' && data[5] == ' ')
+ return SipRequestLayer::SipPRACK;
+ else if (dataLen < 8)
+ return SipRequestLayer::SipMethodUnknown;
+ else if (data[1] == 'U' && data[2] == 'B' && data[3] == 'L' && data[4] == 'I' && data[5] == 'S' && data[6] == 'H' && data[7] == ' ')
+ return SipRequestLayer::SipPUBLISH;
+ break;
+
+ case 'S':
+ if (dataLen < 10)
+ return SipRequestLayer::SipMethodUnknown;
+
+ else if (data[1] == 'U' && data[2] == 'B' && data[3] == 'S' && data[4] == 'C' && data[5] == 'R' && data[6] == 'I' && data[7] == 'B' && data[8] == 'E' && data[9] == ' ')
+ return SipRequestLayer::SipSUBSCRIBE;
+ break;
+
+ case 'N':
+ if (dataLen < 7)
+ return SipRequestLayer::SipMethodUnknown;
+
+ else if (data[1] == 'O' && data[2] == 'T' && data[3] == 'I' && data[4] == 'F' && data[5] == 'Y' && data[6] == ' ')
+ return SipRequestLayer::SipNOTIFY;
+ break;
+
+ case 'I':
+ if (data[1] == 'N' && data[2] == 'F' && data[3] == 'O')
+ return SipRequestLayer::SipINFO;
+ else if (dataLen < 7)
+ return SipRequestLayer::SipMethodUnknown;
+ else if (data[1] == 'N' && data[2] == 'V' && data[3] == 'I' && data[4] == 'T' && data[5] == 'E' && data[6] == ' ')
+ return SipRequestLayer::SipINVITE;
+ break;
+
+ case 'M':
+ if (dataLen < 8)
+ return SipRequestLayer::SipMethodUnknown;
+
+ else if (data[1] == 'E' && data[2] == 'S' && data[3] == 'S' && data[4] == 'A' && data[5] == 'G' && data[6] == 'E' && data[7] == ' ')
+ return SipRequestLayer::SipMESSAGE;
+ break;
+
+ case 'U':
+ if (dataLen < 7)
+ return SipRequestLayer::SipMethodUnknown;
+
+ else if (data[1] == 'P' && data[2] == 'D' && data[3] == 'A' && data[4] == 'T' && data[5] == 'E' && data[6] == ' ')
+ return SipRequestLayer::SipUPDATE;
+ break;
+
+
+ default:
+ return SipRequestLayer::SipMethodUnknown;
+ }
+
+ return SipRequestLayer::SipMethodUnknown;
+}
+
+void SipRequestFirstLine::parseVersion()
+{
+ char* data = (char*)(m_SipRequest->m_Data + m_UriOffset);
+ char* verPos = strstr(data, " SIP/");
+ if (verPos == NULL)
+ {
+ m_Version = "";
+ m_VersionOffset = -1;
+ return;
+ }
+
+ // verify packet doesn't end before the version, meaning still left place for " SIP/x.y" (7 chars)
+ if ((uint16_t)(verPos + 7 - (char*)m_SipRequest->m_Data) > m_SipRequest->getDataLen())
+ {
+ m_Version = "";
+ m_VersionOffset = -1;
+ return;
+ }
+
+ //skip the space char
+ verPos++;
+
+ int endOfVerPos = 0;
+ while (((verPos+endOfVerPos)[0] != '\r') && ((verPos+endOfVerPos)[0] != '\n'))
+ endOfVerPos++;
+
+ m_Version = std::string(verPos, endOfVerPos);
+
+ m_VersionOffset = verPos - (char*)m_SipRequest->m_Data;
+}
+
+bool SipRequestFirstLine::setMethod(SipRequestLayer::SipMethod newMethod)
+{
+ if (newMethod == SipRequestLayer::SipMethodUnknown)
+ {
+ LOG_ERROR("Requested method is SipMethodUnknown");
+ return false;
+ }
+
+ //extend or shorten layer
+ int lengthDifference = SipMethodEnumToString[newMethod].length() - SipMethodEnumToString[m_Method].length();
+ if (lengthDifference > 0)
+ {
+ if (!m_SipRequest->extendLayer(0, lengthDifference))
+ {
+ LOG_ERROR("Cannot change layer size");
+ return false;
+ }
+ }
+ else if (lengthDifference < 0)
+ {
+ if (!m_SipRequest->shortenLayer(0, 0-lengthDifference))
+ {
+ LOG_ERROR("Cannot change layer size");
+ return false;
+
+ }
+ }
+
+ if (lengthDifference != 0)
+ {
+ m_SipRequest->shiftFieldsOffset(m_SipRequest->getFirstField(), lengthDifference);
+ m_SipRequest->m_FieldsOffset += lengthDifference;
+ }
+
+ memcpy(m_SipRequest->m_Data, SipMethodEnumToString[newMethod].c_str(), SipMethodEnumToString[newMethod].length());
+
+ m_UriOffset += lengthDifference;
+ m_VersionOffset += lengthDifference;
+ m_FirstLineEndOffset += lengthDifference;
+
+ m_Method = newMethod;
+
+ return true;
+}
+
+std::string SipRequestFirstLine::getUri()
+{
+ std::string result;
+ if (m_UriOffset != -1 && m_VersionOffset != -1)
+ result.assign((char*)(m_SipRequest->m_Data + m_UriOffset), m_VersionOffset-1-m_UriOffset);
+
+ //else first line is illegal, return empty string
+
+ return result;
+}
+
+bool SipRequestFirstLine::setUri(std::string newUri)
+{
+ if (newUri == "")
+ {
+ LOG_ERROR("URI cannot be empty");
+ return false;
+ }
+
+ //extend or shorten layer
+ std::string currentUri = getUri();
+ int lengthDifference = newUri.length() - currentUri.length();
+ if (lengthDifference > 0)
+ {
+ if (!m_SipRequest->extendLayer(m_UriOffset, lengthDifference))
+ {
+ LOG_ERROR("Cannot change layer size");
+ return false;
+ }
+ }
+ else if (lengthDifference < 0)
+ {
+ if (!m_SipRequest->shortenLayer(m_UriOffset, 0-lengthDifference))
+ {
+ LOG_ERROR("Cannot change layer size");
+ return false;
+ }
+ }
+
+ if (lengthDifference != 0)
+ {
+ m_SipRequest->shiftFieldsOffset(m_SipRequest->getFirstField(), lengthDifference);
+ m_SipRequest->m_FieldsOffset += lengthDifference;
+ }
+
+ memcpy(m_SipRequest->m_Data + m_UriOffset, newUri.c_str(), newUri.length());
+
+ m_VersionOffset += lengthDifference;
+ m_FirstLineEndOffset += lengthDifference;
+
+ return true;
+}
+
+
+
+
+
+// -------- Class SipRequestLayer -----------------
+
+SipRequestLayer::SipRequestLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) : SipLayer(data, dataLen, prevLayer, packet)
+{
+ m_Protocol = SIPRequest;
+ m_FirstLine = new SipRequestFirstLine(this);
+ m_FieldsOffset = m_FirstLine->getSize();
+ parseFields();
+}
+
+SipRequestLayer::SipRequestLayer(SipMethod method, std::string requestUri, std::string version)
+{
+ m_Protocol = SIPRequest;
+ m_FirstLine = new SipRequestFirstLine(this, method, version, requestUri);
+ m_FieldsOffset = m_FirstLine->getSize();
+}
+
+SipRequestLayer::SipRequestLayer(const SipRequestLayer& other) : SipLayer(other)
+{
+ m_FirstLine = new SipRequestFirstLine(this);
+}
+
+SipRequestLayer& SipRequestLayer::operator=(const SipRequestLayer& other)
+{
+ SipLayer::operator=(other);
+
+ if (m_FirstLine != NULL)
+ delete m_FirstLine;
+
+ m_FirstLine = new SipRequestFirstLine(this);
+
+ return *this;
+}
+
+SipRequestLayer::~SipRequestLayer()
+{
+ delete m_FirstLine;
+}
+
+std::string SipRequestLayer::toString()
+{
+ static const int maxLengthToPrint = 120;
+ std::string result = "SIP request, ";
+ int size = m_FirstLine->getSize() - 2; // the -2 is to remove \r\n at the end of the first line
+ if (size <= maxLengthToPrint)
+ {
+ char* firstLine = new char[size+1];
+ strncpy(firstLine, (char*)m_Data, size);
+ firstLine[size] = 0;
+ result += std::string(firstLine);
+ delete[] firstLine;
+ }
+ else
+ {
+ char firstLine[maxLengthToPrint+1];
+ strncpy(firstLine, (char*)m_Data, maxLengthToPrint-3);
+ firstLine[maxLengthToPrint-3] = '.';
+ firstLine[maxLengthToPrint-2] = '.';
+ firstLine[maxLengthToPrint-1] = '.';
+ firstLine[maxLengthToPrint] = 0;
+ result += std::string(firstLine);
+ }
+
+ return result;
+}
+
+
+
+
+
+
+// -------- Class SipResponseLayer -----------------
+
+
+
+const std::string StatusCodeEnumToString[74] = {
+ "Trying",
+ "Ringing",
+ "Call is Being Forwarded",
+ "Queued",
+ "Session in Progress",
+ "Early Dialog Terminated",
+ "OK",
+ "Accepted",
+ "No Notification",
+ "Multiple Choices",
+ "Moved Permanently",
+ "Moved Temporarily",
+ "Use Proxy",
+ "Alternative Service",
+ "Bad Request",
+ "Unauthorized",
+ "Payment Required",
+ "Forbidden",
+ "Not Found",
+ "Method Not Allowed",
+ "Not Acceptable",
+ "Proxy Authentication Required",
+ "Request Timeout",
+ "Conflict",
+ "Gone",
+ "Length Required",
+ "Conditional Request Failed",
+ "Request Entity Too Large",
+ "Request-URI Too Long",
+ "Unsupported Media Type",
+ "Unsupported URI Scheme",
+ "Unknown Resource-Priority",
+ "Bad Extension",
+ "Extension Required",
+ "Session Interval Too Small",
+ "Interval Too Brief",
+ "Bad Location Information",
+ "Use Identity Header",
+ "Provide Referrer Identity",
+ "Flow Failed",
+ "Anonymity Disallowed",
+ "Bad Identity-Info",
+ "Unsupported Certificate",
+ "Invalid Identity Header",
+ "First Hop Lacks Outbound Support",
+ "Max-Breadth Exceeded",
+ "Bad Info Package",
+ "Consent Needed",
+ "Temporarily Unavailable",
+ "Call_Transaction Does Not Exist",
+ "Loop Detected",
+ "Too Many Hops",
+ "Address Incomplete",
+ "Ambiguous",
+ "Busy Here",
+ "Request Terminated",
+ "Not Acceptable Here",
+ "Bad Event",
+ "Request Pending",
+ "Undecipherable",
+ "Security Agreement Required",
+ "Server Internal Error",
+ "Not Implemented",
+ "Bad Gateway",
+ "Service Unavailable",
+ "Server Timeout",
+ "Version Not Supported",
+ "Message Too Large",
+ "Precondition Failure",
+ "Busy Everywhere",
+ "Decline",
+ "Does Not Exist Anywhere",
+ "Not Acceptable",
+ "Unwanted"
+};
+
+
+const int StatusCodeEnumToInt[74] = {
+ 100,
+ 180,
+ 181,
+ 182,
+ 183,
+ 199,
+ 200,
+ 202,
+ 204,
+ 300,
+ 301,
+ 302,
+ 305,
+ 380,
+ 400,
+ 401,
+ 402,
+ 403,
+ 404,
+ 405,
+ 406,
+ 407,
+ 408,
+ 409,
+ 410,
+ 411,
+ 412,
+ 413,
+ 414,
+ 415,
+ 416,
+ 417,
+ 420,
+ 421,
+ 422,
+ 423,
+ 424,
+ 428,
+ 429,
+ 430,
+ 433,
+ 436,
+ 437,
+ 438,
+ 439,
+ 440,
+ 469,
+ 470,
+ 480,
+ 481,
+ 482,
+ 483,
+ 484,
+ 485,
+ 486,
+ 487,
+ 488,
+ 489,
+ 491,
+ 493,
+ 494,
+ 500,
+ 501,
+ 502,
+ 503,
+ 504,
+ 505,
+ 513,
+ 580,
+ 600,
+ 603,
+ 604,
+ 606,
+ 607
+};
+
+
+
+SipResponseLayer::SipResponseLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) : SipLayer(data, dataLen, prevLayer, packet)
+{
+ m_Protocol = SIPResponse;
+ m_FirstLine = new SipResponseFirstLine(this);
+ m_FieldsOffset = m_FirstLine->getSize();
+ parseFields();
+}
+
+SipResponseLayer::SipResponseLayer(SipResponseLayer::SipResponseStatusCode statusCode, std::string statusCodeString, std::string sipVersion)
+{
+ m_Protocol = SIPResponse;
+ m_FirstLine = new SipResponseFirstLine(this, sipVersion, statusCode, statusCodeString);
+ m_FieldsOffset = m_FirstLine->getSize();
+}
+
+SipResponseLayer::~SipResponseLayer()
+{
+ delete m_FirstLine;
+}
+
+
+SipResponseLayer::SipResponseLayer(const SipResponseLayer& other) : SipLayer(other)
+{
+ m_FirstLine = new SipResponseFirstLine(this);
+}
+
+SipResponseLayer& SipResponseLayer::operator=(const SipResponseLayer& other)
+{
+ SipLayer::operator=(other);
+
+ if (m_FirstLine != NULL)
+ delete m_FirstLine;
+
+ m_FirstLine = new SipResponseFirstLine(this);
+
+ return *this;
+}
+
+std::string SipResponseLayer::toString()
+{
+ static const int maxLengthToPrint = 120;
+ std::string result = "SIP response, ";
+ int size = m_FirstLine->getSize() - 2; // the -2 is to remove \r\n at the end of the first line
+ if (size <= maxLengthToPrint)
+ {
+ char* firstLine = new char[size+1];
+ strncpy(firstLine, (char*)m_Data, size);
+ firstLine[size] = 0;
+ result += std::string(firstLine);
+ delete[] firstLine;
+ }
+ else
+ {
+ char firstLine[maxLengthToPrint+1];
+ strncpy(firstLine, (char*)m_Data, maxLengthToPrint-3);
+ firstLine[maxLengthToPrint-3] = '.';
+ firstLine[maxLengthToPrint-2] = '.';
+ firstLine[maxLengthToPrint-1] = '.';
+ firstLine[maxLengthToPrint] = 0;
+ result += std::string(firstLine);
+ }
+
+ return result;
+}
+
+
+
+
+
+
+
+
+// -------- Class SipResponseFirstLine -----------------
+
+int SipResponseFirstLine::getStatusCodeAsInt()
+{
+ return StatusCodeEnumToInt[m_StatusCode];
+}
+
+std::string SipResponseFirstLine::getStatusCodeString()
+{
+ std::string result;
+ int statusStringOffset = 12;
+ if (m_StatusCode != SipResponseLayer::SipStatusCodeUnknown)
+ {
+ int statusStringEndOffset = m_FirstLineEndOffset - 2;
+ if ((*(m_SipResponse->m_Data + statusStringEndOffset)) != '\r')
+ statusStringEndOffset++;
+ result.assign((char*)(m_SipResponse->m_Data + statusStringOffset), statusStringEndOffset-statusStringOffset);
+ }
+
+ //else first line is illegal, return empty string
+
+ return result;
+}
+
+bool SipResponseFirstLine::setStatusCode(SipResponseLayer::SipResponseStatusCode newStatusCode, std::string statusCodeString)
+{
+ if (newStatusCode == SipResponseLayer::SipStatusCodeUnknown)
+ {
+ LOG_ERROR("Requested status code is SipStatusCodeUnknown");
+ return false;
+ }
+
+ //extend or shorten layer
+
+ size_t statusStringOffset = 12;
+ if (statusCodeString == "")
+ statusCodeString = StatusCodeEnumToString[newStatusCode];
+ int lengthDifference = statusCodeString.length() - getStatusCodeString().length();
+
+ if (lengthDifference > 0)
+ {
+ if (!m_SipResponse->extendLayer(statusStringOffset, lengthDifference))
+ {
+ LOG_ERROR("Cannot change layer size");
+ return false;
+ }
+ }
+ else if (lengthDifference < 0)
+ {
+ if (!m_SipResponse->shortenLayer(statusStringOffset, 0-lengthDifference))
+ {
+ LOG_ERROR("Cannot change layer size");
+ return false;
+
+ }
+ }
+
+ if (lengthDifference != 0)
+ {
+ m_SipResponse->shiftFieldsOffset(m_SipResponse->getFirstField(), lengthDifference);
+ m_SipResponse->m_FieldsOffset += lengthDifference;
+ }
+
+ // copy status string
+ memcpy(m_SipResponse->m_Data+statusStringOffset, statusCodeString.c_str(), statusCodeString.length());
+
+ // change status code
+ char statusCodeAsString[4];
+ // convert code to string
+ snprintf (statusCodeAsString, sizeof(statusCodeAsString), "%d",StatusCodeEnumToInt[newStatusCode]);
+
+ memcpy(m_SipResponse->m_Data+8, statusCodeAsString, 3);
+
+ m_StatusCode = newStatusCode;
+ m_FirstLineEndOffset += lengthDifference;
+
+ return true;
+
+}
+
+void SipResponseFirstLine::setVersion(std::string newVersion)
+{
+ if (newVersion == "")
+ return;
+
+ if (newVersion.length() != m_Version.length())
+ {
+ LOG_ERROR("Expected version length is %d characters in the format of SIP/x.y", (int)m_Version.length());
+ return;
+ }
+
+ char* verPos = (char*)m_SipResponse->m_Data;
+ memcpy(verPos, newVersion.c_str(), newVersion.length());
+ m_Version = newVersion;
+}
+
+SipResponseLayer::SipResponseStatusCode SipResponseFirstLine::validateStatusCode(char* data, size_t dataLen, SipResponseLayer::SipResponseStatusCode potentialCode)
+{
+ if (data[0] != ' ')
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ return potentialCode;
+}
+
+SipResponseLayer::SipResponseStatusCode SipResponseFirstLine::parseStatusCode(char* data, size_t dataLen)
+{
+ // minimum data should be 12B long: "SIP/x.y XXX"
+ if (dataLen < 12)
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ char* statusCodeData = data + 8;
+ size_t statusCodeDataLen = dataLen - 8;
+
+ switch (statusCodeData[0])
+ {
+ case '1':
+ switch (statusCodeData[1])
+ {
+ case '0':
+ if (statusCodeData[2] == '0')
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip100Trying);
+ else
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ break;
+ case '8':
+ switch (statusCodeData[2])
+ {
+ case '0':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip180Ringing);
+ case '1':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip181CallisBeingForwarded);
+ case '2':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip182Queued);
+ case '3':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip183SessioninProgress);
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+ };
+ break;
+
+ case '9':
+ if (statusCodeData[2] == '9')
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip199EarlyDialogTerminated);
+ else
+ return SipResponseLayer::SipStatusCodeUnknown;
+ break;
+
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+ };
+
+ break;
+ case '2':
+ if (statusCodeData[1] == '0')
+ {
+ switch (statusCodeData[2])
+ {
+ case '0':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip200OK);
+ case '2':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip202Accepted);
+ case '4':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip204NoNotification);
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ };
+ }
+ else
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ break;
+
+ case '3':
+ switch (statusCodeData[1])
+ {
+ case '0':
+ switch (statusCodeData[2])
+ {
+ case '0':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip300MultipleChoices);
+ case '1':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip301MovedPermanently);
+ case '2':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip302MovedTemporarily);
+ case '5':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip305UseProxy);
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ };
+
+ break;
+
+ case '8':
+ if (statusCodeData[2] == '0')
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip380AlternativeService);
+ else
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ break;
+
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+ };
+
+ break;
+
+ case '4':
+ switch (statusCodeData[1])
+ {
+ case '0':
+ switch (statusCodeData[2])
+ {
+ case '0':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip400BadRequest);
+ case '1':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip401Unauthorized);
+ case '2':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip402PaymentRequired);
+ case '3':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip403Forbidden);
+ case '4':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip404NotFound);
+ case '5':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip405MethodNotAllowed);
+ case '6':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip406NotAcceptable);
+ case '7':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip407ProxyAuthenticationRequired);
+ case '8':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip408RequestTimeout);
+ case '9':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip409Conflict);
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ };
+
+ break;
+
+ case '1':
+ switch (statusCodeData[2])
+ {
+ case '0':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip410Gone);
+ case '1':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip411LengthRequired);
+ case '2':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip412ConditionalRequestFailed);
+ case '3':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip413RequestEntityTooLarge);
+ case '4':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip414RequestURITooLong);
+ case '5':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip415UnsupportedMediaType);
+ case '6':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip416UnsupportedURIScheme);
+ case '7':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip417UnknownResourcePriority);
+ case '8':
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ };
+
+ break;
+
+ case '2':
+ switch (statusCodeData[2])
+ {
+ case '0':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip420BadExtension);
+ case '1':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip421ExtensionRequired);
+ case '2':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip422SessionIntervalTooSmall);
+ case '3':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip423IntervalTooBrief);
+ case '4':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip424BadLocationInformation);
+ case '8':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip428UseIdentityHeader);
+ case '9':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip429ProvideReferrerIdentity);
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ };
+
+ break;
+
+ case '3':
+ switch (statusCodeData[2])
+ {
+ case '0':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip430FlowFailed);
+ case '3':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip433AnonymityDisallowed);
+ case '6':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip436BadIdentityInfo);
+ case '7':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip437UnsupportedCertificate);
+ case '8':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip438InvalidIdentityHeader);
+ case '9':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip439FirstHopLacksOutboundSupport);
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+ };
+
+ break;
+
+ case '4':
+ if (statusCodeData[2] == '0')
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip440MaxBreadthExceeded);
+ else
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ break;
+
+ case '6':
+ if (statusCodeData[2] == '9')
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip469BadInfoPackage);
+ else
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ break;
+
+ case '8':
+ switch (statusCodeData[2])
+ {
+ case '0':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip480TemporarilyUnavailable);
+ case '1':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip481Call_TransactionDoesNotExist);
+ case '2':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip482LoopDetected);
+ case '3':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip483TooManyHops);
+ case '4':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip484AddressIncomplete);
+ case '5':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip485Ambiguous);
+ case '6':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip486BusyHere);
+ case '7':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip487RequestTerminated);
+ case '8':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip488NotAcceptableHere);
+ case '9':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip489BadEvent);
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+ };
+
+ break;
+
+ case '9':
+ switch (statusCodeData[2])
+ {
+ case '1':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip491RequestPending);
+ case '3':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip493Undecipherable);
+ case '4':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip494SecurityAgreementRequired);
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+ };
+
+ break;
+
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+ };
+
+ break;
+
+ case '5':
+ switch (statusCodeData[1])
+ {
+ case '0':
+ switch (statusCodeData[2])
+ {
+ case '0':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip500ServerInternalError);
+ case '1':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip501NotImplemented);
+ case '2':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip502BadGateway);
+ case '3':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip503ServiceUnavailable);
+ case '4':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip504ServerTimeout);
+ case '5':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip505VersionNotSupported);
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ };
+
+ break;
+
+ case '1':
+ if (statusCodeData[2] == '3')
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip513MessageTooLarge);
+ else
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ break;
+
+ case '8':
+ if (statusCodeData[2] == '0')
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip580PreconditionFailure);
+ else
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ break;
+
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+ };
+
+ break;
+
+ case '6':
+ if (statusCodeData[1] == '0')
+ {
+ switch (statusCodeData[2])
+ {
+ case '0':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip600BusyEverywhere);
+ case '3':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip603Decline);
+ case '4':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip604DoesNotExistAnywhere);
+ case '6':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip606NotAcceptable);
+ case '7':
+ return validateStatusCode(statusCodeData+3, statusCodeDataLen-3, SipResponseLayer::Sip607Unwanted);
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+ };
+ }
+ else
+ return SipResponseLayer::SipStatusCodeUnknown;
+
+ break;
+
+ default:
+ return SipResponseLayer::SipStatusCodeUnknown;
+ };
+
+ return SipResponseLayer::SipStatusCodeUnknown;
+}
+
+SipResponseFirstLine::SipResponseFirstLine(SipResponseLayer* sipResponse) : m_SipResponse(sipResponse)
+{
+ m_Version = parseVersion((char*)m_SipResponse->m_Data, m_SipResponse->getDataLen());
+ if (m_Version == "")
+ {
+ m_StatusCode = SipResponseLayer::SipStatusCodeUnknown;
+ }
+ else
+ {
+ m_StatusCode = parseStatusCode((char*)m_SipResponse->m_Data, m_SipResponse->getDataLen());
+ }
+
+
+ char* endOfFirstLine;
+ if ((endOfFirstLine = (char *)memchr((char*)(m_SipResponse->m_Data), '\n', m_SipResponse->m_DataLen)) != NULL)
+ {
+ m_FirstLineEndOffset = endOfFirstLine - (char*)m_SipResponse->m_Data + 1;
+ m_IsComplete = true;
+ }
+ else
+ {
+ m_FirstLineEndOffset = m_SipResponse->getDataLen();
+ m_IsComplete = false;
+ }
+
+ LOG_DEBUG("Version='%s'; Status code=%d '%s'", m_Version.c_str(), StatusCodeEnumToInt[m_StatusCode], getStatusCodeString().c_str());
+}
+
+
+SipResponseFirstLine::SipResponseFirstLine(SipResponseLayer* sipResponse, std::string version, SipResponseLayer::SipResponseStatusCode statusCode, std::string statusCodeString)
+{
+ if (statusCode == SipResponseLayer::SipStatusCodeUnknown)
+ {
+ m_Exception.setMessage("Status code supplied was SipStatusCodeUnknown");
+ throw m_Exception;
+ }
+
+ if (version == "")
+ {
+ m_Exception.setMessage("Version supplied was unknown");
+ throw m_Exception;
+ }
+
+ m_SipResponse = sipResponse;
+
+ m_StatusCode = statusCode;
+ m_Version = version;
+
+ char statusCodeAsString[4];
+ snprintf (statusCodeAsString, sizeof(statusCodeAsString), "%d",StatusCodeEnumToInt[m_StatusCode]);
+ if (statusCodeString == "")
+ statusCodeString = StatusCodeEnumToString[m_StatusCode];
+ std::string firstLine = m_Version + " " + std::string(statusCodeAsString) + " " + statusCodeString + "\r\n";
+
+ m_FirstLineEndOffset = firstLine.length();
+
+ m_SipResponse->m_DataLen = firstLine.length();
+ m_SipResponse->m_Data = new uint8_t[m_SipResponse->m_DataLen];
+ memcpy(m_SipResponse->m_Data, firstLine.c_str(), m_SipResponse->m_DataLen);
+
+ m_IsComplete = true;
+}
+
+std::string SipResponseFirstLine::parseVersion(char* data, size_t dataLen)
+{
+ if (dataLen < 7) // "SIP/x.y"
+ {
+ LOG_DEBUG("SIP response length < 7, cannot identify version");
+ return "";
+ }
+
+ if (data[0] != 'S' || data[1] != 'I' || data[2] != 'P' || data[3] != '/')
+ {
+ LOG_DEBUG("SIP response does not begin with 'SIP/'");
+ return "";
+ }
+
+ char* nextSpace = strchr(data, ' ');
+ if (nextSpace - data > (int)dataLen)
+ return "";
+
+ return std::string(data, nextSpace - data);
+}
+
+
+
+}
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/c0a788b3/thirdparty/pcap++/Packet++/src/SllLayer.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/pcap++/Packet++/src/SllLayer.cpp b/thirdparty/pcap++/Packet++/src/SllLayer.cpp
new file mode 100644
index 0000000..429bc27
--- /dev/null
+++ b/thirdparty/pcap++/Packet++/src/SllLayer.cpp
@@ -0,0 +1,129 @@
+#define LOG_MODULE PacketLogModuleSllLayer
+
+#include <SllLayer.h>
+#include <Logger.h>
+#include <IPv4Layer.h>
+#include <IPv6Layer.h>
+#include <PayloadLayer.h>
+#include <ArpLayer.h>
+#include <VlanLayer.h>
+#include <PPPoELayer.h>
+#include <MplsLayer.h>
+#include <string.h>
+#if defined(WIN32) || defined(WINx64)
+#include <winsock2.h>
+#elif LINUX
+#include <in.h>
+#elif MAC_OS_X
+#include <arpa/inet.h>
+#endif
+
+namespace pcpp
+{
+
+SllLayer::SllLayer(uint16_t packetType, uint16_t ARPHRDType)
+{
+ m_DataLen = sizeof(sll_header);
+ m_Data = new uint8_t[m_DataLen];
+ memset(m_Data, 0, m_DataLen);
+ sll_header* sllHdr = (sll_header*)m_Data;
+ sllHdr->packet_type = htons(packetType);
+ sllHdr->ARPHRD_type = htons(ARPHRDType);
+ m_Protocol = SLL;
+}
+
+bool SllLayer::setLinkLayerAddr(uint8_t* addr, size_t addrLength)
+{
+ if (addrLength == 0 || addrLength > 8)
+ {
+ LOG_ERROR("Address length is out of bounds, it must be between 1 and 8");
+ return false;
+ }
+
+ sll_header* sllHdr = (sll_header*)m_Data;
+ memcpy(sllHdr->link_layer_addr, addr, addrLength);
+ sllHdr->link_layer_addr_len = htons(addrLength);
+
+ return true;
+}
+
+bool SllLayer::setMacAddressAsLinkLayer(MacAddress macAddr)
+{
+ if (!macAddr.isValid())
+ {
+ LOG_ERROR("MAC address is not valid");
+ return false;
+ }
+
+ uint8_t macAddrAsArr[6];
+ macAddr.copyTo(macAddrAsArr);
+ return setLinkLayerAddr(macAddrAsArr, 6);
+}
+
+void SllLayer::parseNextLayer()
+{
+ if (m_DataLen <= sizeof(sll_header))
+ return;
+
+ sll_header* hdr = getSllHeader();
+ switch (ntohs(hdr->protocol_type))
+ {
+ case PCPP_ETHERTYPE_IP:
+ m_NextLayer = new IPv4Layer(m_Data + sizeof(sll_header), m_DataLen - sizeof(sll_header), this, m_Packet);
+ break;
+ case PCPP_ETHERTYPE_IPV6:
+ m_NextLayer = new IPv6Layer(m_Data + sizeof(sll_header), m_DataLen - sizeof(sll_header), this, m_Packet);
+ break;
+ case PCPP_ETHERTYPE_ARP:
+ m_NextLayer = new ArpLayer(m_Data + sizeof(sll_header), m_DataLen - sizeof(sll_header), this, m_Packet);
+ break;
+ case PCPP_ETHERTYPE_VLAN:
+ m_NextLayer = new VlanLayer(m_Data + sizeof(sll_header), m_DataLen - sizeof(sll_header), this, m_Packet);
+ break;
+ case PCPP_ETHERTYPE_PPPOES:
+ m_NextLayer = new PPPoESessionLayer(m_Data + sizeof(sll_header), m_DataLen - sizeof(sll_header), this, m_Packet);
+ break;
+ case PCPP_ETHERTYPE_PPPOED:
+ m_NextLayer = new PPPoEDiscoveryLayer(m_Data + sizeof(sll_header), m_DataLen - sizeof(sll_header), this, m_Packet);
+ break;
+ case PCPP_ETHERTYPE_MPLS:
+ m_NextLayer = new MplsLayer(m_Data + sizeof(sll_header), m_DataLen - sizeof(sll_header), this, m_Packet);
+ break;
+ default:
+ m_NextLayer = new PayloadLayer(m_Data + sizeof(sll_header), m_DataLen - sizeof(sll_header), this, m_Packet);
+ }
+
+}
+
+void SllLayer::computeCalculateFields()
+{
+ if (m_NextLayer == NULL)
+ return;
+
+ sll_header* hdr = getSllHeader();
+ switch (m_NextLayer->getProtocol())
+ {
+ case IPv4:
+ hdr->protocol_type = htons(PCPP_ETHERTYPE_IP);
+ break;
+ case IPv6:
+ hdr->protocol_type = htons(PCPP_ETHERTYPE_IPV6);
+ break;
+ case ARP:
+ hdr->protocol_type = htons(PCPP_ETHERTYPE_ARP);
+ break;
+ case VLAN:
+ hdr->protocol_type = htons(PCPP_ETHERTYPE_VLAN);
+ break;
+ default:
+ return;
+ }
+}
+
+std::string SllLayer::toString()
+{
+ return "Linux cooked header";
+}
+
+} // namespace pcpp
+
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/c0a788b3/thirdparty/pcap++/Packet++/src/TcpLayer.cpp
----------------------------------------------------------------------
diff --git a/thirdparty/pcap++/Packet++/src/TcpLayer.cpp b/thirdparty/pcap++/Packet++/src/TcpLayer.cpp
new file mode 100644
index 0000000..4f81967
--- /dev/null
+++ b/thirdparty/pcap++/Packet++/src/TcpLayer.cpp
@@ -0,0 +1,387 @@
+#define LOG_MODULE PacketLogModuleTcpLayer
+
+#include <TcpLayer.h>
+#include <IPv4Layer.h>
+#include <IPv6Layer.h>
+#include <PayloadLayer.h>
+#include <HttpLayer.h>
+#include <SSLLayer.h>
+#include <SipLayer.h>
+#include <IpUtils.h>
+#include <Logger.h>
+#include <string.h>
+#include <sstream>
+
+namespace pcpp
+{
+
+#define TCPOPT_DUMMY 0xff
+
+
+TcpOptionData* TcpLayer::castPtrToTcpOptionData(uint8_t* ptr)
+{
+ return (TcpOptionData*)ptr;
+}
+
+TcpOptionData* TcpLayer::getTcpOptionData(TcpOption option)
+{
+ uint16_t dataOffset = ((tcphdr *)m_Data)->dataOffset * 4;
+
+ if (m_DataLen < dataOffset)
+ return NULL;
+
+ // check if there are tags at all
+ if (dataOffset <= sizeof(tcphdr))
+ return NULL;
+
+ uint8_t* curOptPtr = m_Data + sizeof(tcphdr);
+
+ while ((curOptPtr - m_Data) < dataOffset)
+ {
+ TcpOptionData* curOpt = castPtrToTcpOptionData(curOptPtr);
+ if ((int)curOpt->option == option)
+ return curOpt;
+
+ curOptPtr += curOpt->getTotalSize();
+ }
+
+ return NULL;
+}
+
+TcpOptionData* TcpLayer::getFirstTcpOptionData()
+{
+ // check if there are TCP options at all
+ if (getHeaderLen() <= sizeof(tcphdr))
+ return NULL;
+
+ uint8_t* curOptPtr = m_Data + sizeof(tcphdr);
+ return castPtrToTcpOptionData(curOptPtr);
+}
+
+TcpOptionData* TcpLayer::getNextTcpOptionData(TcpOptionData* tcpOption)
+{
+ if (tcpOption == NULL)
+ return NULL;
+
+ // prev opt was the last opt
+ if ((uint8_t*)tcpOption + tcpOption->getTotalSize() - m_Data >= (int)getHeaderLen())
+ return NULL;
+
+ TcpOptionData* nextOption = castPtrToTcpOptionData((uint8_t*)tcpOption + tcpOption->getTotalSize());
+ if (nextOption->option == TCPOPT_DUMMY)
+ return NULL;
+
+ return nextOption;
+}
+
+size_t TcpLayer::getTcpOptionsCount()
+{
+ if (m_TcpOptionsCount != (size_t)-1)
+ return m_TcpOptionsCount;
+
+ m_TcpOptionsCount = 0;
+ TcpOptionData* curOpt = getFirstTcpOptionData();
+ while (curOpt != NULL)
+ {
+ m_TcpOptionsCount++;
+ curOpt = getNextTcpOptionData(curOpt);
+ }
+
+ return m_TcpOptionsCount;
+}
+
+TcpOptionData* TcpLayer::addTcpOption(TcpOption optionType, uint8_t optionLength, const uint8_t* optionData)
+{
+ return addTcpOptionAt(optionType, optionLength, optionData, getHeaderLen()-m_NumOfTrailingBytes);
+}
+
+TcpOptionData* TcpLayer::addTcpOptionAfter(TcpOption optionType, uint8_t optionLength, const uint8_t* optionData, TcpOptionData* prevOption)
+{
+ int offset = 0;
+ if (prevOption == NULL)
+ {
+ offset = sizeof(tcphdr);
+ }
+ else
+ {
+ offset = (uint8_t*)prevOption + prevOption->getTotalSize() - m_Data;
+ }
+
+ return addTcpOptionAt(optionType, optionLength, optionData, offset);
+}
+
+bool TcpLayer::removeTcpOption(TcpOption optionType)
+{
+ TcpOptionData* opt = getTcpOptionData(optionType);
+ if (opt == NULL)
+ {
+ return false;
+ }
+
+ // calculate total TCP option size
+ TcpOptionData* curOpt = getFirstTcpOptionData();
+ size_t totalOptSize = 0;
+ while (curOpt != NULL)
+ {
+ totalOptSize += curOpt->getTotalSize();
+ curOpt = getNextTcpOptionData(curOpt);
+ }
+ totalOptSize -= opt->getTotalSize();
+
+
+ int offset = (uint8_t*)opt - m_Data;
+
+ if (!shortenLayer(offset, opt->getTotalSize()))
+ {
+ return false;
+ }
+
+ adjustTcpOptionTrailer(totalOptSize);
+
+ m_TcpOptionsCount--;
+
+ return true;
+}
+
+bool TcpLayer::removeAllTcpOptions()
+{
+ int offset = sizeof(tcphdr);
+
+ if (!shortenLayer(offset, getHeaderLen()-offset))
+ return false;
+
+ getTcpHeader()->dataOffset = sizeof(tcphdr)/4;
+ m_NumOfTrailingBytes = 0;
+ m_TcpOptionsCount = 0;
+ return true;
+}
+
+TcpOptionData* TcpLayer::addTcpOptionAt(TcpOption optionType, uint8_t optionLength, const uint8_t* optionData, int offset)
+{
+ if ((optionType == PCPP_TCPOPT_EOL || optionType == PCPP_TCPOPT_NOP) && optionLength != PCPP_TCPOLEN_NOP)
+ {
+ LOG_ERROR("Can't set TCP NOP option or TCP EOL option with size different than 1, tried to set size %d", optionLength);
+ return NULL;
+ }
+
+ // calculate total TCP option size
+ TcpOptionData* curOpt = getFirstTcpOptionData();
+ size_t totalOptSize = 0;
+ while (curOpt != NULL)
+ {
+ totalOptSize += curOpt->getTotalSize();
+ curOpt = getNextTcpOptionData(curOpt);
+ }
+ totalOptSize += optionLength;
+
+
+ if (!extendLayer(offset, optionLength))
+ {
+ LOG_ERROR("Could not extend TcpLayer in [%d] bytes", optionLength);
+ return NULL;
+ }
+
+ uint8_t optionTypeVal = (uint8_t)optionType;
+ memcpy(m_Data + offset, &optionTypeVal, sizeof(uint8_t));
+
+ if (optionLength > 1)
+ {
+ memcpy(m_Data + offset + sizeof(uint8_t), &optionLength, sizeof(uint8_t));
+ if (optionLength > 2 && optionData != NULL)
+ memcpy(m_Data + offset + 2*sizeof(uint8_t), optionData, optionLength-2*sizeof(uint8_t));
+ }
+
+ adjustTcpOptionTrailer(totalOptSize);
+
+ uint8_t* newOptPtr = m_Data + offset;
+
+ m_TcpOptionsCount++;
+
+ return castPtrToTcpOptionData(newOptPtr);
+}
+
+void TcpLayer::adjustTcpOptionTrailer(size_t totalOptSize)
+{
+ int newNumberOfTrailingBytes = 0;
+ while ((totalOptSize + newNumberOfTrailingBytes) % 4 != 0)
+ newNumberOfTrailingBytes++;
+
+ if (newNumberOfTrailingBytes < m_NumOfTrailingBytes)
+ shortenLayer(sizeof(tcphdr)+totalOptSize, m_NumOfTrailingBytes - newNumberOfTrailingBytes);
+ else if (newNumberOfTrailingBytes > m_NumOfTrailingBytes)
+ extendLayer(sizeof(tcphdr)+totalOptSize, newNumberOfTrailingBytes - m_NumOfTrailingBytes);
+
+ m_NumOfTrailingBytes = newNumberOfTrailingBytes;
+
+ for (int i = 0; i < m_NumOfTrailingBytes; i++)
+ m_Data[sizeof(tcphdr) + totalOptSize + i] = TCPOPT_DUMMY;
+
+ getTcpHeader()->dataOffset = (sizeof(tcphdr) + totalOptSize + m_NumOfTrailingBytes)/4;
+}
+
+uint16_t TcpLayer::calculateChecksum(bool writeResultToPacket)
+{
+ tcphdr* tcpHdr = getTcpHeader();
+ uint16_t checksumRes = 0;
+ uint16_t currChecksumValue = tcpHdr->headerChecksum;
+
+ if (m_PrevLayer != NULL)
+ {
+ tcpHdr->headerChecksum = 0;
+ ScalarBuffer<uint16_t> vec[2];
+ LOG_DEBUG("data len = %d", (int)m_DataLen);
+ vec[0].buffer = (uint16_t*)m_Data;
+ vec[0].len = m_DataLen;
+
+ if (m_PrevLayer->getProtocol() == IPv4)
+ {
+ uint32_t srcIP = ((IPv4Layer*)m_PrevLayer)->getSrcIpAddress().toInt();
+ uint32_t dstIP = ((IPv4Layer*)m_PrevLayer)->getDstIpAddress().toInt();
+ uint16_t pseudoHeader[6];
+ pseudoHeader[0] = srcIP >> 16;
+ pseudoHeader[1] = srcIP & 0xFFFF;
+ pseudoHeader[2] = dstIP >> 16;
+ pseudoHeader[3] = dstIP & 0xFFFF;
+ pseudoHeader[4] = 0xffff & htons(m_DataLen);
+ pseudoHeader[5] = htons(0x00ff & PACKETPP_IPPROTO_TCP);
+ vec[1].buffer = pseudoHeader;
+ vec[1].len = 12;
+ checksumRes = compute_checksum(vec, 2);
+ LOG_DEBUG("calculated checksum = 0x%4X", checksumRes);
+
+
+ }
+ else if (m_PrevLayer->getProtocol() == IPv6)
+ {
+ uint16_t pseudoHeader[18];
+ ((IPv6Layer*)m_PrevLayer)->getSrcIpAddress().copyTo((uint8_t*)pseudoHeader);
+ ((IPv6Layer*)m_PrevLayer)->getDstIpAddress().copyTo((uint8_t*)(pseudoHeader+8));
+ pseudoHeader[16] = 0xffff & htons(m_DataLen);
+ pseudoHeader[17] = htons(0x00ff & PACKETPP_IPPROTO_TCP);
+ vec[1].buffer = pseudoHeader;
+ vec[1].len = 36;
+ checksumRes = compute_checksum(vec, 2);
+ LOG_DEBUG("calculated checksum = 0x%4X", checksumRes);
+ }
+ }
+
+ if(writeResultToPacket)
+ tcpHdr->headerChecksum = htons(checksumRes);
+ else
+ tcpHdr->headerChecksum = currChecksumValue;
+
+ return checksumRes;
+}
+
+void TcpLayer::initLayer()
+{
+ m_DataLen = sizeof(tcphdr);
+ m_Data = new uint8_t[m_DataLen];
+ memset(m_Data, 0, m_DataLen);
+ m_Protocol = TCP;
+ m_TcpOptionsCount = 0;
+ m_NumOfTrailingBytes = 0;
+ getTcpHeader()->dataOffset = sizeof(tcphdr)/4;
+}
+
+TcpLayer::TcpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) : Layer(data, dataLen, prevLayer, packet)
+{
+ m_Protocol = TCP;
+ m_TcpOptionsCount = -1;
+ m_NumOfTrailingBytes = 0;
+}
+
+TcpLayer::TcpLayer()
+{
+ initLayer();
+}
+
+TcpLayer::TcpLayer(uint16_t portSrc, uint16_t portDst)
+{
+ initLayer();
+ getTcpHeader()->portDst = htons(portDst);
+ getTcpHeader()->portSrc = htons(portSrc);
+}
+
+void TcpLayer::copyLayerData(const TcpLayer& other)
+{
+ m_TcpOptionsCount = other.m_TcpOptionsCount;
+ m_NumOfTrailingBytes = other.m_NumOfTrailingBytes;
+}
+
+TcpLayer::TcpLayer(const TcpLayer& other) : Layer(other)
+{
+ copyLayerData(other);
+}
+
+TcpLayer& TcpLayer::operator=(const TcpLayer& other)
+{
+ Layer::operator=(other);
+
+ copyLayerData(other);
+
+ return *this;
+}
+
+void TcpLayer::parseNextLayer()
+{
+ size_t headerLen = getHeaderLen();
+ if (m_DataLen <= headerLen)
+ return;
+
+ tcphdr* tcpHder = getTcpHeader();
+ uint16_t portDst = ntohs(tcpHder->portDst);
+ uint16_t portSrc = ntohs(tcpHder->portSrc);
+ if ((HttpMessage::getHTTPPortMap()->find(portDst) != HttpMessage::getHTTPPortMap()->end()) && HttpRequestFirstLine::parseMethod((char*)(m_Data + headerLen), m_DataLen - headerLen) != HttpRequestLayer::HttpMethodUnknown)
+ m_NextLayer = new HttpRequestLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
+ else if ((HttpMessage::getHTTPPortMap()->find(portSrc) != HttpMessage::getHTTPPortMap()->end()) && HttpResponseFirstLine::parseStatusCode((char*)(m_Data + headerLen), m_DataLen - headerLen) != HttpResponseLayer::HttpStatusCodeUnknown)
+ m_NextLayer = new HttpResponseLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
+ else if (SSLLayer::IsSSLMessage(portSrc, portDst, m_Data + headerLen, m_DataLen - headerLen))
+ m_NextLayer = SSLLayer::createSSLMessage(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
+ else if (((portDst == 5060) || (portDst == 5061)) && (SipRequestFirstLine::parseMethod((char*)(m_Data + headerLen), m_DataLen - headerLen) != SipRequestLayer::SipMethodUnknown))
+ m_NextLayer = new SipRequestLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
+ else if (((portDst == 5060) || (portDst == 5061)) && (SipResponseFirstLine::parseStatusCode((char*)(m_Data + headerLen), m_DataLen - headerLen) != SipResponseLayer::SipStatusCodeUnknown))
+ m_NextLayer = new SipResponseLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
+ else
+ m_NextLayer = new PayloadLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
+}
+
+void TcpLayer::computeCalculateFields()
+{
+ tcphdr* tcpHdr = getTcpHeader();
+
+ tcpHdr->dataOffset = getHeaderLen() >> 2;
+ calculateChecksum(true);
+}
+
+std::string TcpLayer::toString()
+{
+ tcphdr* hdr = getTcpHeader();
+ std::string result = "TCP Layer, ";
+ if (hdr->synFlag)
+ {
+ if (hdr->ackFlag)
+ result += "[SYN, ACK], ";
+ else
+ result += "[SYN], ";
+ }
+ else if (hdr->finFlag)
+ {
+ if (hdr->ackFlag)
+ result += "[FIN, ACK], ";
+ else
+ result += "[FIN], ";
+ }
+ else if (hdr->ackFlag)
+ result += "[ACK], ";
+
+ std::ostringstream srcPortStream;
+ srcPortStream << ntohs(hdr->portSrc);
+ std::ostringstream dstPortStream;
+ dstPortStream << ntohs(hdr->portDst);
+ result += "Src port: " + srcPortStream.str() + ", Dst port: " + dstPortStream.str();
+
+ return result;
+}
+
+} // namespace pcpp