void IpAnalysis::analyzeProtocol(ProtocolStack &pstack, size_t *bytes)
{
if(_bufsize < sizeof(_iphdr))
{
bzero(&_iphdr, sizeof(_iphdr));
return;
}
memcpy(&_iphdr, _buffer, sizeof(_iphdr));
_iphdr.tot_len = ntohs(_iphdr.tot_len);
_iphdr.check = ntohs(_iphdr.check);
if(bytes != NULL)
*bytes += _iphdr.tot_len;
pstack.push_back(this);
Analysis *child = _getChild(_iphdr.protocol);
if(child != NULL)
{
child->setBuffer(_buffer + getHeaderLen(),
_bufsize - getHeaderLen());
child->analyzeProtocol(pstack, NULL);
}
}
void HttpReq::updateReqHeader(int index, const char *pNewValue,
int newValueLen)
{
char *pOld = (char *)getHeader(index);
int oldLen = getHeaderLen(index);
int diff = oldLen - newValueLen;
if (*pOld && diff >= 0)
{
memmove(pOld, pNewValue, newValueLen);
if (diff > 0)
memset(pOld + newValueLen, ' ', diff);
}
else
{
const char *pName = HttpHeader::getHeader(index);
int iNameLen = HttpHeader::getHeaderStringLen(index);
if (m_headerBuf.available() < newValueLen + iNameLen + 4)
m_headerBuf.grow(newValueLen + iNameLen + 4 - m_headerBuf.available());
m_headerBuf.append(pName, iNameLen);
m_headerBuf.append(':');
m_headerBuf.append(' ');
m_commonHeaderOffset[ index ] = m_headerBuf.size();
m_headerBuf.append(pNewValue, newValueLen);
m_headerBuf.append('\r');
m_headerBuf.append('\n');
}
m_commonHeaderLen[index] = newValueLen;
}
void GreLayer::parseNextLayer()
{
size_t headerLen = getHeaderLen();
if (m_DataLen <= headerLen)
return;
gre_basic_header* header = (gre_basic_header*)m_Data;
switch (ntohs(header->protocol))
{
case PCPP_ETHERTYPE_IP:
m_NextLayer = new IPv4Layer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
case PCPP_ETHERTYPE_IPV6:
m_NextLayer = new IPv6Layer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
case PCPP_ETHERTYPE_VLAN:
m_NextLayer = new VlanLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
case PCPP_ETHERTYPE_MPLS:
m_NextLayer = new MplsLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
case PCPP_ETHERTYPE_PPP:
m_NextLayer = new PPP_PPTPLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
default:
m_NextLayer = new PayloadLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
}
}
TcpOption TcpLayer::getNextTcpOption(TcpOption& tcpOption)
{
TcpOption nextOpt = m_OptionReader.getNextTLVRecord(tcpOption, getOptionsBasePtr(), getHeaderLen() - sizeof(tcphdr));
if (nextOpt.isNotNull() && nextOpt.getType() == TCPOPT_DUMMY)
return TcpOption(NULL);
return nextOpt;
}
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);
}
uint16_t PPPoESessionLayer::getPPPNextProtocol()
{
if (m_DataLen < getHeaderLen())
{
LOG_ERROR("ERROR: size of layer is smaller then PPPoE session header");
return 0;
}
uint16_t pppNextProto = *(uint16_t*)(m_Data + sizeof(pppoe_header));
return ntohs(pppNextProto);
}
void PPPoESessionLayer::setPPPNextProtocol(uint16_t nextProtocol)
{
if (m_DataLen < getHeaderLen())
{
LOG_ERROR("ERROR: size of layer is smaller then PPPoE session header");
return;
}
uint16_t* pppProto = (uint16_t*)(m_Data + sizeof(pppoe_header));
*pppProto = htons(nextProtocol);
}
bool TcpLayer::removeAllTcpOptions()
{
int offset = sizeof(tcphdr);
if (!shortenLayer(offset, getHeaderLen()-offset))
return false;
getTcpHeader()->dataOffset = sizeof(tcphdr)/4;
m_NumOfTrailingBytes = 0;
m_OptionReader.changeTLVRecordCount(0-getTcpOptionCount());
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;
}
void IcmpLayer::parseNextLayer()
{
IcmpMessageType type = getMessageType();
size_t headerLen = 0;
switch (type)
{
case ICMP_DEST_UNREACHABLE:
case ICMP_SOURCE_QUENCH:
case ICMP_TIME_EXCEEDED:
case ICMP_REDIRECT:
case ICMP_PARAM_PROBLEM:
headerLen = getHeaderLen();
if (m_DataLen - headerLen >= sizeof(iphdr))
m_NextLayer = new IPv4Layer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
return;
default:
headerLen = getHeaderLen();
if (m_DataLen > headerLen)
m_NextLayer = new PayloadLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
return;
}
}
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;
}
void PPP_PPTPLayer::parseNextLayer()
{
size_t headerLen = getHeaderLen();
if (m_DataLen <= headerLen)
return;
switch (ntohs(getPPP_PPTPHeader()->protocol))
{
case PCPP_PPP_IP:
m_NextLayer = new IPv4Layer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
case PCPP_PPP_IPV6:
m_NextLayer = new IPv6Layer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
default:
m_NextLayer = new PayloadLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
}
}
void PPPoESessionLayer::parseNextLayer()
{
size_t headerLen = getHeaderLen();
if (m_DataLen <= headerLen)
return;
switch (getPPPNextProtocol())
{
case PPP_IP:
m_NextLayer = new IPv4Layer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
case PPP_IPV6:
m_NextLayer = new IPv6Layer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
default:
m_NextLayer = new PayloadLayer(m_Data + headerLen, m_DataLen - headerLen, this, m_Packet);
break;
}
}
void GREv1Layer::computeCalculateFields()
{
computeCalculateFieldsInner();
getGreHeader()->payloadLength = htons(m_DataLen - getHeaderLen());
}
TcpOption TcpLayer::getFirstTcpOption()
{
return m_OptionReader.getFirstTLVRecord(getOptionsBasePtr(), getHeaderLen() - sizeof(tcphdr));
}
TcpOptionData* TcpLayer::addTcpOption(TcpOption optionType, uint8_t optionLength, const uint8_t* optionData)
{
return addTcpOptionAt(optionType, optionLength, optionData, getHeaderLen()-m_NumOfTrailingBytes);
}
size_t TcpLayer::getTcpOptionCount()
{
return m_OptionReader.getTLVRecordCount(getOptionsBasePtr(), getHeaderLen() - sizeof(tcphdr));
}
TcpOption TcpLayer::addTcpOption(const TcpOptionBuilder& optionBuilder)
{
return addTcpOptionAt(optionBuilder, getHeaderLen()-m_NumOfTrailingBytes);
}
TcpOption TcpLayer::getTcpOption(TcpOptionType option)
{
return m_OptionReader.getTLVRecord((uint8_t)option, getOptionsBasePtr(), getHeaderLen() - sizeof(tcphdr));
}
PPPoEDiscoveryLayer::PPPoETag* PPPoEDiscoveryLayer::addTag(PPPoETagTypes tagType, uint16_t tagLength, const uint8_t* tagData)
{
return addTagAt(tagType, tagLength, tagData, getHeaderLen());
}
