include/wipal/pcap/stream.hxx

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2007, 2008, 2009  Universite Pierre et Marie Curie - Paris 6
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA  02110-1301  USA
 *
 * Author: Thomas Claveirole <thomas.claveirole@lip6.fr>
 */
#ifndef PCAP_STREAM_HXX_
# define PCAP_STREAM_HXX_

# include <stdexcept>
# include <fstream>

# include <boost/scoped_ptr.hpp>

# include "stream.hh"

# include <wipal/tool/endianness.hh>
# include <wipal/tool/exceptions.hh>

namespace wpl
{

  namespace pcap
  {

    /*-------------.
    | pcap::stream |
    `-------------*/

    template <class B>
    int32_t
    stream<B>::zone() const
    {
      return this->exact().zone_impl();
    }

    template <class B>
    int32_t
    stream<B>::snaplen() const
    {
      return this->exact().snaplen_impl();
    }


    /*--------------.
    | pcap::istream |
    `--------------*/

    template <class B>
    istream<B>::istream(std::istream* const is)
    {
      internals::file_header            h;

      if (not *is)
        throw tool::file_error ("Open failed");
      if (not is->read(reinterpret_cast<char*> (&h), sizeof (h)) or
          is->gcount() != sizeof (h))
        throw tool::read_error ("Unreadable PCAP file header");
      switch (h.magic)
        {
        case 0xa1b2c3d4:
          swap_ = false;
          break;
        case 0xd4c3b2a1:
          swap_ = true;
          break;
        default:
          throw std::invalid_argument ("Not a PCAP trace");
        }

      if (tool::extract_short_u(h.version_major, swap_) !=
          internals::version_major)
        throw std::invalid_argument ("Invalid PCAP major version");
      if (tool::extract_short_u(h.version_minor, swap_) !=
          internals::version_minor)
        throw std::invalid_argument ("Invalid PCAP minor version");

      type_     = pkt::type (tool::extract_long_u(h.linktype, swap_));
      zone_     = tool::extract_long_s(h.thiszone, swap_);
      snaplen_  = tool::extract_long_u(h.snaplen, swap_);

      // Some traces advertised as Prism header do actually contain AVS
      // headers.  See
      // http://crawdad.cs.dartmouth.edu/wiki/pmwiki.php?n=Dataset.Ucsb-ietf2005
      if (type_ == pkt::PRISM_HEADER)
        {
          const const_iterator  b (this->exact(), sizeof (h), 0, is);

          if (b != this->end())
            {
              const unsigned    magic =
                tool::extract_big_endian_long_u(b->bytes());

              if ((magic & 0xFFFFFF00) == 0x80211000)
                type_ = pkt::IEEE802_11_RADIO_AVS;
            }
        }
    }

    template <class B>
    std::ostream&
    istream<B>::print_impl(std::ostream& os) const
    {
      return os << "std::istream@" << this;
    }

    template <class B>
    bool
    istream<B>::swapped_impl() const
    {
      return swap_;
    }

    template <class B>
    pkt::type
    istream<B>::type_impl() const
    {
      return type_;
    }

    template <class B>
    int32_t
    istream<B>::zone_impl() const
    {
      return zone_;
    }

    template <class B>
    int32_t
    istream<B>::snaplen_impl() const
    {
      return snaplen_;
    }


    /*-----------.
    | pcap::file |
    `-----------*/

    template <class B>
    file<B>::file(const std::string& filename):
      super_type (new std::ifstream (filename.c_str())),
      filename_ (filename)
    {
      std::ifstream     is (filename_.c_str());

      if (not is.seekg(0, std::ios::end))
        throw tool::seek_error ("Seek operation failed");
      filesize_ = is.tellg();
    }

    template <class B>
    std::ifstream*
    file<B>::stream(bool seek) const
    {
      std::ifstream* const r = new std::ifstream (filename_.c_str());

      if (not *r)
        throw tool::file_error ("Open failed.");
      if (seek and not r->seekg(sizeof (internals::file_header), std::ios::beg))
        throw tool::seek_error ("Seek operation failed");
      return r;
    }

    template <class B>
    std::streampos
    file<B>::filesize() const
    {
      return filesize_;
    }

    template <class B>
    const std::string&
    file<B>::filename() const
    {
      return filename_;
    }

    template <class B>
    std::ostream&
    file<B>::print_impl(std::ostream& os) const
    {
      return os << filename();
    }


    /*----------------.
    | Dummy callbacks |
    `----------------*/

    namespace internals
    {

      struct DummySetup
      {
        inline
        void
        operator () (std::streampos, std::streampos)
        {
        }
      };

      struct DummyUpdate
      {
        inline
        const std::string*
        operator () (std::streampos)
        {
          return 0;
        }
      };

    } // End of namespace wpl::pcap::internals.


    /*-------------------.
    | pcap::indexed_file |
    `-------------------*/

    template <class B>
    indexed_file<B>::indexed_file(const std::string& filename):
      super_type (filename)
    {
      internals::DummySetup     pi_setup;
      internals::DummyUpdate    pi_update;

      setup(pi_setup, pi_update);
    }

    template <class B>
    indexed_file<B>::indexed_file(const std::string&    filename,
                                  const index_type&     marks,
                                  unsigned              size):
      super_type (filename),
      marks_ (marks),
      size_ (size)
    {
    }

    template <class B>
    template <typename ProgressInfoSetupType,
              typename ProgressInfoUpdateType>
    indexed_file<B>::indexed_file(const std::string&            filename,
                                  ProgressInfoSetupType&        pi_setup,
                                  ProgressInfoUpdateType&       pi_update):
      super_type (filename)
    {
      setup(pi_setup, pi_update);
    }

    template <class B>
    typename indexed_file<B>::iterator
    indexed_file<B>::operator [] (size_t i)
    {
      const size_t      near_mark = i / mark_step;
      const size_t      extra_steps = i % mark_step;

      assert(i < size_);
      assert(near_mark < marks_.size());

      iterator          r (*this, marks_[near_mark], i - extra_steps);

      for (unsigned j = 0; j < extra_steps; ++j)
        {
          ++r;
          assert(r != this->end());
        }
      return r;
    }

    template <class B>
    size_t
    indexed_file<B>::size() const
    {
      return size_;
    }

    template <class B>
    void
    indexed_file<B>::warn(const std::streampos& p, const std::string& msg)
    {
      std::cerr << *this <<  ':' << p << ": WARNING: " << msg << '.'
                << std::endl;
    }

    template <class B>
    void
    indexed_file<B>::handle_truncation(const std::string& msg)
    {
      warn(this->filesize(), "corrupted file (" + msg + ')');
      if (not size_)
        throw std::invalid_argument ("Empty PCAP file");
      --size_;
    }

    template <class B>
    template <typename ProgressInfoSetupType,
              typename ProgressInfoUpdateType>
    void
    indexed_file<B>::setup(ProgressInfoSetupType&       pi_setup,
                           ProgressInfoUpdateType&      pi_update)
    {
# ifdef WP_TIME_PCAP_LOADING
      using namespace boost::posix_time;

      const ptime start = microsec_clock::universal_time();
# endif // WP_TIME_PCAP_LOADING

      boost::scoped_ptr<std::ifstream>  is (this->stream());
      internals::file_frame_header      h;

      size_ = 0;
      marks_.push_back(sizeof (internals::file_header));
      pi_setup(sizeof (internals::file_header), this->filesize());

      while (is->read(reinterpret_cast<char*> (&h), sizeof (h)))
        {
          if (is->gcount() != sizeof (h))
            {
              handle_truncation("truncated packet header");
              break;
            }

          char          junk[junk_len];

          h.caplen = tool::extract_long_u(h.caplen, this->swapped());
          while(h.caplen) // Skip packet data.
            {
              size_t    to_read = std::min(sizeof (junk), size_t (h.caplen));
              if (not is->read(junk, to_read))
                {
                  handle_truncation("truncated packet data");
                  break;
                }
              h.caplen -= to_read;
            }

          if (++size_ % mark_step == 0)
            {
              const std::streampos      current_offset = is->tellg();

              marks_.push_back(current_offset);
              if (const std::string* e = pi_update(current_offset))
                throw tool::user_interruption (*e);
            }
        }
      pi_update(this->filesize());
      if (is->bad())
        throw tool::file_error ("Unrecoverable corruption in PCAP file");

# ifdef WP_TIME_PCAP_LOADING
      std::cerr << (microsec_clock::universal_time() - start) << std::endl;
# endif // WP_TIME_PCAP_LOADING
    }

  } // End of namespace wpl::pcap.

} // End of namespace wpl;

#endif // ! PCAP_STREAM_HXX_

---