include/wipal/pcap/file_iterator.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_FILE_ITERATOR_HXX_
# define PCAP_FILE_ITERATOR_HXX_

# include <boost/lexical_cast.hpp>

# include "file_iterator.hh"

# include <wipal/pcap/base.hh>
# include <wipal/tool/exceptions.hh>

namespace wpl
{

  namespace pcap
  {

    namespace internals
    {

      template <class S, class B>
      file_iterator<S, B>::file_iterator(const iterable_type&   stream,
                                         bool                   end):
        stream_ (&stream)
      {
        if (not end)
          {
            pos_ = sizeof (file_header);
            count_ = 0;
            increment();
          }
      }

      template <class S, class B>
      file_iterator<S, B>::file_iterator(const iterable_type&   stream,
                                         const std::streampos&  pos,
                                         unsigned               count,
                                         std::istream* const    istream):
        stream_ (&stream),
        input_ (istream),
        pos_ (pos),
        count_ (count)
      {
        increment();
      }

      template <class S, class B>
      file_iterator<S, B>::file_iterator(const file_iterator& it):
        stream_ (it.stream_)
      {
        if (it.value())
          {
            pos_ = it.pos_;
            count_ = it.count_;
            this->value() = it.value();
          }
      }

      template <class S, class B>
      file_iterator<S, B>&
      file_iterator<S, B>::operator = (const file_iterator& rhs)
      {
        if (&rhs == this)
          return *this;

        stream_ = rhs.stream_;
        input_.reset();
        if ((this->value() = rhs.value()))
          {
            pos_ = rhs.pos_;
            count_ = rhs.count_;
          }
        return *this;
      }

      template <class S, class B>
      bool
      file_iterator<S, B>::equal(const file_iterator& rhs) const
      {
        if (not rhs.value())
          return not this->value();
        return this->value() and pos_ == rhs.pos_;
      }

      template <class S, class B>
      void
      file_iterator<S, B>::increment()
      {
        try
          {
            increment_pcap();
          }
        catch (const tool::read_error&)
          {
            if (stream().eof())
              this->value() = boost::none_t ();
            else
              throw;
          }
      }

      template <class S, class B>
      std::istream&
      file_iterator<S, B>::stream()
      {
        if (not input_.get())
          {
            input_.reset(stream_->stream(false));
            if (not input_->seekg(pos_, std::ios::beg))
              throw tool::seek_error("Seek operation failed");
          }
        return *input_;
      }

      template <class S, class B>
      void
      file_iterator<S, B>::increment_pcap()
      {
        std::istream&           i = stream();
        file_frame_header       h;

        if (not i.read(reinterpret_cast<char*> (&h), sizeof (h)) or
            i.gcount() != sizeof (h))
          throw tool::read_error ("Unreadable packet header");
        pos_ += sizeof (h);

        const bool      swapped = stream_->swapped();
        const size_t    caplen = tool::extract_long_u(h.caplen, swapped);

        if (caplen > max_packet_size)
          throw tool::bad_file("Packet size too large to make sense (" +
                               boost::lexical_cast<std::string>(caplen) + ")");

        // FIXME: TODO: Implement caplen > value_type::max_size.
        assert(caplen <= value_type::max_size);

        const unsigned  id = ++count_;
        const unsigned  sec = (tool::extract_long_s(h.ts.tv_sec, swapped) +
                               stream_->zone());
        const unsigned  usec = tool::extract_long_s(h.ts.tv_usec, swapped);
        const size_t    len = tool::extract_long_u(h.len, swapped);

        boost::optional<value_type>&    v = this->value();

        if (not v or not v->unique())
          v = value_type (id, sec, usec, caplen, len, stream_);
        else
          {
            pkt::metadata& m = v->meta();

            m.id = id;
            m.ts.tv_sec = sec;
            m.ts.tv_usec = usec;
            m.caplen = caplen;
            m.len = len;
          }

        if (not i.read(static_cast<char*> (v->bytes()), caplen) or
            i.gcount() != std::streampos (caplen))
          throw tool::read_error ("Unreadable packet data");
        pos_ += caplen;
      }

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

  } // End of namespace wpl::pcap.

} // End of namespace wpl.

#endif // ! PCAP_FILE_ITERATOR_HXX_

---