From 747afdd86973c43f41d778a847c6a9fcaaf919e2 Mon Sep 17 00:00:00 2001
From: Ingmar Steen <iksteen@gmail.com>
Date: Tue, 30 Sep 2014 16:51:37 +0200
Subject: [PATCH] Make R/W properties compatible with Python 2.5.

Change the @<property>.setter constructs to
<property> = property(getter, setter)
---
 src/pcappy/__init__.py | 72 +++++++++++++++++++++---------------------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/src/pcappy/__init__.py b/src/pcappy/__init__.py
index d625d9a..4e92a1e 100644
--- a/src/pcappy/__init__.py
+++ b/src/pcappy/__init__.py
@@ -482,27 +482,27 @@ def datalink_ext(self):
             raise PcapPyException(self.err)
         return r
 
-    @property
-    def datalink(self):
+    def get_datalink(self):
         r = pcap_datalink(self._p)
         if r == -1:
             raise PcapPyException(self.err)
         return r
 
-    @datalink.setter
-    def datalink(self, value):
+    def set_datalink(self, value):
         if pcap_set_datalink(self._p, value) < 0:
             raise PcapPyException(self.err)
 
-    @property
-    def snapshot(self):
+    datalink = property(get_datalink, set_datalink)
+
+    def get_snapshot(self):
         return pcap_snapshot(self._p)
 
-    @snapshot.setter
-    def snapshot(self, value):
+    def set_snapshot(self, value):
         if pcap_set_snaplen(self._p, value) < 0:
             raise PcapPyException(self.err)
 
+    snapshot = property(get_snapshot, set_snapshot)
+
     snaplen = snapshot
 
     def __del__(self):
@@ -584,21 +584,21 @@ def next(self):
 
         return self._parse_entry(ph, pd)
 
-    @property
-    def nonblock(self):
+    def get_nonblock(self):
         errbuf = create_string_buffer(PCAP_ERRBUF_SIZE)
         r = pcap_getnonblock(self._p, c_char_p((addressof(errbuf))))
         if r == -1:
             raise PcapPyException(errbuf.raw)
         return r
 
-    @nonblock.setter
-    def nonblock(self, value):
+    def set_nonblock(self, value):
         errbuf = create_string_buffer(PCAP_ERRBUF_SIZE)
         r = pcap_setnonblock(self._p, value, c_char_p((addressof(errbuf))))
         if r < 0:
             raise PcapPyException(errbuf.raw)
 
+    nonblock = property(get_nonblock, set_nonblock)
+
     @property
     def stats(self):
         ps = pcap_stat()
@@ -620,12 +620,10 @@ def stats(self):
             ps_ifdrop=ps.ps_ifdrop
         )
 
-    @property
-    def filter(self):
+    def get_filter(self):
         return self._bpf
 
-    @filter.setter
-    def filter(self, value):
+    def set_filter(self, value):
         if isinstance(value, basestring):
             self._bpf = self.compile(value)
         else:
@@ -633,6 +631,8 @@ def filter(self, value):
         if pcap_setfilter(self._p, pointer(self._bpf._bpf)) < 0:
             raise PcapPyException(self.err)
 
+    filter = property(get_filter, set_filter)
+
     @property
     def selectable_fd(self):
         return pcap_get_selectable_fd(self._p)
@@ -641,12 +641,10 @@ def selectable_fd(self):
     def can_set_rfmon(self):
         return pcap_can_set_rfmon(self._p) == 1
 
-    @property
-    def direction(self):
+    def get_direction(self):
         return self._direction
 
-    @direction.setter
-    def direction(self, value):
+    def set_direction(self, value):
         if value not in [PCAP_D_INOUT, PCAP_D_IN, PCAP_D_OUT]:
             raise ValueError(
                 'Must be either PCAP_D_INOUT (%s), PCAP_D_IN (%s), or PCAP_D_OUT (%s)' %
@@ -660,6 +658,8 @@ def direction(self, value):
             raise PcapPyException(self.err)
         self._direction = value
 
+    direction = property(get_direction, set_direction)
+
     @property
     def fileno(self):
         return pcap_fileno(self._p)
@@ -743,42 +743,42 @@ def activate(self):
     def device(self):
         return self._device
 
-    @property
-    def rfmon(self):
+    def get_rfmon(self):
         return self._rfmon
 
-    @rfmon.setter
-    def rfmon(self, value):
+    def set_rfmon(self, value):
         if pcap_set_rfmon(self._p, value) < 0:
             raise PcapPyException(self.err)
         self._rfmon = value
 
-    @property
-    def timeout(self):
+    rfmon = property(get_rfmon, set_rfmon)
+
+    def get_timeout(self):
         return self._timeout
 
-    @timeout.setter
-    def timeout(self, value):
+    def set_timeout(self, value):
         if pcap_set_timeout(self._p, value) < 0:
             raise PcapPyException(self.err)
         self._timeout = value
 
-    @property
-    def promisc(self):
+    timeout = property(get_timeout, set_timeout)
+
+    def get_promisc(self):
         return self._promisc
 
-    @promisc.setter
-    def promisc(self, value):
+    def set_promisc(self, value):
         if pcap_set_promisc(self._p, value) < 0:
             raise PcapPyException(self.err)
         self._promisc = value
 
-    @property
-    def buffer_size(self):
+    promisc = property(get_promisc, set_promisc)
+
+    def get_buffer_size(self):
         return self._buffer_size
 
-    @buffer_size.setter
-    def buffer_size(self, value):
+    def set_buffer_size(self, value):
         if pcap_set_buffer_size(self._p, value) < 0:
             raise PcapPyException(self.err)
         self._buffer_size = value
+
+    buffer_size = property(get_buffer_size, set_buffer_size)