Merge remote-tracking branch 'origin/master'

Author: Francesco Mecatti

OtherSocketExamples/asyncio_stream_simple_server.py

@@ -0,0 +1,90 @@
+import argparse
+import logging
+import threading
+import asyncio
+import sys
+
+"""
+Connect to this server using netcat or similar utilities
+"""
+
+HOST, PORT = "127.0.0.1", 9999
+
+# TODO: mantieni numero di client connessi e ritorna lista con indirizzi
+# TODO: trasforma write in writelines e termina con \n
+# TODO: usa readline e termina comando con \n
+
+
+def handle_command(cmd: str, client_stream: asyncio.StreamWriter):
+    if not cmd: return
+    if cmd == '0':
+        return f"Client address: {client_stream.get_extra_info('peername')}\n"
+    elif cmd == '1':
+        return f"Socket address: {client_stream.get_extra_info('sockname')}\n"
+    elif cmd == '2':
+        return f"Current thread name: {threading.current_thread().getName()}\n"
+    elif cmd == '3':
+        return f"Alive threads number: {threading.active_count()}\n"
+    elif cmd == '4':
+        return f"Alive threads: {[t.getName() for t in threading.enumerate()]}\n"
+    else:  # Help
+        return """'0': Return the remote address (client) to which the socket is connected;
+'1': Return the server socket's own address;
+'2': Return the current thread name;
+'3': Return the number of alive threads;
+'4': Return the list of names of alive threads (comma separated);
+'q': Quit server when all the clients will be disconnected;
+"""
+
+
+async def server_handler(reader, writer):
+    addr = writer.get_extra_info('peername')
+    logging.info(f"Serving {addr}")
+    while True:
+        writer.write(">> ".encode())
+        await writer.drain()
+        try:
+            data = await reader.read(1024)
+        except ConnectionResetError:
+            logging.error(f"Closed connection - Reset Connection Error: {addr}")
+            break
+        cmd = data.decode().strip()
+
+        logging.info(f"Received {cmd} from {addr}")
+
+        if not cmd:
+            writer.close()
+            break
+        elif cmd == 'q':
+            logging.warning(f"Closed connection: {addr}")
+            writer.close()
+            break
+        else:
+            writer.write(handle_command(cmd, writer).encode())  # TODO: writeline
+            await writer.drain()
+
+
+async def main():
+    global HOST, PORT
+    logging.basicConfig(level=logging.DEBUG, format="%(threadName)s --> %(asctime)s - %(levelname)s: %(message)s",
+                        datefmt="%H:%M:%S")
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-a", "--address", help="host address", default=HOST, type=str, dest="address")
+    parser.add_argument("-p", "--port", help="port number", default=PORT, type=int, dest="port")
+    args = parser.parse_args()  # TODO: non funzionante con asyncio
+    PORT = args.port
+    HOST = args.address
+
+    logging.info(f"Server running on {HOST}:{PORT}...")
+
+    server = await asyncio.start_server(server_handler, HOST, PORT)
+
+    async with server:
+        await server.serve_forever()
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logging.warning("Server stopping...")

OtherSocketExamples/multithreaded_simple_server.py

@@ -6,6 +6,7 @@
 """
 Connect to this server using netcat or similar utilities
 """
+# TODO: termina con \n --> adatta ricezione e trasmissione
 
 # '0': Return the remote address (client) to which the socket is connected;
 # '1': Return the server socket's own address;
@@ -19,10 +20,14 @@
 
 
 def client_handle(conn, addr):
-    logging.info(f"New connection {addr}".encode())
+    logging.info(f"New connection {addr}")
     while True:
         conn.sendall(">> ".encode())
-        data = conn.recv(1024).decode()  # command
+        try:
+            data = conn.recv(1024).decode()  # command
+        except ConnectionResetError:
+            logging.error(f"Closed connection - Reset Connection Error: {addr}")
+            break
         cmd = data[0]
         logging.debug(f"Received: {cmd}")
         if not cmd: break

OtherSocketExamples/select_simple_server.py

@@ -4,13 +4,18 @@
 from select import select
 from collections import defaultdict
 import threading
+import sys
 
 """
 Connect to this server using netcat or similar utilities
 """
 
 HOST, PORT = "127.0.0.1", 9999
 
+# TODO: mantieni numero e lista client connessi
+# TODO: sistema socket asincrono con sendall --> fai send e togli quello che ha inviato
+# TODO: termina con \n --> adatta ricezione e trasmissione
+
 
 def handle_command(cmd: str, server_sock: socket, client_sock: socket):
     if not cmd: return
@@ -107,6 +112,7 @@ def main():
         logging.warning("Server stopping...")
     finally:
         server_sock.close()
+        sys.exit()
 
 
 if __name__ == "__main__":

OtherSocketExamples/socketserver_simple_server.py

@@ -9,14 +9,19 @@
 
 HOST, PORT = "127.0.0.1", 9999
 
+# TODO: termina con \n --> adatta ricezione e trasmissione
 
 class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
 
     def handle(self):
         logging.info(f"New connection {self.client_address}".encode())
         while True:
             self.request.sendall(">> ".encode())
-            data = self.request.recv(1024).decode()  # command
+            try:
+                data = self.request.recv(1024).decode()  # command
+            except ConnectionResetError:
+                logging.error(f"Closed connection - Reset Connection Error: {self.client_address}")
+                break
             cmd = data[0]
             logging.debug(f"Received: {cmd}")
             if not cmd: break

ProtocolImplementation/ClientProtocolImplementation/ClientProtocol.py

@@ -1,20 +1,22 @@
 import os
-from ProtocolImplementation.Protocol import DIMBYTESNUM, BUFFSIZENUM, CODEBYTES, StatusHandler
+from ProtocolImplementation.Protocol import DIMBYTESNUM, BUFFSIZENUM, CODEBYTES, StatusHandler, ReliableTransmission
 import socket
 from typing import BinaryIO
 
 
 class ProtocolHandler:
-    def __init__(self, s: socket):
-        self.s: socket = s
+    def __init__(self, s: socket.socket):
+        self.s: socket.socket = s
         self.status_handler = StatusHandler(self.s)
 
     def input(self):
         try:
-            text = self.s.recv(BUFFSIZENUM).decode()
+            text = ReliableTransmission.recvstring(self.s)
             self.status_handler.ok()
             self.status_handler.response()
-            self.s.sendall(input(text)[:BUFFSIZENUM].encode())
+            input_text = input(text)
+            input_text += "\n"
+            self.s.sendall(input().encode())
             if not self.status_handler.is_code("OK", self.s.recv(CODEBYTES)):
                 raise ConnectionError("Server not confirming")
             if not self.status_handler.is_code("End", self.s.recv(CODEBYTES)):
@@ -72,8 +74,8 @@ def upload_file(self, file: BinaryIO, size: int):  # size [bytes]
 
 
 class FileHandler:
-    def __init__(self, s: socket):
-        self.s: socket = s
+    def __init__(self, s: socket.socket):
+        self.s: socket.socket = s
         self.protocol_handler = ProtocolHandler(self.s)
         self.status_handler = StatusHandler(self.s)
 

ProtocolImplementation/Protocol.py

@@ -1,7 +1,9 @@
 import os
 import socket
 
-DIMBYTESNUM = 4
+# TODO: sanifica input utente in server --> togli . e / (tutti i caratteri che rendono possibile la navigazione tra cartelle) --> potrebbe rimanare stringa vuota
+
+DIMBYTESNUM = 5  # Can be represented up to 2^(5*8) b = 1 TB
 BUFFSIZENUM = 1024  # bytes
 CODEBYTES = 1
 
@@ -20,13 +22,13 @@
     "End": b'\x14',
     "SendBytes": b'\x15',
     "GetBytes": b'\x16',
-    }
+}
 
 
 class StatusHandler:
     Codes = ProtocolCodes
 
-    def __init__(self, s: socket):
+    def __init__(self, s: socket.socket):
         self.s = s
 
     def is_code(self, codename, value):  # Check if 'value' is equal to the code associated with codename
@@ -70,3 +72,42 @@ def error_file_too_large(self):
 
     def error_file_not_found(self):
         self.__send_code("FileNotFound")
+
+
+class ReliableTransmission:
+    @classmethod
+    def recvall(cls, s: socket.socket, size: int):  # TODO: usa yeld per ricevere dati fino a size
+        """
+        This method receives size bytes and then returns the received data
+
+        :param s: socket over which send data
+        :param size: number of bytes to receive
+        :return: received buffer
+        :rtype: bytes
+        """
+        received_bytes: int = 0
+        buf: bytes = bytes()
+        while received_bytes < size:
+            tmp = s.recv(BUFFSIZENUM)
+            received_bytes += len(tmp)
+            buf += received_bytes
+        return buf
+
+    @classmethod
+    def recvstring(cls, s: socket.socket, eot: str = "\n", encoding: str = "utf-8"):  # TODO: recvline, EOL
+        """
+        This method receives until eot occurs and then returns the received data
+
+        :param s: socket over which send data
+        :param eot: End-Of-Transmission character (1 byte-long)
+        :param encoding: used to decode received bytes
+        :return: received string (buffer decoded) without eot character
+        :rtype: str
+        """
+        eot = bytes(eot)
+        buf: bytes = bytes()
+        while True:
+            tmp = s.recv(1)
+            if eot in tmp: break
+            buf += tmp
+        return buf.decode(encoding)

ProtocolImplementation/ServerProtocolImplementation/ServerProtocol.py

@@ -8,8 +8,8 @@
 
 
 class ProtocolHandler:
-    def __init__(self, s: socket):
-        self.s: socket = s
+    def __init__(self, s: socket.socket):
+        self.s: socket.socket = s
         self.status_handler = StatusHandler(self.s)
 
     def close_connection(self):
@@ -91,7 +91,7 @@ def send_file(self, file, filename):
 
 
 class FileHandler:
-    def __init__(self, name, surname, s: socket):
+    def __init__(self, name, surname, s: socket.socket):
         self.name = name
         self.surname = surname
         self.path = os.path.join(os.getcwd(), f"{name}_{surname}")

client.py

@@ -5,7 +5,7 @@
 
 
 class UserHandler:
-    def __init__(self, s: socket):
+    def __init__(self, s: socket.socket):
         self.s = s
 
     def start(self):