예제 #1
0
 def accept(self):
     '''
     modified ssl.SSLSocket.accept() of ssl.py.
     '''
     #import pdb; pdb.set_trace()
     newsock, addr = socket.accept(self)
     self.logger.debug("Connection from {}".format(addr))
     self.logger.debug("begin SSL handshake")
     newsock = self.context.wrap_socket(
         newsock,
         do_handshake_on_connect=self.do_handshake_on_connect,
         suppress_ragged_eofs=self.suppress_ragged_eofs,
         server_side=True)
     self.logger.debug("end SSL handshake: ssl_ver={}({})".format(
         ssl.get_protocol_name(self.ssl_version), self.ssl_version))
     '''
     if not server_side:
         print(self.getpeercert())
         print(self.context.get_ca_certs())
     #print(self.context.check_hostname)
     #print(type(self.cipher()))
     #print(type(self.shared_ciphers()))
     #print(type(self.compression()))
     #print(self.context.session_stats())
     '''
     return newsock, addr
예제 #2
0
 def accept(self):
     newsock, addr = socket.accept(self)
     try:
         return (SSLSocket(newsock, keyfile=self.keyfile, certfile=self.certfile, server_side=True, cert_reqs=self.cert_reqs, ssl_version=self.ssl_version, ca_certs=self.ca_certs, ciphers=self.ciphers, do_handshake_on_connect=self.do_handshake_on_connect, suppress_ragged_eofs=self.suppress_ragged_eofs), addr)
     except socket_error as e:
         newsock.close()
         raise e
예제 #3
0
def waitConnect(socket, port=int(sys.argv[1])):
    socket.bind(('', port))
    socket.listen(1)

    con, client = socket.accept()
    print(client, " connected.")

    connected = True
def convProgress(socket):
	socket.listen(0)
	conn, addr = socket.accept()
	while 1:
		data = conn.recv(4096)
		if not data: break
		print data,
	sys.stderr.write("Progress thread exiting!!")
	socket.close()
예제 #5
0
파일: server.py 프로젝트: yawnnn/RSAChat
def accept_connections(socket):
    while True:
        conn, addr = socket.accept()
        clients[conn] = addr

        exchange_keys(conn)
        print('%s:%s has connected.' % (addr[0], addr[1]))
        send(conn, 'Enter your name')

        Thread(target=handle_client, args=(conn, )).start()
예제 #6
0
 def accept(self):
     """Accepts a new connection from a remote client, and returns
     a tuple containing that new connection wrapped with a server-side
     SSL channel, and the address of the remote client."""
     newsock, addr = socket.accept(self)
     try:
         return (SSLSocket(newsock, keyfile=self.keyfile, certfile=self.certfile, server_side=True, cert_reqs=self.cert_reqs, ssl_version=self.ssl_version, ca_certs=self.ca_certs, ciphers=self.ciphers, do_handshake_on_connect=self.do_handshake_on_connect, suppress_ragged_eofs=self.suppress_ragged_eofs), addr)
     except socket_error as e:
         newsock.close()
         raise e
예제 #7
0
def socketAccept(socket):
    """
    Waiting for a client accept at socket
    :param socket: listening socket
    :return: connection instance for connected client
    """
    print('waiting for a connection')
    connection, client_address = socket.accept()
    print('connection from', client_address)

    return connection
예제 #8
0
파일: ssl.py 프로젝트: maximerobin/Ufwi
    def accept(self):

        """Accepts a new connection from a remote client, and returns
        a tuple containing that new connection wrapped with a server-side
        SSL channel, and the address of the remote client."""

        newsock, addr = socket.accept(self)
        return (SSLSocket(newsock,
                          keyfile=self.keyfile,
                          certfile=self.certfile),
                addr)
예제 #9
0
    def accept(self):
        """Accepts a new connection from a remote client, and returns
        a tuple containing that new connection wrapped with a server-side
        SSL channel, and the address of the remote client."""

        newsock, addr = socket.accept(self)
        newsock = self.context.wrap_socket(newsock,
                    do_handshake_on_connect=self.do_handshake_on_connect,
                    suppress_ragged_eofs=self.suppress_ragged_eofs,
                    server_side=True)
        return newsock, addr
예제 #10
0
파일: ssl.py 프로젝트: alej0varas/pythones
    def accept(self):
        """Accepts a new connection from a remote client, and returns
        a tuple containing that new connection wrapped with a server-side
        SSL channel, and the address of the remote client."""

        newsock, addr = socket.accept(self)
        newsock = self.context.wrap_socket(newsock,
                    do_handshake_on_connect=self.do_handshake_on_connect,
                    suppress_ragged_eofs=self.suppress_ragged_eofs,
                    server_side=True)
        return newsock, addr
예제 #11
0
def echo_server(adress):
    sock = socket(AF_INET, SOCK_STREAM)
    sock.bind(adress)
    socket.listen(1)
    while True:
        client, addr = socket.accept()
        echo_client(client, addr)


# 需要重点强调的一点是,上面的例子仅仅是为了演示内置的open()函数的一个特性,并且也只适用于基于Unix的系统。
# 如果你想将一个类文件接口作用在一个套接字并希望你的代码可以跨平台,请使用套接字对象的makefile()方法。
# 但是如果不考虑可移植性的话,那上面的解决方案会比使用makefile()性能更好一点。
예제 #12
0
def LineSensor(socket):
    try:
        while True:
            print 'Waiting for connection to line sensor service...'
            # Waiting for connection. Once receiving a connection, the function accept() returns a separate
            # client socket for the subsequent communication. By default, the function accept() is a blocking
            # one, which means it is suspended before the connection comes.
            clientSocket, addr = socket.accept()
            print '...connected to line sensor service:', addr  # Print the IP address of the client connected with the server.
            start_time = datetime.now()
            next_time = datetime.now()
            lastCommand = ''
            while True:
                try:
                    #print("Line Sensor Loop")
                    score = line_follower.get_score()
                    #print("Score:", score)
                    if len(str(score)) > 0 and score != "None":
                        #print("Score found, passing to score tests")
                        pass
                    else:
                        #print("Score not found, continuing next iteration")
                        continue

                    if score == 1000 and lastCommand != '1000':
                        try:
                            print('Lap\n')
                            clientSocket.send(str(score) + ";")
                            lastCommand = '1000'
                            #print('Current Time', datetime.now())
                            #print('Next Time: ', (datetime.now() + timedelta(milliseconds=250)))
                            next_time = (datetime.now() +
                                         timedelta(milliseconds=250))
                        except Exception as e:
                            print(e)
                            raise
                    elif next_time < datetime.now() and score != -1:
                        try:
                            #print("Time to send new data", score)
                            if score <= 7:
                                lastCommand = score
                                clientSocket.send(str(score) + ";")
                                next_time = (datetime.now() +
                                             timedelta(milliseconds=250))
                        except Exception as e:
                            print(e)
                except Exception as e:
                    print(e)
    except Exception as e:
        print(e)
def start():
    socket.listen()
    print("Waiting for connections")
    while True:
        try:
            conn , addr = socket.accept()
            conn_list.append(conn)
            addr_list.append(addr)
            #threding rerun function with given args 
            Thread = threading.Thread(target=client_handler, args=(conn , addr))
            Thread.start()
        except Exception as e:
            print(e)
            break
예제 #14
0
def serve_socket(socket,
                 request_handler,
                 socket_reader=socket_read_json,
                 socket_writer=socket_write_json):
    """Serve a single request from the given socket. This is done as follows:
    1. A connection is accepted. If no connection request is received (timeout), returns None.
    2. Read the request using the given socket_reader.
    3. Invoke the given request_handler with the request.
    4. Extract the response and return value from the object returned by the request_handler.
    5. Write the response to the connection socket using the socket_writer.
    6. Return the return value extracted from the object returned by the request_handler.
    7. Close the socket in every case.

    Arguments:
    socket          -- A socket.socket like object. Must support the accept() method that should return a tuple
                       with the first object being a connection socket.
    request_handler -- A function that will handle the request received. This function should:
                       1. Accept one argument, the request object returned by the socket_reader.
                       2. Must return a HandlerResult or similar object that contains:
                        response     -- This is the response that is sent to the requester using the socket_writer.
                        return_value -- This is returned to the caller of this function.
                       The request_handler is called only when a request is received.

    Keyword Arguments:
    socket_reader   -- The function used to read a response from the socket.
    socket_writer   -- The function used to write the request to the socket.
    """
    connection_socket = None
    return_value = None

    try:
        logging.debug('Waiting for a connection...')
        connection_socket, _ = socket.accept()
        request = socket_reader(connection_socket)
        if request:
            logging.debug('Got the following request: {}'.format(request))
            handler_result = request_handler(request)
            socket_writer(connection_socket, handler_result.response)
            logging.debug('Sending the following response: {}'.format(
                handler_result.response))
            return_value = handler_result.return_value
    except timeout:
        logging.debug('Timed out waiting for connection.')
        pass
    finally:
        if connection_socket:
            connection_socket.close()

    return return_value
예제 #15
0
    def accept(self):
        """Accepts a new connection from a remote client, and returns
        a tuple containing that new connection wrapped with a server-side
        SSL channel, and the address of the remote client."""

        newsock, addr = socket.accept(self)
        return (SSLSocket(sock=newsock,
                          keyfile=self.keyfile, certfile=self.certfile,
                          server_side=True,
                          cert_reqs=self.cert_reqs,
                          ssl_version=self.ssl_version,
                          ca_certs=self.ca_certs,
                          do_handshake_on_connect=
                              self.do_handshake_on_connect),
                addr)
예제 #16
0
    def handle_connections(self):
        socket = self.__get_socket()
        socket.bind(self.__get_addr())
        socket.listen(2)
        print("Waiting for sender...")
        client, client_addr_sender = socket.accept()
        self.__set_client_addr_sender(client_addr_sender)
        print("%s:%s has connected as sender." % client_addr_sender)

        while True:

            msg = client.recv(self.__get_buf_size()).decode("utf8")
            self.put_message_on_queue(msg)
            if msg == "":
                # socket.close()
                break

        print("Waiting for receiver...")
        socket.listen(20)
        receiver, client_addr_receiver = socket.accept()
        self.__set_client_addr_receiver(client_addr_receiver)
        print("%s:%s has connected as receiver." % client_addr_receiver)

        self.send_data(receiver)
예제 #17
0
    def accept(self):
        """Accepts a new connection from a remote client, and returns
        a tuple containing that new connection wrapped with a server-side
        SSL channel, and the address of the remote client."""

        newsock, addr = socket.accept(self)
        return (SSLSocket(
            sock=newsock,
            keyfile=self.keyfile,
            certfile=self.certfile,
            server_side=True,
            cert_reqs=self.cert_reqs,
            ssl_version=self.ssl_version,
            ca_certs=self.ca_certs,
            do_handshake_on_connect=self.do_handshake_on_connect), addr)
예제 #18
0
    def accept(self):
        """
        Accepts a new connection from a remote client, and returns a tuple
        containing that new connection wrapped with a server-side secure
        channel, and the address of the remote client.
        """
        if not self.server_side:
            raise ValueError("can't accept in client-side mode")

        newsock, addr = socket.accept(self)
        newsock = self.context.wrap_socket(
            newsock,
            do_handshake_on_connect=self.do_handshake_on_connect,
            suppress_ragged_eofs=self.suppress_ragged_eofs,
            server_side=True)

        return newsock, addr
예제 #19
0
    def accept(self):
        """
        Accepts a new connection from a remote client, and returns a tuple
        containing that new connection wrapped with a server-side secure
        channel, and the address of the remote client.
        """
        if not self.server_side:
            raise ValueError("can't accept in client-side mode")

        newsock, addr = socket.accept(self)
        newsock = self.context.wrap_socket(
            newsock,
            do_handshake_on_connect=self.do_handshake_on_connect,
            suppress_ragged_eofs=self.suppress_ragged_eofs,
            server_side=True)

        return newsock, addr
예제 #20
0
 def accept(self):
     """Accepts a new connection from a remote client, and returns
     a tuple containing that new connection wrapped with a server-side
     SSL channel, and the address of the remote client."""
     newsock, addr = socket.accept(self)
     try:
         return (SSLSocket(
             newsock,
             keyfile=self.keyfile,
             certfile=self.certfile,
             server_side=True,
             cert_reqs=self.cert_reqs,
             ssl_version=self.ssl_version,
             ca_certs=self.ca_certs,
             ciphers=self.ciphers,
             do_handshake_on_connect=self.do_handshake_on_connect,
             suppress_ragged_eofs=self.suppress_ragged_eofs), addr)
     except socket_error as e:
         newsock.close()
         raise e
예제 #21
0
from socket import socket, AF_INET, SOCK_STREAM

sock = socket(AF_INET, SOCK_STREAM)
sock.bind(("localhost", 5505))
sock.listen(1)
while True:
    try:
        while self.running:
            try:
                c, addr = socket.accept()
                print("Connection accepted from " + repr(addr[1]))
                # do special stuff here...
                print("sending...")
                continue
            except (SystemExit, KeyboardInterrupt):
                print("Exiting....")
                service.stop_service()
                break
            except Exception as ex:
                print("======> Fatal Error....\n" + str(ex))
                print(traceback.format_exc())
                self.running = False
                service.stop_service()
                raise
    except (SystemExit, KeyboardInterrupt):
        print("Force Exiting....")
        service.stop_service()
        raise

def stop_service(self):
    """
예제 #22
0
        if player_index == 0:
            msg = players[1]
        else:
            msg = players[0]

        print("Server received: ", player)
        print("Server responded with: ", msg)
        # encodes string into a bytes object, security thing
        connection.sendall(pickle.dumps(msg))
    print("Lost connection")
    print("________________________________")
    connection.close()


def extract_meta_info_and_log(address):
    local_ip, port = extract_ip_and_port_as_string(address)
    print("Connected to local ip: " + local_ip + " on port: " + port)


def extract_ip_and_port_as_string(address):
    return address[0], str(address[1])


current_player = 1
while True:
    connection, address = socket.accept()
    extract_meta_info_and_log(address)
    start_new_thread(client_thread, (connection, current_player))
    current_player *= -1
socket.close()
예제 #23
0
파일: server.py 프로젝트: rlacherksu/ccasp
from django.conf import settings
from utils import sendMsg, recvMsg, abnormalShutdown
def server_port():
    return 12322

if __name__ == "__main__":
    # Create socket object
    socket = socket(AF_INET, SOCK_STREAM)
    # Bind socket to localhost on defined port
    socket.bind(('', server_port()))
    # Start listening
    socket.listen(0)
    
    while True:
        # Accept connections while server is alive
        conn, address = socket.accept()
        
        # Print connection information
        #print("Connection received from client address " + str(address[0]) + " on port " + str(address[1]))
        
        # Try to receive incoming message and starting time
        incomingMsg = recvMsg(conn)
        # Print message from client
        #print("Received from client: " + str(incomingMsg))

        ser = serial.Serial(settings.TTY_PORT, '9600', timeout=5)
        time.sleep(2)

        try:
            ser.write(str(incomingMsg))
        except:
예제 #24
0
from socket import AF_INET, SOCK_STREAM, socket

socket = socket(AF_INET, SOCK_STREAM)
socket.bind(('localhost', 10000))
socket.listen(1)

def client_thread(conn, addr):
    print("hello " + str(addr[1]))
    while True:
        message = conn.recv(16).decode()
        if(message):
            print(str(addr[1]) + ": " + message)
        else:
            break

while True:
    conn, addr = socket.accept()
    client_thread(conn, addr)
    conn.close()
    socket.close()
    #exit(0)
예제 #25
0
 def accept(self):
     (newsock, addr) = socket.accept(self)
     newsock = self.context.wrap_socket(newsock, do_handshake_on_connect=self.do_handshake_on_connect, suppress_ragged_eofs=self.suppress_ragged_eofs, server_side=True)
     return (newsock, addr)
예제 #26
0
    try:
        socket.bind(conn)
    except OSError:
        logger.critical(
            'La dirección no está disponible para ser usada como servidor')
        pause()
        sys.exit(1)
    except GAIError:
        logger.critical('No es una dirección válida.')
        pause()
        sys.exit(1)
    # Escuchar solamente una conexión.
    logger.info('Aceptando solamente una conexión')
    socket.listen(1)
    # Acceptar la conexión.
    c, ip = socket.accept()
    logger.debug('Conexión aceptada por: "%s:%d"', *ip)
else:
    logger.debug('Conectando como cliente a la dirección "%s:%d"', *conn)
    try:
        socket.connect(conn)  # Conectar como cliente.
    except OSError:
        logger.critical('Esta dirección no tiene servidor.')
        pause()
        sys.exit(1)

# Crear el protocolo.
logger.info('Creando el manejador para el protocolo NTP')
if server: t = Transfer(c)
else: t = Transfer(socket)
예제 #27
0
    def handle_single_peer(self, socket: socket, connPeerId: int,
                           queue: queue.Queue) -> None:
        """ Handles communication with a single socket.

        Args:
            socket: A configured TCP socket to the peer.
        """

        # Wait for peer to reconnect (peer will drop connection, then connect to new
        # peer specific port)
        while constants.FOREVER:
            try:
                conn, addr = socket.accept()
                # Thread only expect a single client.
                socket.close()
                break
            except timeout:
                # Repeat indefinitely.
                continue

        # Now peer has reconnected, send it its ID.
        conn.send(str(connPeerId).encode())
        conn.settimeout(constants.TCP_PEER_TIMEOUT_DURATION)

        msg_queue = []

        # Initial tracker-peer handshake
        try:
            # Get the IP & port that other peers can connect with
            utils.append_to_message_queue(msg_queue, conn)

            new_peer, peer_addr, port = utils.parse_new_peer_message(
                msg_queue.pop(0))
            self.queuey.add_peer(new_peer, (peer_addr, port))

            # Get Filename and sizefrom client
            utils.append_to_message_queue(msg_queue, conn)

            id, data = utils.parse_new_file_message(msg_queue.pop(0))
            # Update Chunky with new peer and new files.
            for file in data:
                _logger.warning(f"GETTING FILE: {file}")
                filename, chunks = file
                self.queuey.add_file(id, filename, chunks)
            self.printer.print_new_peer(id, data)

            # Send list of files, chunks, peers to peer.
            msg = utils.create_chunk_list_message(self.chunky.files)
            conn.send(msg)

            # Send list of peer -> (addr, port) to peer
            msg = utils.create_peer_list_message(self.queuey.peer_info)
            conn.send(msg)
        except UnexpectedMessageReceivedException as e:
            _logger.error(
                f"An error occurred in initial Peer-Tracker handshake. "
                f"Error: {str(e)}.")

        # Poll (until disconnection breaks loop)
        _logger.warning(f"{connPeerId} starting to loop")
        while constants.FOREVER:
            try:
                msg = conn.recv(constants.MAX_BUFFER_SIZE)
                if not msg:
                    raise timeout

                try:
                    msg_code = utils.parse_peer_message(msg)

                except UnexpectedMessageReceivedException as e:
                    _logger.error(
                        f"An unexpected Message was received from peer. "
                        f"Error: {str(e)}")

                _logger.warning(
                    f"{connPeerId} handling message: {msg_code}, {msg}")
                if msg_code == MessageCode.PEER_DISCONNECT:
                    try:
                        msg_int, msg_chunk = msg.decode().split(
                            constants.MESSAGE_SEPARATOR, 1)
                        peer_id = int(msg_chunk)
                    except ValueError:
                        _logger.error(
                            f"Peer Disconnect message has invalid payload: {msg_chunk}."
                        )
                        break

                    _logger.warning(f"Peer {peer_id} is disconnecting.")
                    self.queuey.disconnect(peer_id)
                    self.printer.print_peer_disconnect(
                        peer_id, self.chunky.get_peers_files(peer_id))
                    if peer_id == connPeerId:
                        socket.close()
                        return

                elif msg_code == MessageCode.PEER_ACQUIRED_CHUNK:
                    peer_id, filename, chunk = utils.parse_peer_acquired_chunk_message(
                        msg)
                    self.queuey.peer_acquired_chunk(connPeerId, filename,
                                                    chunk)
                    self.printer.print_peer_acquire_chunk(
                        connPeerId, chunk,
                        self.chunky.get_num_chunks(filename), filename)

                _logger.warning(f"{connPeerId} handling queue")
                msgs = utils.get_messages_from_queue(queue)
                for m in msgs:
                    _logger.warning(f"{connPeerId} sent message {m}.")
                    conn.send(m)
                if len(msgs) == 0:
                    _logger.warning(f"{connPeerId} queue empty.")

            except timeout:
                _logger.warning(f"{connPeerId} handling queue 2")
                # If messages to send to peer.
                msgs = utils.get_messages_from_queue(queue)
                for m in msgs:
                    _logger.warning(f"{connPeerId} sent message {m}.")
                    conn.send(m)
                if len(msgs) == 0:
                    _logger.warning(f"{connPeerId} queue empty.")

        _logger.error(f"TRACKER THREAD DONE: {connPeerId}")
예제 #28
0
 def accept(self):
     newsock, addr = socket.accept(self)
     return (SSLSocket(newsock, keyfile=self.keyfile, certfile=self.certfile, server_side=True, cert_reqs=self.cert_reqs, ssl_version=self.ssl_version, ca_certs=self.ca_certs, ciphers=self.ciphers, do_handshake_on_connect=self.do_handshake_on_connect, suppress_ragged_eofs=self.suppress_ragged_eofs), addr)
예제 #29
0
 def accept_clients(self, socket: socket) -> None:
     for _ in range(11):
         conn, _ = socket.accept()
         Thread(target=self.on_new_client, args=(conn, )).start()
예제 #30
0
def CarController(socket):
    while True:
        print 'Waiting for connection to car controller service...'
        # Waiting for connection. Once receiving a connection, the function accept() returns a separate
        # client socket for the subsequent communication. By default, the function accept() is a blocking
        # one, which means it is suspended before the connection comes.
        clientSocket, addr = socket.accept()
        print '...connected to car controller service:', addr  # Print the IP address of the client connected with the server.

        lastCmd = ''

        while True:
            msgs = ''
            recdata = clientSocket.recv(BUFSIZ)
            # Receive data sent from the client.
            # Analyze the command received and control the car accordingly.
            msgs = recdata.split(';')
            #print("Received", len(msgs), "new messages")
            for data in msgs:
                if not data:
                    break

                if lastCmd == data:
                    print("Last Command:", lastCmd, "Current Data:", data,
                          "Ignoring")
                    break

                if data == ctrl_cmd[0]:
                    print 'motor moving forward'
                    motor.forward()
                elif data == ctrl_cmd[1]:
                    print 'recv backward cmd'
                    motor.backward()
                elif data == ctrl_cmd[2]:
                    print 'recv left cmd'
                    car_dir.turn_left()
                elif data == ctrl_cmd[3]:
                    print 'recv right cmd'
                    car_dir.turn_right()
                elif data == ctrl_cmd[6]:
                    print 'recv home cmd'
                    car_dir.home()
                elif data == ctrl_cmd[4]:
                    print 'recv stop cmd'
                    motor.ctrl(0)
                elif data == ctrl_cmd[5]:
                    print 'read cpu temp...'
                    temp = cpu_temp.read()
                    tcpCliSock.send('[%s] %0.2f' % (ctime(), temp))
                elif data[0:5] == 'speed':
                    #print data
                    numLen = len(data) - len('speed')
                    if numLen == 1 or numLen == 2 or numLen == 3:
                        tmp = data[-numLen:]
                        #print 'tmp(str) = %s' % tmp
                        spd = int(tmp)
                        #print 'spd(int) = %d' % spd
                        if spd < 24:
                            spd = 24
                        motor.setSpeed(spd)
                elif data[0:8] == 'network=':
                    print 'network =', data
                    spd = data.split('=')[1]
                    try:
                        spd = int(spd)
                        os.system('sudo tc qdisc del dev wlan0 root')
                        os.system(
                            'sudo tc qdisc add dev wlan0 root netem delay {0}ms'
                            .format(spd))
                    except:
                        print 'ERROR , speed =', spd
                elif data[0:7] == 'offset=':
                    print 'offset called, data = ', data
                    offset = int(data[7:]) + 28
                    car_dir.calibrate(offset)
                elif data[0:8] == 'forward=':
                    #print 'data =', data
                    spd = data.split('=')[1]
                    try:
                        spd = int(spd)
                        motor.setSpeed(spd)
                        motor.forward()
                    except:
                        print 'Error speed =', spd
                elif data[0:9] == 'backward=':
                    #print 'data =', data
                    spd = data.split('=')[1]
                    try:
                        spd = int(spd)
                        motor.setSpeed(spd)
                        motor.backward()
                    except:
                        print 'ERROR , speed =', spd

                else:
                    print 'Command Error! Cannot recognize command: ' + data
예제 #31
0
from socket import socket, AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
import pickle
from time import sleep

socket = socket(AF_INET, SOCK_STREAM)
socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
socket.bind(("", 2001))
socket.listen(2)
print("Server running...")

player1, player1_addr = socket.accept() # accept player1
print(f"{player1_addr[0]} has been connected")
player2, player2_addr = socket.accept() # accept player2
print(f"{player2_addr[0]} has been connected")

player1_win = False
player2_win = False

player1_shot = 0
player2_shot = 0

player1_coordinates = pickle.loads(player1.recv(1024)) # recv player1 ship coordinates
player2_coordinates = pickle.loads(player2.recv(1024)) # recv player2 ship coordinates


while True:
    # send ready to player1
    if player2_win:
        player1.send(pickle.dumps(["You lose", player1_shot, player2_shot]))
        player2.send(pickle.dumps(["You win", player1_shot, player2_shot]))
    else: