Add python compatibility for 2 and 3 simultaneously

Author: AlexisTM

README.md

@@ -2,22 +2,26 @@
 
 [API Documentation](https://rawsocket-python.readthedocs.io/en/latest/api.html)
 
-Raw socket is a layer 2 python library for communication using the MAC addresses only. 
+Raw socket is a layer 2 python library for communication using the MAC addresses only.
 
 This allows you to create a custom made Ethernet/WiFi communication system which is **not** using IP nor TCP/UDP or to debug custom frames such as SERCOS III, Profibus, ARP, PTP, ...
 
 Python versions tested:
 
 - [x] 2.7.x
-- [ ] 3.5.x - Reimplement to_bytes for Socket.send
+- [x] 3.5.x
+- [x] 3.8.x
 
 OSes:
 
-- [ ] Linux 14.04
+- [x] Linux 14.04
 - [x] Linux 16.04
-- [ ] Linux 18.04
-- [ ] Windows 10
-- [ ] Mac OSX
+- [x] Linux 18.04
+- [x] Linux 20.04
+
+Not working on:
+- [ ] Windows 10 - Due to Raw socket limitation
+- [ ] Mac OSX - Due to implementation (can likely be made working)
 
 **Pros:**
 
@@ -36,7 +40,7 @@ OSes:
 - No encryption
 - No fragmentation
 - **Requires root**
-- MTU of 1500
+- MTU of 1500 (Ethernet frames)
 
 ## Installation
 
@@ -63,7 +67,7 @@ while True: print(sock.recv())"
 # Boo
 ```
 
-On the second computer over the same router:
+On **the second computer** over the same router (or same network on Zerotier):
 
 ```bash
 sudo python -c "from rawsocketpy import RawSocket; import time
@@ -81,7 +85,7 @@ from rawsocketpy import RawSocket
 
 # 0xEEFA is the ethertype
 # The most common are available here: https://en.wikipedia.org/wiki/EtherType
-# The full official list is available here: https://regauth.standards.ieee.org/standards-ra-web/pub/view.html#registries 
+# The full official list is available here: https://regauth.standards.ieee.org/standards-ra-web/pub/view.html#registries
 # Direct link: https://standards.ieee.org/develop/regauth/ethertype/eth.csv
 # You can use whatever you want but using a already use type can have unexpected behaviour.
 sock = RawSocket("wlp2s0", 0xEEFA)
@@ -127,7 +131,7 @@ class LongTaskTest(RawRequestHandler):
         print("End")
 
     def setup(self):
-        print("Begin") 
+        print("Begin")
 
 def main():
     rs = RawServer("wlp2s0", 0xEEFA, LongTaskTest)
@@ -161,7 +165,7 @@ class LongTaskTest(RawRequestHandler):
         print("End")
 
     def setup(self):
-        print("Begin") 
+        print("Begin")
 
 def main():
     rs = RawAsyncServerCallback("wlp2s0", 0xEEFA, LongTaskTest, callback)
@@ -175,7 +179,8 @@ if __name__ == '__main__':
 
 You are free to contribue, the following capabilities are welcome:
 
-- Windows compatibility
+- Windows compatibility (even possible?)
+- MacOS compatibility
 - More Python versions and OS tests
 - Bring a major refactor ;)
 

rawsocketpy/__init__.py

@@ -3,15 +3,16 @@
 
 """A Raw socket implementation allowing any ethernet type to be used/sniffed.
 
-If gevent is available, sockets are monkey patched and two additionnal asynchronous server implementations are available: :class:`RawAsyncServer`, :class:`RawAsyncServerCallback` 
+If gevent is available, sockets are monkey patched and two additionnal asynchronous server implementations are available: :class:`RawAsyncServer`, :class:`RawAsyncServerCallback`
 
 .. moduleauthor:: Alexis Paques <alexis.paques@gmail.com>
 """
 
 from __future__ import absolute_import
 from __future__ import print_function
 try:
-    from gevent import monkey; monkey.patch_all()
+    from gevent import monkey
+    monkey.patch_all()
     from .asyncserver import RawAsyncServer, RawAsyncServerCallback
 except ImportError:
     print("Gevent could not be loaded; the sockets will not be cooperative.")

rawsocketpy/asyncserver.py

@@ -5,6 +5,7 @@
 from .server import RawServer, RawServerCallback
 from gevent import pool, Greenlet
 
+
 class RawAsyncServer(RawServer):
     """
     Prefered server instead of RawServer.
@@ -13,20 +14,23 @@ class RawAsyncServer(RawServer):
     This will ensure you are not loosing data because the handler is too long.
     """
     pool = pool.Pool()
+
     def handle_handler(self, handler):
         """Add the Greenlet to the pool with ``handler.run()``, the function to run.
-        
+
         :param handler: The RawRequestHandler provided in the constructor
         :type handler: RawRequestHandler"""
         self.pool.start(Greenlet(handler.run))
 
+
 class RawAsyncServerCallback(RawServerCallback, RawAsyncServer):
     """
     Async server using :class:`gevent.Greenlet` in a :class:`gevent.pool` to allow asynchronous calls.
     """
+
     def handle_handler(self, handler):
         """Add the Greenlet to the pool with ``self.callback(handler, self)``: the function to run.
-        
+
         :param handler: The RawRequestHandler provided in the constructor
         :type handler: RawRequestHandler"""
         self.pool.start(Greenlet(self.callback, handler, self))

rawsocketpy/packet.py

@@ -4,13 +4,15 @@
 from __future__ import absolute_import
 from .util import to_str
 
+
 class RawPacket():
-    """RawPacket is the resulting data container of the RawSocket class. 
+    """RawPacket is the resulting data container of the RawSocket class.
 
     It reads raw data and stores the MAC source, MAC destination, the Ethernet type and the data payload.
 
     RawPacket.success is true if the packet is successfuly read.
     """
+
     def __init__(self, data):
         """A really simple class.
 
@@ -30,7 +32,7 @@ def __init__(self, data):
         """:description: Payload received
         :type: str or bytes or bytearray"""
         self.success = False
-        """:description: True if the packet has been successfully unmarshalled 
+        """:description: True if the packet has been successfully unmarshalled
         :type: bool"""
         try:
             self.dest, self.src, self.type = data[0:6], data[6:12], data[12:14]

rawsocketpy/server.py

@@ -6,15 +6,17 @@
 from .socket import RawSocket
 from .util import get_hw, to_bytes, protocol_to_ethertype
 
+
 class RawServer(object):
     """A **Blocking** base server implementation of a server on top of the RawSocket.
-    It waits for data, encapsulate the data in the RequestHandlerClass provided and blocks until the RequestHandlerClass run() function finishes.  
+    It waits for data, encapsulate the data in the RequestHandlerClass provided and blocks until the RequestHandlerClass run() function finishes.
 
-    :note: packet = recv() 
-           -> RequestHandlerClass(packet) 
+    :note: packet = recv()
+           -> RequestHandlerClass(packet)
            -> RequestHandlerClass.run()
            -> loop
     """
+
     def __init__(self, interface, protocol, RequestHandlerClass):
         """
 
@@ -50,11 +52,12 @@ def spin(self):
 class RawServerCallback(RawServer):
     """A blocking server implementation that uses a centralized callback. This is useful for a stateful server.
 
-    :note: packet = recv() 
-           -> RequestHandlerClass(packet, self) 
+    :note: packet = recv()
+           -> RequestHandlerClass(packet, self)
            -> callback(RequestHandlerClass, self)
            -> loop
     """
+
     def __init__(self, interface, protocol, RequestHandlerClass, callback):
         """
         :param interface: interface to be used.
@@ -68,7 +71,7 @@ def __init__(self, interface, protocol, RequestHandlerClass, callback):
         """
         self.callback = callback
         RawServer.__init__(self, interface, protocol, RequestHandlerClass)
-    
+
     def handle_handler(self, handler):
         """
         Overwritten: Calls callback(handler, self) instead.
@@ -77,9 +80,10 @@ def handle_handler(self, handler):
 
 
 class RawRequestHandler(object):
-    """The class that handles the request. 
+    """The class that handles the request.
     It has access to the packet and the server data.
     """
+
     def __init__(self, packet, server):
         self.packet = packet
         """:description: Packet received
@@ -91,17 +95,17 @@ def __init__(self, packet, server):
     def finish(self):
         """empty: To be **overwritten**"""
         pass
-    
+
     def setup(self):
         """empty: To be **overwritten**"""
         pass
 
     def handle(self):
         """empty: To be **overwritten**"""
         pass
-    
+
     def run(self):
-        """Run the request handling process: 
+        """Run the request handling process:
 
         try:
             * self.setup()

rawsocketpy/socket.py

@@ -2,17 +2,22 @@
 # -*- coding: utf-8 -*-
 
 from __future__ import absolute_import
-import socket, select, struct, time
+import socket
+import select
+import struct
+import time
 from .packet import RawPacket
 from .util import get_hw, to_str, protocol_to_ethertype, to_bytes
 
+
 class RawSocket(object):
     """RawSocket is using the socket library to send raw ethernet frames, using socket.RAW_SOCK
 
     It has a similar API to the socket library: send/recv/close/dup.
     """
-    BROADCAST = "\xff\xff\xff\xff\xff\xff"
+    BROADCAST = b"\xff\xff\xff\xff\xff\xff"
     """:description: Default MAC address: ``"\\xff\\xff\\xff\\xff\\xff\\xff"``"""
+
     def __init__(self, interface, protocol, sock=None, no_recv_protocol=False):
         """
 
@@ -25,7 +30,7 @@ def __init__(self, interface, protocol, sock=None, no_recv_protocol=False):
         :param no_recv_protocol: If true (default False), the socket will not subscribe to anything, recv will just block.
         :type no_recv_protocol: bool
         """
-        if  not protocol < 0xFFFF:
+        if not protocol < 0xFFFF:
             raise ValueError("Protocol has to be in the range 0 to 65535")
         self.no_recv_protocol = no_recv_protocol
         self.non_processed_protocol = protocol
@@ -63,9 +68,11 @@ def send(self, msg, dest=None, ethertype=None):
         :param ethertype: Allow to send data using a different ethertype using the same socket. Default is the protocol given in the constructor.
         :type ethertype: str/bytes/bytearray
         """
-        if ethertype is None: ethertype = self.ethertype
-        if dest is None: dest = self.BROADCAST
-        payload = dest + self.mac + ethertype + msg
+        if ethertype is None:
+            ethertype = self.ethertype
+        if dest is None:
+            dest = self.BROADCAST
+        payload = to_bytes(dest, self.mac, ethertype, msg)
         self.sock.send(payload)
 
     def recv(self):
@@ -77,6 +84,6 @@ def recv(self):
         """
         data = self.sock.recv(1024)
         return RawPacket(data)
-    
+
     def __str__(self):
         return self.interface