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