extended ICMP packet dumping to parts after packet creation

[pingcheck] / src / tools / feed_packet_data.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.
*/

#include <fstream>
#include <ios>
#include <logfunc.hpp>
#include <boost/foreach.hpp>
#include <boost/program_options.hpp>
#include <boost/asio/ip/icmp.hpp>

#include "icmp/icmppacketfactory.h"
#include "tcp/tcpsegmentfactory.h"
#include "tools/pcap.h"

using I2n::Logger::GlobalLogger;
namespace po = boost::program_options;


//------------------------------------------------------------------------------
// constants
const bool default_is_icmp = true;
const bool default_is_v4 = true;

//------------------------------------------------------------------------------
// function declarations
void init_logger();
void increase_verbosity();
int read_packets(std::istream &input_stream, const bool, const bool);

//------------------------------------------------------------------------------
// helper functions

void init_logger()
{
    // set default: log at level NOTICE to stderr
    I2n::Logger::enable_stderr_log( true );
    I2n::Logger::set_log_level( I2n::Logger::LogLevel::Debug );
    GlobalLogger.info() << "Logger initiated";
}

void increase_verbosity()
{
    I2n::Logger::set_log_level( I2n::Logger::LogLevel::Debug );
    GlobalLogger.info() << "Increased verbosity";
}

/**
 * @brief read packets from given input stream
 *
 * @returns positive error code or negated number of packets created
 */
int read_packets( std::istream &input_stream, const bool is_icmp,
                                              const bool is_v4)
{
    // peek at start of stream to see if there is a pcap header
    bool is_pcap = check_for_pcap_header(input_stream);
    if (is_pcap)
        GlobalLogger.info() << "File is pcap --> consume first "
            << pcap_file_header_size << " bytes";
    else
        GlobalLogger.info() << "File is not pcap";

    int next_val;
    int packet_count = 0;
    uint32_t packet_type = 0;
    if (is_pcap)
    {
        packet_type = consume_pcap_file_header(input_stream);
        GlobalLogger.debug() << "Packet type from header is " << packet_type;
    }
    if ( !input_stream )
    {
        GlobalLogger.notice() << "Failure consuming pcap file header!";
        return 3;
    }

    // read from stream until it is empty
    while (true)
    {
        if (is_pcap)
        {
            // assume that there is a packet header if stream had pcap header
            GlobalLogger.debug() << "Consume packet header ("
                << pcap_packet_header_size << " bytes)";
            consume_pcap_packet_header(input_stream);
            if ( !input_stream )
            {
                GlobalLogger.notice() <<"Failure consuming pcap packet header!";
                return 4;
            }

            if (packet_type == 1)
            {
                GlobalLogger.debug() << "Consume ethernet header ("
                    << pcap_ethernet_header_size << " bytes)";
                consume_pcap_ethernet_header(input_stream);
                if ( !input_stream )
                {
                    GlobalLogger.notice() <<"Failure consuming pcap packet header!";
                    return 5;
                }
            }
        }

        // feed data to right factory
        if (is_icmp)
        {
            IcmpPacketItem packet;
            if (is_v4)
            {
                GlobalLogger.info() << "Trying to read ICMP v4 packet"
                                    << std::endl;
                packet = IcmpPacketFactory::create_icmp_packet(
                                     boost::asio::ip::icmp::v4(), input_stream);
            }
            else  // v6
            {
                GlobalLogger.info() << "Trying to read ICMP v6 packet"
                                    << std::endl;
                packet = IcmpPacketFactory::create_icmp_packet(
                                     boost::asio::ip::icmp::v6(), input_stream);
            }

            if (packet)
            {
                GlobalLogger.notice() << "Succesfully created ICMP packet";
                GlobalLogger.info() << packet->to_string();
            }
            else
            {
                GlobalLogger.notice() << "ICMP packet creation failed";
                return 6;
            }
        }
        else   // is tcp
        {
            TcpSegmentItem segment;
            if (is_v4)
            {
                GlobalLogger.info() << "Trying to read TCP v4 packet"
                                    << std::endl;
                segment = TcpSegmentFactory::create_tcp_segment(
                        boost::asio::ip::tcp_raw_protocol::v4(),
                        input_stream);
            }
            else  // v6
            {
                GlobalLogger.info() << "Trying to read TCP v6 packet"
                                    << std::endl;
                segment = TcpSegmentFactory::create_tcp_segment(
                        boost::asio::ip::tcp_raw_protocol::v6(),
                        input_stream);
            }

            if (segment)
                GlobalLogger.notice() << "Succesfully created TCP segment";
            else
            {
                GlobalLogger.notice() << "TCP segment creation failed";
                return 6;
            }
        }

        if ( !input_stream )
        {
            GlobalLogger.notice() << "Stream not good after reading!";
            return 7;
        }

        // if reached this point, created a packet, otherwise will have
        // returned with error code
        ++packet_count;

        // peek 1 byte to check whether we are at the end of stream
        next_val = input_stream.get();
        if ( input_stream.eof() )
        {
            GlobalLogger.info() << "Reached end of stream";
            break;
        }
        GlobalLogger.debug() << "Stream continues with value " << std::showbase
                             << std::hex << next_val;

        if (is_pcap && packet_type == 1 && next_val == 0)
        {
            GlobalLogger.debug() << "Consume 0s added for alignment";
            while (input_stream.good() && next_val == 0)
                next_val = input_stream.get();

            // if stream is still good, then got a non-0 value from it
            // --> put it back
            if (input_stream.good())
                input_stream.unget();
            else
            {
                GlobalLogger.info() << "Reached end of stream";
                break;
            }
        }
        else
            input_stream.unget();
    } //eo: while (input_stream)

    return (-1) * packet_count;
} // eo: function read_packets

//------------------------------------------------------------------------------
/** @brief main function
 *
 * @returns 0 if all input resulted in good packets or the error number of the
 *   last failed packet
 */
int main(int argc, char *argv[])
{
    // init logging
    init_logger();

    bool is_icmp = default_is_icmp;
    bool is_v4 = default_is_v4;
    int current_return, return_val = 0;
    int packet_count_good = 0;
    int packet_count_bad = 0;
    DumpMode dump_mode = DUMP_NEVER;

    if (argc == 1)
    {
        GlobalLogger.notice() << "No arguments! Start with mix of file names "
                              << "and flags";
        GlobalLogger.notice() << "Valid flags: -i[cmp], -t[cp], -[v]4 -[v]6; "
                              << "-- to read from stdin instead of file";
        return 1;
    }

    IcmpPacketFactory::PacketDumpMode = dump_mode;

    // convert arguments to vector of strings and loop over them
    std::vector<std::string> args(argv+1, argv + argc);
    BOOST_FOREACH (const std::string &arg, args)
    {
        GlobalLogger.debug() << "Parsing next arg: " << arg;
        current_return = 0;

        // check if is some specification of data format
        if (arg == "-i" || arg == "-icmp" || arg == "i" || arg == "icmp")
            is_icmp = true;
        else if (arg == "-t" || arg == "-tcp" || arg == "t" || arg == "tcp")
            is_icmp = false;
        else if (arg == "-4" || arg == "-v4" || arg == "4" || arg == "v4")
            is_v4 = true;
        else if (arg == "-6" || arg == "-v6" || arg == "6" || arg == "v6")
            is_v4 = false;
        else if (arg == "-v")
            increase_verbosity();
        else if (arg == "--")   // read input from stdin
        {
            GlobalLogger.info() << "Trying to read from stdin" << std::endl;
            current_return = read_packets(std::cin, is_icmp, is_v4);
        }
        else   // assume is file name
        {
            GlobalLogger.info() << "Trying to read from " << arg
                                << std::endl;
            std::ifstream file_stream(arg.c_str(), std::ios::in |
                                                   std::ios::binary);
            if ( !file_stream )
            {
                GlobalLogger.notice() << "Failed to open file " << arg
                    << " for reading!";
                current_return = 2;
            }
            else
            {
                current_return = read_packets( file_stream, is_icmp, is_v4);
                file_stream.close();
            }
        }

        if (current_return > 0)
        {
            GlobalLogger.debug() << "Remember error value " << current_return;
            return_val = current_return;
            ++packet_count_bad;
        }
        else // returned the number of packets created * (-1)
            packet_count_good -= current_return;
    } //eo: loop over input-files

    GlobalLogger.notice() << "Created (at least) " << packet_count_good
        << " packets successfully and failed for " << packet_count_bad;
    // ("at least" because if we get an error code from read_packets, then
    //  there might have been successfull reads earlier in same stream)

    GlobalLogger.debug() << "End program with return value " << return_val;
    return return_val;

} // eo: function main