Merge pull request #33 from mfontanini/sniffer-config-object

Sniffer config object

include/sniffer.h

@@ -45,6 +45,7 @@
 
 namespace Tins {
     class SnifferIterator;
+    class SnifferConfiguration;
 
     /**
      * \class BaseSniffer
@@ -238,17 +239,16 @@ namespace Tins {
          * Default constructor.
          */
         BaseSniffer();
-    
-        /**
-         * \brief Initialices this BaseSniffer.
-         * 
-         * \param phandle The pcap handle to be used for sniffing.
-         * \param filter The pcap filter which will be applied to the
-         * stream.
-         * \param if_mask The interface's subnet mask. If 0 is provided,
-         * then some IP broadcast tests won't work correctly.
-         */
-        void init(pcap_t *phandle, const std::string &filter, bpf_u_int32 if_mask);
+
+        void set_pcap_handle(pcap_t* const pcap_handle);
+
+        pcap_t* get_pcap_handle();
+
+        const pcap_t* get_pcap_handle() const;
+
+        void set_if_mask(bpf_u_int32 if_mask);
+
+        bpf_u_int32 get_if_mask() const;
     private:
         BaseSniffer(const BaseSniffer&);
         BaseSniffer &operator=(const BaseSniffer&);
@@ -264,12 +264,24 @@ namespace Tins {
      */
     class Sniffer : public BaseSniffer {
     public:
+        /**
+         * \deprecated
+         */
         enum promisc_type {
             NON_PROMISC,
             PROMISC
         };
 
         /**
+         * Constructs an instance of Sniffer.
+         *
+         * \param device The device which will be sniffed.
+         * \param configuration The configuration object to use to setup the sniffer.
+         */
+        Sniffer(const std::string &device, const SnifferConfiguration& configuration);
+
+        /**
+         * \deprecated
          * Constructs an instance of Sniffer.
          *
          * By default the interface won't be put into promiscuous mode, and won't
@@ -285,6 +297,7 @@ namespace Tins {
           bool promisc = false, const std::string &filter = "", bool rfmon = false);
 
         /**
+         * \deprecaetd
          * \brief Constructs an instance of Sniffer.
          *
          * The maximum capture size is set to 65535. By default the interface won't
@@ -297,9 +310,17 @@ namespace Tins {
          */
         Sniffer(const std::string &device, promisc_type promisc = NON_PROMISC, 
           const std::string &filter = "", bool rfmon = false);
+
     private:
-        void init_sniffer(const std::string &device, unsigned max_packet_size,
-          bool promisc = false, const std::string &filter = "", bool rfmon = false);
+        friend class SnifferConfiguration;
+
+        void set_snap_len(unsigned snap_len);
+
+        void set_buffer_size(unsigned buffer_size);
+
+        void set_promisc_mode(bool promisc_enabled);
+
+        void set_rfmon(bool rfmon_enabled);
     };
     
     /**
@@ -316,6 +337,15 @@ namespace Tins {
          * \param file_name The pcap file which will be parsed.
          * \param filter A capture filter to be used on the file.(optional);
          */
+        FileSniffer(const std::string &file_name, const SnifferConfiguration& configuration);
+
+        /**
+         * \deprecated
+         *
+         * \brief Constructs an instance of FileSniffer.
+         * \param file_name The pcap file which will be parsed.
+         * \param filter A capture filter to be used on the file.(optional);
+         */
         FileSniffer(const std::string &file_name, const std::string &filter = "");
     };
     
@@ -417,6 +447,106 @@ namespace Tins {
         Packet pkt;
     };
 
+    /** 
+     * \class SnifferConfiguration
+     * \brief Represents the configuration of a BaseSniffer object.
+     *
+     * This class can be used as an easy way to configure a Sniffer 
+     * or FileSniffer object.
+     *
+     * It can be used by constructing an object of this type, 
+     * setting the desired values and then passing it to the 
+     * Sniffer or FileSniffer object's constructor. 
+     * 
+     * For example:
+     *
+     * \code
+     * // Initialize the configuration.
+     * SnifferConfiguration config;
+     * config.set_filter("ip and port 80");
+     * config.set_promisc_mode(true);
+     * 
+     * // Use it on a Sniffer object.
+     * Sniffer sniffer("eth0", config);
+     * \endcode
+     */
+    class SnifferConfiguration {
+    public:
+        /**
+         * \brief The default snapshot length.
+         *
+         * This is 65535 by default.
+         */
+        static const unsigned DEFAULT_SNAP_LEN;
+
+        /**
+         * \brief The default timeout.
+         *
+         * This is 1000 by default.
+         */
+        static const unsigned DEFAULT_TIMEOUT;
+
+        /**
+         * Default constructs a SnifferConfiguration.
+         */
+        SnifferConfiguration();
+
+        /**
+         * Sets the snapshot length option.
+         * \param snap_len The snapshot length to be set.
+         */
+        void set_snap_len(unsigned snap_len);
+
+        /**
+         * Sets the buffer size option.
+         * \param buffer_size The buffer size to be set.
+         */
+        void set_buffer_size(unsigned buffer_size);
+
+        /**
+         * Sets the promiscuous mode option.
+         * \param enabled The promiscuous mode value.
+         */
+        void set_promisc_mode(bool enabled);
+
+        /**
+         * Sets a pcap filter to use on the sniffer.
+         * \param filter The pcap filter to be used.
+         */
+        void set_filter(const std::string& filter);
+
+        /**
+         * Sets the rfmon option.
+         * \param enabled The rfmon option value.
+         */
+        void set_rfmon(bool enabled);
+
+        /**
+         * Sets the timeout option.
+         * \param timeout The timeout to be set.
+         */
+        void set_timeout(unsigned timeout);
+    protected:
+        friend class Sniffer;
+        friend class FileSniffer;
+
+        void configure_sniffer_pre_activation(Sniffer& sniffer) const;
+        void configure_sniffer_pre_activation(FileSniffer& sniffer) const;
+
+        void configure_sniffer_post_activation(Sniffer& sniffer) const;
+
+        unsigned _snap_len;
+        bool _has_buffer_size;
+        unsigned _buffer_size;
+        bool _has_promisc;
+        bool _promisc;
+        bool _has_rfmon;
+        bool _rfmon;
+        bool _has_filter;
+        std::string _filter;
+        unsigned _timeout;
+    };
+
     template<class Functor>
     void Tins::BaseSniffer::sniff_loop(Functor function, uint32_t max_packets) {
         for(iterator it = begin(); it != end(); ++it) {