extended ICMP packet dumping to parts after packet creation

[pingcheck] / src / icmp / icmpdata_pingfailreply.cpp

/*
 The software in this package is distributed under the GNU General
 Public License version 2 (with a special exception described below).

 A copy of GNU General Public License (GPL) is included in this distribution,
 in the file COPYING.GPL.

 As a special exception, if other files instantiate templates or use macros
 or inline functions from this file, or you compile this file and link it
 with other works to produce a work based on this file, this file
 does not by itself cause the resulting work to be covered
 by the GNU General Public License.

 However the source code for this file must still be made available
 in accordance with section (3) of the GNU General Public License.

 This exception does not invalidate any other reasons why a work based
 on this file might be covered by the GNU General Public License.

 Christian Herdtweck, Intra2net AG 2015
 Based on an example in Boost Documentation (by Christopher M. Kohlhoff)
 and adaptation by Guilherme M. Ferreira
 */

#include "icmp/icmpdata_pingfailreply.h"
#include "boost_assert_handler.h"

#include <logfunc.hpp>
using I2n::Logger::GlobalLogger;


IcmpData_PingFailReply::IcmpData_PingFailReply(const std::size_t size_arg)
    : IcmpData( size_arg )
{}

bool IcmpData_PingFailReply::match_echo_reply(
                                           const uint16_t identifier,
                                           const uint16_t sequence_number) const
{ return false; }

bool IcmpData_PingFailReply::match_ping_request(
                                           const uint16_t identifier,
                                           const uint16_t sequence_number) const
{
    return      identifier == get_icmp_identifier() &&
           sequence_number == get_icmp_sequence_number();
}


uint16_t IcmpData_PingFailReply::get_icmp_identifier() const
{ return get_icmp_request_data(4); }

uint16_t IcmpData_PingFailReply::get_icmp_sequence_number() const
{ return get_icmp_request_data(6); }

/**
 * @brief access a given byte within request ICMP data
 *
 * first tests whether data actually IS a reply for an ICMP request and what
 *   IP version this is, then access the given byte and byte+1 within request
 *   ICMP header/data
 *
 * @returns 2-byte value based on byte and byte+1 in icmp data
 */
uint16_t IcmpData_PingFailReply::get_icmp_request_data(
                                                const int icmp_start_byte) const
{
    // payload should be the original query, which is an IP packet.
    // first check whether that IP packet contains an ICMP message at all
    int offset = get_icmp_data_offset();

    if (offset == -1)
        return static_cast<uint16_t>(-1);
    else
        // if it is an icmp message, then the icmp packet comes right after
        // the IP header. Inside the icmp packet we need the given byte offset
        return IcmpData::raw_data.decode16(offset+icmp_start_byte,
                                           offset+icmp_start_byte+1);
}

/**
 * copying code from ip header parsing ...
 * If we need more functions of this sort, could create a data stream from
 *   raw_data, read a IpHeader from it and get info from that
 *
 * Unfortunately, the value in packet is not the original one, but the one
 *   change en route to destination, so in case of TimeExceeded, it is always 1
 *
 * @throws boost assertion if data does not seem to start with an IP v4/6 header
 */
uint8_t IcmpData_PingFailReply::get_ip_ttl() const
{
    int offset = 4;   // the 4 uninteresting bytes we need to skip
    int version = IcmpData::get_ip_version();

    if (version == 4)   // IPv4
        offset += 8;    // byte 8 within IP header
    else if (version == 6)   // IPv6
        offset += 7;
    else
    {
        GlobalLogger.error() << "Request IP header is neither IPv4 nor v6!"
                             << std::endl;
        BOOST_ASSERT( !"Source IP header is neither IPv4 nor v6!" );
    }

    return IcmpData::raw_data[offset];
}

/** @brief get byte index of start of ICMP request data after IP header
 *
 * @returns -1 if this data does not contain a ICMP request packet
 * @throws boost assertion if data does not seem to start with an IP v4/6 header
 */
int IcmpData_PingFailReply::get_icmp_data_offset() const
{
    bool is_icmp = false;
    int offset = 4;   // the 4 uninteresting bytes we need to skip
    uint8_t version_with_ihl = static_cast<uint8_t>(IcmpData::raw_data[offset]);
    uint8_t version = (version_with_ihl & 0xF0) >> 4;

    if (version == 4)   // IPv4
    {
        is_icmp = IcmpData::raw_data[offset+9] == 1;
        offset += 20;     // 20 byte for IPv4 header
    }
    else if (version == 6)   // IPv6
    {
        is_icmp = IcmpData::raw_data[offset+6] == 58;
        offset += 40;     // 40 byte for IPv6 header
    }
    else
    {
        GlobalLogger.error()
            << "Icmp data does not seem to start with IPv4/6 header!"
            << std::endl;
        BOOST_ASSERT( !"Icmp data does not seem to start with IPv4/6 header!" );
    }

    if (is_icmp)
        return offset;
    else
        return -1;
}