include/wipal/pcap/stream.hh

/*
 * 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_HH_
# define PCAP_STREAM_HH_

extern "C"
{
# include <inttypes.h>
}
# include <cstdlib>
# include <string>
# include <vector>

# include <wipal/pcap/pkt.hh>
# include <wipal/pcap/file_iterator.hh>

namespace wpl
{

  namespace pcap
  {

    template <class D>
    struct file;

    template <class D>
    struct indexed_file;

  } // End of namespace wpl::pcap.

  namespace tool
  {

    template <class B>
    struct types< pcap::file<B> >
    {
      typedef WP_GET_EXACT(B, pcap::file<B>)                    exact_type;
      typedef pcap::internals::file_iterator<exact_type>        iterator;
    };

    template <class B>
    struct types< pcap::indexed_file<B> >
    {
      typedef WP_GET_EXACT(B, pcap::indexed_file<B>)            exact_type;
      typedef pcap::internals::file_iterator<exact_type>        iterator;
    };

  } // End of namespace wpl::tool.

  namespace pcap
  {

    template <class Bottom>
    struct stream: WP_INHERIT(public pkt::stream, stream<Bottom>)
    {
      int32_t           zone() const;

      int32_t           snaplen() const;
    };

    template <class Bottom>
    struct istream: WP_INHERIT(public stream, istream<Bottom>)
    {
      typedef WP_GET_EXACT(Bottom, istream<Bottom>)     exact_type;
      typedef stream<exact_type>                        super_type;
      typedef WP_TYPE(iterator, exact_type)             iterator;
      typedef iterator                                  const_iterator;

      istream(std::istream* const is);

      std::ostream&     print_impl(std::ostream&) const;

      bool              swapped_impl() const;
      pkt::type         type_impl() const;
      int32_t           zone_impl() const;
      int32_t           snaplen_impl() const;

    private:
      bool              swap_;
      pkt::type         type_;
      int32_t           zone_;
      int32_t           snaplen_;
    };

    template <class Bottom = tool::bottom>
    struct file: WP_INHERIT(public istream, file<Bottom>)
    {
      typedef WP_GET_EXACT(Bottom, file<Bottom>)        exact_type;
      typedef istream<exact_type>                       super_type;

      file(const std::string& filename);

      std::ifstream*            stream(bool seek = true) const;

      std::streampos            filesize() const;

      const std::string&        filename() const;

      std::ostream&                     print_impl(std::ostream&) const;

    private:
      std::string       filename_;
      std::streampos    filesize_;
    };

    template <class Bottom = tool::bottom>
    struct indexed_file: WP_INHERIT(public file, indexed_file<Bottom>)
    {
      typedef WP_GET_EXACT(Bottom, indexed_file<Bottom>)        exact_type;
      typedef file<exact_type>                                  super_type;
      typedef WP_TYPE(iterator, exact_type)                     iterator;

      typedef std::vector<std::streampos>               index_type;

      enum
      {
        mark_step       = 4,

        junk_len        = 4096
      };

      indexed_file(const std::string& filename);

      indexed_file(const std::string&   filename,
                   const index_type&    marks,
                   unsigned             size);

      template <typename ProgressInfoSetupType,
                typename ProgressInfoUpdateType>
      indexed_file(const std::string&           filename,
                   ProgressInfoSetupType&       pi_setup,
                   ProgressInfoUpdateType&      pi_update);

      iterator  operator [] (size_t);

      size_t    size() const;

    protected:
      void      warn(const std::streampos& pos, const std::string& msg);
      void      handle_truncation(const std::string& msg);

    private:
      template <typename ProgressInfoSetupType,
                typename ProgressInfoUpdateType>
      void
      setup(ProgressInfoSetupType&      pi_setup,
            ProgressInfoUpdateType&     pi_update);

      index_type        marks_;
      size_t            size_;
    };

  } // End of namespace wpl::pcap.

} // End of namespace wpl.

# include "stream.hxx"

#endif // ! PCAP_STREAM_HH_

---