用boost庫實現traceroute小工具

????? 參考了網上幾個 traceroute的實現版本，存在一些缺陷，比如沒有做超時處理，或者只能在window下使用。自己用boost實現了一個traceroute小工具，在window下正常運行。

????? 先來看下面實現的原理。這些說明來自維基百科。traceroute，現代Linux系統稱為tracepath，Windows系統稱為tracert，是一種電腦網絡工具。它可顯示數據包在IP網絡經過的路由器的IP地址。 程序利用增加存活時間（TTL）值來實現其功能的。每當數據包經過一個路由器，其存活時間就會減1。當其存活時間是0時，主機便取消數據包，并傳送一個ICMP TTL數據包給原數據包的發出者。

????? 下面是具體實現的源代碼：

?

//
// traceroute.cpp
// ~~~~~~~~
//
// BoSheng Lu 2013-04-25
//
// Version 1.0.
//

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include<boost/thread.hpp>
#include <istream>
#include <iostream>
#include<iomanip>
#include<string> 
#include <ostream>

#include "icmp_header.hpp"
#include "ipv4_header.hpp"

using boost::asio::ip::icmp;
using boost::asio::deadline_timer;
namespace posix_time = boost::posix_time;

class traceroute
{
public:
    traceroute(boost::asio::io_service& io_service, const char* destination)
        : resolver_(io_service), socket_(io_service, icmp::v4()),
        sequence_number_(0), max_hop_(30)
    {
        icmp::resolver::query query(icmp::v4(), destination, "");
        destination_ = *resolver_.resolve(query);

        std::cout << "\nTracing route to " << destination 
        << " [" << destination_.address().to_string() << "]"
        << " with a maximum of " << max_hop_ << " hops.\n" << std::endl;

#if defined(BOOST_WINDOWS)
        int timeout = 5000;
        if( setsockopt(socket_.native(), SOL_SOCKET, SO_RCVTIMEO, 
            (const char*)&timeout, sizeof(timeout)))
        {
             std::cout << "RCVTIMEO not set properly." << std::endl;
            throw std::runtime_error("RCVTIMEO not set properly");
        }
#else
        struct timeval tv;
        tv.tv_sec  = 5; 
        tv.tv_usec = 0;         
        if( setsockopt(socket_.native(), SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)))
        {
            std::cout << "RCVTIMEO not set properly." << std::endl;
            throw std::runtime_error("RCVTIMEO not set properly");
        }
#endif

        reach_dest_host_ = false;
        int ttl = 1;
        while (!reach_dest_host_ && max_hop_--)
        {
            const boost::asio::ip::unicast::hops option(ttl);
            socket_.set_option(option);

            boost::asio::ip::unicast::hops op;
            socket_.get_option(op);
            if( ttl !=  op.value() )
            {
                std::cout << "TTL not set properly. Should be "
                    << ttl << " but was set to "
                    << op.value() << '.' << std::endl;
                throw std::runtime_error("TTL not set properly");        
            }

            std::cout << std::setw(3) << ttl << std::flush;
            start_send();
            start_receive();
         
            ttl++;
        }//while
    }

private:
    void start_send()
    {
        std::string body("\"Hello!\" from Asio ping.");

        // Create an ICMP header for an echo request.
        icmp_header echo_request;
        echo_request.type(icmp_header::echo_request);
        echo_request.code(0);
        echo_request.identifier(get_identifier());
        echo_request.sequence_number(++sequence_number_);
        compute_checksum(echo_request, body.begin(), body.end());

        // Encode the request packet.
        boost::asio::streambuf request_buffer;
        std::ostream os(&request_buffer);
        os << echo_request << body;

        // Send the request.
        time_sent_ = posix_time::microsec_clock::universal_time();
        socket_.send_to(request_buffer.data(), destination_);  
    }


    void start_receive()
    {
        // Discard any data already in the buffer.
        reply_buffer_.consume(reply_buffer_.size());

        // Wait for a reply. We prepare the buffer to receive up to 64KB.
        boost::system::error_code ec;
        boost::asio::socket_base::message_flags flags = 0;
        size_t len = socket_.receive(reply_buffer_.prepare(65536), flags, ec);
    
        handle_receive(len, ec);
    }

    void handle_receive(std::size_t length, boost::system::error_code& ec)
    {
        // The actual number of bytes received is committed to the buffer so that we
        // can extract it using a std::istream object.
        reply_buffer_.commit(length);

        // Decode the reply packet.
        std::istream is(&reply_buffer_);
        ipv4_header ipv4_hdr;
        is >> ipv4_hdr;

        if(ec)
        {
            std::cout << std::setw(9) << '*' << '\t' << "Request timed out." << std::endl;
            return;
        }
    
        posix_time::ptime now = posix_time::microsec_clock::universal_time();
        long long dwRoundTripTime = (now - time_sent_).total_milliseconds();

        if(dwRoundTripTime)
        {
            std::cout << std::setw(6) << dwRoundTripTime << " ms"  << std::flush;
        }
        else
        {
            std::cout << std::setw(6) << "<1" << " ms" << std::flush;
        }
        
        boost::this_thread::sleep(boost::posix_time::seconds(2)); 
    
        std::cout << '\t' << ipv4_hdr.source_address() << std::endl;

        // Print out some information about the reply packet.
        if( ipv4_hdr.source_address().to_string() == destination_.address().to_string() )
        {
            reach_dest_host_ = true;
            std::cout << std::endl;
            std::cout << std::endl;
            std::cout << "traceroute sucess!" << std::endl;

            icmp_header icmp_hdr;
            is >> icmp_hdr;

            if (is && icmp_hdr.type() == icmp_header::echo_reply
                && icmp_hdr.identifier() == get_identifier()
                && icmp_hdr.sequence_number() == sequence_number_)
            {
                // Print out some information about the reply packet.
                std::cout << length - ipv4_hdr.header_length()
                 << " bytes from " << ipv4_hdr.source_address()
                << ": icmp_seq=" << icmp_hdr.sequence_number()
                << ", ttl=" << ipv4_hdr.time_to_live()
                << ", time=" << dwRoundTripTime << " ms"
                << std::endl;
            }
        }
     }

    static unsigned short get_identifier()
    {
#if defined(BOOST_WINDOWS)
        return static_cast<unsigned short>(::GetCurrentProcessId());
#else
        return static_cast<unsigned short>(::getpid());
#endif
    }

    icmp::resolver resolver_;
    icmp::endpoint destination_;
    icmp::socket socket_;
    unsigned short sequence_number_;
    posix_time::ptime time_sent_;
    boost::asio::streambuf reply_buffer_;
    bool reach_dest_host_;
    std::size_t max_hop_;
};

int main(int argc, char* argv[])
{
    try
    {
        if(argc != 2)
        {
            std::cerr << "Usage: ping <host>" << std::endl;
#if !defined(BOOST_WINDOWS)
            std::cerr << "(You may need to run this program as root.)" << std::endl;
#endif
            return 1;
        }

        boost::asio::io_service io_service;
        traceroute p(io_service, argv[1]);
        io_service.run();
    }
    catch (std::exception& e)
    {
        std::cerr << "Exception: " << e.what() << std::endl;
    }
}

?

?

??? ? ?這個源碼實現使用了boost庫附帶的boost asio使用示例中的代碼，下面也將這個例子中使用到的代碼附上，方便使用。至于boost庫的編譯使用另請參考其他的文章。

????? 下面是ipv4_header.hpp：

//
// ipv4_header.hpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef IPV4_HEADER_HPP
#define IPV4_HEADER_HPP#include <algorithm>
#include <boost/asio/ip/address_v4.hpp>// Packet header for IPv4.
//
// The wire format of an IPv4 header is:
// 
// 0               8               16                             31
// +-------+-------+---------------+------------------------------+      ---
// |       |       |               |                              |       ^
// |version|header |    type of    |    total length in bytes     |       |
// |  (4)  | length|    service    |                              |       |
// +-------+-------+---------------+-+-+-+------------------------+       |
// |                               | | | |                        |       |
// |        identification         |0|D|M|    fragment offset     |       |
// |                               | |F|F|                        |       |
// +---------------+---------------+-+-+-+------------------------+       |
// |               |               |                              |       |
// | time to live  |   protocol    |       header checksum        |   20 bytes
// |               |               |                              |       |
// +---------------+---------------+------------------------------+       |
// |                                                              |       |
// |                      source IPv4 address                     |       |
// |                                                              |       |
// +--------------------------------------------------------------+       |
// |                                                              |       |
// |                   destination IPv4 address                   |       |
// |                                                              |       v
// +--------------------------------------------------------------+      ---
// |                                                              |       ^
// |                                                              |       |
// /                        options (if any)                      /    0 - 40
// /                                                              /     bytes
// |                                                              |       |
// |                                                              |       v
// +--------------------------------------------------------------+      ---class ipv4_header
{
public:ipv4_header() { std::fill(rep_, rep_ + sizeof(rep_), 0); }unsigned char version() const { return (rep_[0] >> 4) & 0xF; }unsigned short header_length() const { return (rep_[0] & 0xF) * 4; }unsigned char type_of_service() const { return rep_[1]; }unsigned short total_length() const { return decode(2, 3); }unsigned short identification() const { return decode(4, 5); }bool dont_fragment() const { return (rep_[6] & 0x40) != 0; }bool more_fragments() const { return (rep_[6] & 0x20) != 0; }unsigned short fragment_offset() const { return decode(6, 7) & 0x1FFF; }unsigned int time_to_live() const { return rep_[8]; }unsigned char protocol() const { return rep_[9]; }unsigned short header_checksum() const { return decode(10, 11); }boost::asio::ip::address_v4 source_address() const{boost::asio::ip::address_v4::bytes_type bytes= { { rep_[12], rep_[13], rep_[14], rep_[15] } };return boost::asio::ip::address_v4(bytes);}boost::asio::ip::address_v4 destination_address() const{boost::asio::ip::address_v4::bytes_type bytes= { { rep_[16], rep_[17], rep_[18], rep_[19] } };return boost::asio::ip::address_v4(bytes);}friend std::istream& operator>>(std::istream& is, ipv4_header& header){is.read(reinterpret_cast<char*>(header.rep_), 20);if (header.version() != 4)is.setstate(std::ios::failbit);std::streamsize options_length = header.header_length() - 20;if (options_length < 0 || options_length > 40)is.setstate(std::ios::failbit);elseis.read(reinterpret_cast<char*>(header.rep_) + 20, options_length);return is;}private:unsigned short decode(int a, int b) const{ return (rep_[a] << 8) + rep_[b]; }unsigned char rep_[60];
};#endif // IPV4_HEADER_HPP

?????? 下面是icmp_header.hpp：

//
// icmp_header.hpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef ICMP_HEADER_HPP
#define ICMP_HEADER_HPP#include <istream>
#include <ostream>
#include <algorithm>// ICMP header for both IPv4 and IPv6.
//
// The wire format of an ICMP header is:
// 
// 0               8               16                             31
// +---------------+---------------+------------------------------+      ---
// |               |               |                              |       ^
// |     type      |     code      |          checksum            |       |
// |               |               |                              |       |
// +---------------+---------------+------------------------------+    8 bytes
// |                               |                              |       |
// |          identifier           |       sequence number        |       |
// |                               |                              |       v
// +-------------------------------+------------------------------+      ---class icmp_header
{
public:enum { echo_reply = 0, destination_unreachable = 3, source_quench = 4,redirect = 5, echo_request = 8, time_exceeded = 11, parameter_problem = 12,timestamp_request = 13, timestamp_reply = 14, info_request = 15,info_reply = 16, address_request = 17, address_reply = 18 };icmp_header() { std::fill(rep_, rep_ + sizeof(rep_), 0); }unsigned char type() const { return rep_[0]; }unsigned char code() const { return rep_[1]; }unsigned short checksum() const { return decode(2, 3); }unsigned short identifier() const { return decode(4, 5); }unsigned short sequence_number() const { return decode(6, 7); }void type(unsigned char n) { rep_[0] = n; }void code(unsigned char n) { rep_[1] = n; }void checksum(unsigned short n) { encode(2, 3, n); }void identifier(unsigned short n) { encode(4, 5, n); }void sequence_number(unsigned short n) { encode(6, 7, n); }friend std::istream& operator>>(std::istream& is, icmp_header& header){ return is.read(reinterpret_cast<char*>(header.rep_), 8); }friend std::ostream& operator<<(std::ostream& os, const icmp_header& header){ return os.write(reinterpret_cast<const char*>(header.rep_), 8); }private:unsigned short decode(int a, int b) const{ return (rep_[a] << 8) + rep_[b]; }void encode(int a, int b, unsigned short n){rep_[a] = static_cast<unsigned char>(n >> 8);rep_[b] = static_cast<unsigned char>(n & 0xFF);}unsigned char rep_[8];
};template <typename Iterator>
void compute_checksum(icmp_header& header,Iterator body_begin, Iterator body_end)
{unsigned int sum = (header.type() << 8) + header.code()+ header.identifier() + header.sequence_number();Iterator body_iter = body_begin;while (body_iter != body_end){sum += (static_cast<unsigned char>(*body_iter++) << 8);if (body_iter != body_end)sum += static_cast<unsigned char>(*body_iter++);}sum = (sum >> 16) + (sum & 0xFFFF);sum += (sum >> 16);header.checksum(static_cast<unsigned short>(~sum));
}#endif // ICMP_HEADER_HPP

?