示例#1
0
 def run(self):
     names.append(self.getName())
     transmitter_socket = socket.socket()
     transmitter_socket = SDPTPTC.fail_repeat_connector(
         transmitter_socket, self.address, self.port,
         self.receiver_identity)
     commands.append("#{0}".format(self.receiver_identity))
     while True:
         while len(instructions) != 0:
             if instructions[0][0].startswith('#{0}'.format(
                     self.receiver_identity)):
                 split_instruction = (instructions.pop(0)[0]).split(' ', 1)
                 message = SDPTPTC.encode(
                     self.key, (identity + ': ' + split_instruction[1]))
                 transmitter_socket.send(message.encode())
示例#2
0
 def run(self):
     transmitter_socket = socket.socket()
     transmitter_socket = SDPTPTC.fail_repeat_connector(
         transmitter_socket, self.address, self.port,
         self.receiver_identity)
     connection_live = True
     connections.append([self.address, self.receiver_identity])
     update_list.append([self.getName(), False])
     index = update_list.index([self.getName(), False])
     connection_update()
     while connection_live:
         try:
             if update_list[index][1]:
                 print("Updating {0} @ {1}".format(self.receiver_identity,
                                                   self.address))
                 transmitter_socket.send(connections_transmission.encode())
                 update_list[index][1] = False
         except socket.error:
             print("Closing")
             connections[index] = ["", ""]
             update_list[index] = ["", False]
             connection_update()
             connection_live = False
             print("Closed")
         time.sleep(15)
示例#3
0
def server_connector():
    request = socket.socket()
    request = SDPTPTC.fail_repeat_connector(request, server_address, 6112,
                                            "Addressing Server")
    receiver_port = int((request.recv(128)).decode())
    request.send(identity.encode())
    request.shutdown(socket.SHUT_RDWR)
    request.close()
    addressing_receiver_thread = AddressingReceiver(receiver_port)
    addressing_receiver_thread.start()
示例#4
0
def conversation_starter(recipient, receiver_address, receiver_port,
                         sender_port, sender_identity, key):
    if recipient:
        receiver_address = receiver_address[0]
    elif not recipient:
        request = socket.socket()
        request = SDPTPTC.fail_repeat_connector(request, receiver_address,
                                                sender_port, sender_identity)
        sender_port = ports.get()
        request.send((str(sender_port) + ' ' + identity).encode())
        receiver_port = int((request.recv(128)).decode())
        key = SDPTPTC.key_generation_client(request)
        key = SDPTPTC.create_key(key)
        request.shutdown(socket.SHUT_RDWR)
        request.close()
    transmitter_thread = Transmitter(receiver_address, receiver_port,
                                     sender_identity, key)
    receiver_thread = Receiver(sender_port, key)
    transmitter_thread.start()
    receiver_thread.start()
示例#5
0
 def run(self):
     receiver_socket = socket.socket()
     receiver_socket.bind((home_address, self.port))
     receiver_socket.listen(5)
     while True:
         transmitter_socket, transmitter_address = receiver_socket.accept()
         while True:
             message = transmitter_socket.recv(4096).decode()
             if message != '':
                 print((SDPTPTC.decode(self.key, message) + '\t' +
                        str(time.ctime())))
示例#6
0
    def run(self):
        while running:
            request_handler_socket = socket.socket()
            request_sender_socket, request_sender_address = SDPTPTC.socket_binder(
                request_handler_socket, 5112, server_address)
            port = ports.get()
            request_sender_socket.send(str(port).encode())
            request_sender_information = request_sender_socket.recv(
                128).decode()
            request_sender_port = int(request_sender_information[0:4])
            request_sender_identity = request_sender_information[5:]
            numerical_key = SDPTPTC.key_generation_server(
                request_sender_socket)
            key = SDPTPTC.create_key(numerical_key)

            request_sender_socket.shutdown(socket.SHUT_RDWR)
            request_handler_socket.close()
            request_sender_socket.close()
            conversation_starter(True, request_sender_address,
                                 request_sender_port, port,
                                 request_sender_identity, key)
示例#7
0
    def run(self):
        while running:
            # Lock all threads which read from instructions

            instruction = input()
            if instruction[:3] in commands:
                if instruction.startswith('##C'):
                    instructions.append([instruction])
                    input_barrier.wait()
                elif instruction.startswith('##S'):
                    instructions.append([instruction])
                    input_barrier.wait()
                elif instruction.startswith('##T'):
                    SDPTPTC.table_printer(connections)
                elif instruction.startswith('##H'):
                    SDPTPTC.help_command()
                elif instruction.startswith('##I'):
                    SDPTPTC.who_am_i(identity, home_address, server_address)
                elif instruction.startswith('##F'):
                    length = len(instructions)
                    for index in range(length):
                        instructions.pop(index)
                    print("Instruction buffer cleared of {0} instructions".
                          format(length))
            elif instruction.startswith('#'):
                instructions.append([instruction])
示例#8
0
def initialisation():
    global s_g_primes
    s_g_primes = SDPTPTC.s_g_prime_generator()
    global home_address
    home_address = SDPTPTC.get_local_address()

    global ports
    ports = queue.Queue()
    for port in range(6113, 7112):
        ports.put(port)

    global connections
    connections = []

    global running
    running = True

    global update_list
    update_list = []

    global connections_transmission
    connections_transmission = ""
示例#9
0
    def run(self):
        while running:
            request_handler_socket = socket.socket()
            request_sender_socket, request_sender_address = SDPTPTC.socket_binder(
                request_handler_socket, 6112, home_address)
            port = ports.get()
            request_sender_socket.send(str(port).encode())
            request_sender_identity = request_sender_socket.recv(128).decode()
            request_sender_socket.shutdown(socket.SHUT_RDWR)

            request_handler_socket.close()
            request_sender_socket.close()
            conversation_starter(True, request_sender_address, port,
                                 request_sender_identity)
示例#10
0
def initialisation():
    global instructions
    instructions = []

    global identity
    identity = input("Please input identity")

    global home_address
    home_address = SDPTPTC.get_local_address()

    global running
    running = True

    global conditional
    conditional = threading.Condition()

    global ports
    ports = queue.Queue()
    for port in range(5113, 6112):
        ports.put(port)

    global names
    names = []

    global input_barrier
    input_barrier = threading.Barrier(2)

    global commands
    commands = ['##C', '##H', '##I', '##S', '##T', '##F']

    global connections
    connections = []

    global server_address
    server_address = input("Input addressing server address")
    if server_address == "0":
        server_address = home_address