Beispiel #1
0
 def _socketRequest(self, scheme, host, port, payload):
     socket = self._getSocketForScheme(scheme)
     socket.connect((host, port))
     socket.sendall(payload)
     data = socket.recv(1024)
     socket.close()
     return data
def parse_sent_data(data, socket):
    if data[0:9] == 'userName/':
        # Username the client chose for himself
        user_connected = data[9:len(data)]
        dup = False
        # Check if it is a duplicate
        for key, val in user_dic:
            if user_dic[key, val] == user_connected:
                dup = True;
                break
        if (dup):
            socket.sendall(str("DUPNAME"))
            return None
        # Add to the client dicionary the userName as value and the sockname as key
        update_user_list(socket.getpeername(), user_connected)
        return None
    elif data[0:10] == '--userList':
        # User requested the user list of the site
        user_names_to_return = [];
        for (sock_String, port_value) in user_dic:
            user_names_to_return.append(user_dic[(sock_String, port_value)])
        socket.sendall(str(user_names_to_return))
        return None

    elif data == "CLOSEDCONNECTION":
        # Client has signaled it is disconnecting
        remove_client(socket)
        return None
    else:
        return data
Beispiel #3
0
    def _writeWrapper(self, socket, data):
        try:
            socket.sendall(bytes(data + "\r\n", 'utf-8'))

        except OSError:
            self.shutdown()
            raise
Beispiel #4
0
def sendAllInt(socket, integerData):
    try:
        strLen = struct.pack('i', integerData)
        socket.sendall(strLen)
    except socket.error as msg:
        return False
    return True
  def push(self, metrics, socket=None, logging_prefix=''):
    """
    :param metrics: An iterable of string, each repreasenting a metric data
    """
    """A list of strings representing metrics"""
    docs = list()
    for metric in metrics:

      if metric == 'version' and socket is not None:
        socket.sendall( (VERSION + '\n').encode() )

      line = self.parser.parse(metric, logging_prefix=logging_prefix)

      if line is None:
        continue

      self.lock.acquire()
      self.buffer.append({'_index': self.index,
                          '_type': line[0],
                          '_source': line[1]})

      current_time = time.time()
      if len(self.buffer) > self.buffer_size or (current_time - self.last_flush) > 60:
        self.flush()
        self.last_flush = current_time
      self.lock.release()
Beispiel #6
0
def mangodb(socket, address):
    socket.sendall('HELLO\r\n')
    client = socket.makefile()
    output = open(os.devnull, 'w')
    lock = threading.Lock()
    wait = threading.Condition(lock)
    while 1:
        line = client.readline()
        if not line:
            break
        cmd_bits = line.split(' ', 1)
        cmd = cmd_bits[0]
        if cmd == 'BYE':
            break
        if cmd == 'WAIT':
            wait.wait()
            continue
        if len(cmd_bits) > 1:
            lock.acquire(True)
            output.write(cmd_bits[1])
            if MANGODB_DURABLE:
                output.flush()
                os.fsync(output.fileno())
            data = '42' if MANGODB_EVENTUAL else \
                os.urandom(1024).encode('string-escape')
            lock.release()
            client.write('OK' + data + '\r\n')
        client.flush()
Beispiel #7
0
    def round(self, player, move):
        """ """
        if (move[0] == constants.QUIT):
            self.set_game_in_progress(False)
            #TODO: make something to the end of the game
        elif (move[0] == constants.CLICK):
            # verifies if is the player's turn
            if (player != self.get_player()):
                pass
            # verifies if is a empty square
            elif (self.board.getSquare(move[1]) != 0):
                pass
            else:
                try:
                    self.board.setSquare(move[1], self.player_indice + 1)
                    self.board.display()
                    msg = serialize.dumps((constants.DRAW, move[1], self.get_color()))
                    ignore, ready, ignore2 = select.select([], self.players, [], 0)

                    # checks if we have a winner
                    if self.end_game(move[1]):
                        self.set_game_in_progress(False)
                        print "end of the game"
                        # Draws the winner
                        msg = serialize.dumps((constants.WINNER, self.get_winner_coordinates(), self.get_color()))
                        ignore, ready, ignore2 = select.select([], self.players, [], 0)
                        for socket in ready:
                            socket.sendall(msg)
                    else:
                        for socket in ready:
                            socket.sendall(msg)
                        self.next_player()
                finally:
                    self.server.close()
Beispiel #8
0
def buildpath(socket, basedir, httpid):
    """Builds a directory path to a file from an HTTP request."""
    request = socket.recv(4096)
    print str(httpid) + " REQUEST"
    print "Request recieved: " + request

    reqlist = request.split()
    print "Request in list form: " + str(reqlist)
    print "Length of reqlist: " +  str(len(reqlist))

    if (len(reqlist) > 1):
        if (reqlist[0] == "GET"):
            endpath = reqlist[1]
            abspath = basedir + str(endpath)
            print "Full path constructed: " + str(abspath)
            print (endpath)
        else:
            socket.sendall("HTTP/1.0 400 Bad Request\r\n")
            socket.close
            abspath = None
    else:
        socket.sendall("HTTP/1.0 400 Bad Request\r\n")
        socket.close
        abspath = None

    return abspath
Beispiel #9
0
	def send_message(self, socket, data):
		try:
			socket.sendall(data)
		#except socket.error, e:
		except Exception, (error, message):
			print 'Error sending data. Exiting...'
			sys.exit()
Beispiel #10
0
 def serviceClientsOut(self):
     while 1:
         
         self.commandsEvent.wait()
         try:
             ###dispatch individual commands
             self.indivCommandsLock.acquire()
             while self.indivCommands:
                 self.socketsLock.acquire()
                 socket = self.sockets[self.indivCommands[0][0]]
                 socket.sendall(self.indivCommands[0][1]+self.term)
                 self.socketsLock.release()
                 self.indivCommands.pop(0)
             self.indivCommandsLock.release()           
             
             ### dispatch commands to each socket connected
             self.commandLock.acquire()
             while self.commands:
                 self.socketsLock.acquire()
                 for socket in self.sockets.values():
                     socket.sendall(self.commands[0]+self.term)
                 self.socketsLock.release()
                 if BotWars.DEBUG:
                     print "server send: "+self.commands[0]
                     pass
                 self.commands.pop(0)
             self.commandLock.release()
             self.commandsEvent.clear()
         ###capture disconnects and remove those sockets from the list
         ### release any locked locks
         ### kill service thread if no more sockets remain
         except error , se:
             self.handleError(socket)
Beispiel #11
0
  def sendRequest(self, socket):
      print "Sending request to server\n"
      HTTPcommand = sys.argv[3]
      filePath = sys.argv[4]
      if HTTPcommand in validHTTPRequestGet :
          socket.send(HTTPcommand + " " + filePath + " "+  HTTPprotocol + CRLF ) 
          size = 1024
          data = ""
          while True :
            recvBuffer = socket.recv(size)
            if recvBuffer == None or len(recvBuffer) == 0:
              break;
            data += recvBuffer

          socket.close() 
          print 'Received:', data
      elif HTTPcommand in validHTTPRequestPut:
          if filePath == "/" :
            filePath = "/index.html"
          fileHandler = open("../WebContent" + filePath, "r")
          print "Reading data from file to send payload to server\n"
          payload = fileHandler.read()
          fileHandler.close()
          putRequest =  HTTPcommand + " " + filePath + " " +  HTTPprotocol + CRLF + "Host: my simple client" + CRLF + CRLF +  "data=" + payload
          socket.sendall(putRequest)
          print "Sent data to server\n "

          socket.close()
      else:  
          print "Bad request"
          socket.close()
def send(socket, message):
	# Send the length of the message.
	# Should work as long as we send messages shorter than ~10 googol chars
	length = str(len(message)).encode('utf-8')
	socket.sendall(length)
	# Send the message
	socket.sendall(message.encode('utf-8'))
def send(request, socket):
    try:
        socket.sendall(request.encode('utf-8'))
        socket.sendall(b'\n')
    except Exception as e:
        service_down(message=str(e), exception=e)
        raise e
def checkConnection(socket) :    
    global username
    socket.sendall(SECURITY_PASS + '\n' + username)
    reply = socket.recv(1024)
    log('Received ' + reply)
    con = reply == OK_MESSAGE
    return con
Beispiel #15
0
def servicerequest(path, socket, httpid):
    """Services an HTTP request based on the provided file path"""

    if (os.path.exists(path)):
        print str(httpid) + " DELIVERED"
        fd = open(path, "r")
        file = fd.read()

        okmsg = "HTTP/1.0 200 OK\r\n"
        now = datetime.datetime.now()

        datestr = now.strftime("%a %d %B %Y %H:%M:%S %z") + "\r\n"

        print "Date and time: " + datestr

        server = "Server: Var http-server 1.0\r\n"
        connection = "Connection: close\r\n"
        content_length = "Content length: " + str(sys.getsizeof(file)) + "\r\n"
        content_type = "Content type: " + mimetypes.guess_type(path)[0] + "\r\n\r\n"

        print content_type
        print content_length

        header = datestr + server + connection + content_length + content_type

        socket.sendall(okmsg + header + file)
        socket.close()
    else:
        print str(httpid) + " NOTFOUND"
        socket.sendall("HTTP/1.0 404 Not Found\r\n")
        socket.close()
        print str(httpid) + " CLOSE"

    return None
Beispiel #16
0
 def sendFile(fname, socket):
     blockSize = 32000
     msg = ''
     try:
         source = open(fname, 'rb')
         sizeBytes = os.path.getsize(fname)
         utils.log('Sending file ' + fname + ' of ' + str(sizeBytes) + ' bytes')
         bytesOut = 0
         start = utils.getUTCTime()
         prev = 0
         for data in utils.chunked(source, blockSize):
             utils.log('sending data ' + str(len(data)))
             socket.sendall(data)
             bytesOut += len(data)
             if (bytesOut - sizeBytes) > 1024:
                 utils.log('WARNING - truncating send because send file appears to be growing.')
                 break;
             diff = utils.getSecondsBetweenTwoDates(start, utils.getUTCTime())
             diff = (int(diff/30))*30
             if diff > prev:
                 prev = diff
                 utils.log('So far sent ' + str(bytesOut) + ' read')
         utils.log('Completed send of ' + str(bytesOut) + ' bytes')
         
         socket.settimeout(20)
         c = socket.recv(4096)
         utils.log('Received ' + repr(c))
         return msg
     #except(socket.error):
         #utils.log("timeout in sendFile - possibly no received confirmation data")
     except Exception, errorcode:
         if errorcode[0] != "timed out":
             utils.logTrace('Exception ' + repr(errorcode))
Beispiel #17
0
 def client(self,socket,addr):
   infoName="SocketWriter-%s"%(unicode(addr),)
   self.setName("[%s]%s-Writer %s"%(AVNLog.getThreadId(),self.getName(),unicode(addr)))
   self.setInfo(infoName,"sending data",AVNWorker.Status.RUNNING)
   if self.getBoolParam('read',False):
     clientHandler=threading.Thread(target=self.clientRead,args=(socket, addr))
     clientHandler.daemon=True
     clientHandler.start()
   filterstr=self.getStringParam('filter')
   filter=None
   if filterstr != "":
     filter=filterstr.split(',')
   try:
     seq=0
     socket.sendall("avnav_server %s\r\n"%(VERSION))
     while True:
       hasSend=False
       seq,data=self.feeder.fetchFromHistory(seq,10)
       if len(data)>0:
         for line in data:
           if NMEAParser.checkFilter(line, filter):
             socket.sendall(line)
             hasSend=True
       else:
         time.sleep(0.1)
       pass
       if not hasSend:
         #just throw an exception if the reader potentially closed the socket
         socket.getpeername()
   except Exception as e:
     AVNLog.info("exception in client connection %s",traceback.format_exc())
   AVNLog.info("client disconnected")
   socket.close()
   self.removeHandler(addr)
   self.deleteInfo(infoName)
Beispiel #18
0
    def sokect_handler(self, socket, address):
        if self.debug and logger.is_debug():
            logger.get_logger().debug('%s: accept connection', address)

        # send welcome
        socket.sendall(Messager.data_for_welcome())
        conn_inbox = Queue()
        answer_thread = gevent.spawn(self.answer_fiber, socket, address, conn_inbox)
        while self._running:
            try:
                message = Messager.receive_msg(socket)
                if not message:
                    if self.debug and logger.is_debug():
                        logger.get_logger().debug('%s: connection has been closed by client.', address)
                    break;
                if isinstance(message, Answer):
                    logger.get_logger().error('%s: unexpected message received: %s', address, message)
                    continue
                elif isinstance(message, Query):
                    if self.debug and logger.is_debug():
                        logger.get_logger().debug('%s: message received: %s', address, message)
                    message.inbox = conn_inbox
                    self._query_queue.put(message)
            except gevent.socket.error as ex:
                logger.get_logger().error('%s: socket error: %s', address, repr(ex))
                break
            except:
                logger.get_logger().error('%s: exception: %s', address, traceback.format_exc())
                break

        if self.debug and logger.is_debug():
            logger.get_logger().debug('%s: close connection', address)
        socket.close()
        # stop answer thread
        conn_inbox.put(StopIteration)
    def POST(self, url, args=None):
        host, port, path = self.parse_url(url)
        socket = self.connect(host, port)

        if args == None:
            arguments = ""
        else:
            arguments = urllib.urlencode(args)

        request =  "POST %s HTTP/1.1\n" % path
        request += "Host: %s\n"         % host
        request += "Content-Type: application/x-www-form-urlencoded\n"
        request += "Content-Length: %s\n" % len(arguments)
        request += "Connection: close" + self.TERMINATE
        request += arguments + self.TERMINATE

        socket.sendall(request)
        response = self.recvall(socket)
        socket.close()

        code = self.get_code(response)
        #body = self.get_post_body(response, args)
        body = self.get_body(response)
        print response
        
        return HTTPRequest(code, body)
	def get_pending(self,socket) :
		
			header = self.get_header(14,701)
			socket.sendall(header)
			print "packet sent"
		
			header1 = socket.recv(14)  #recieve header packet
			size = header1[2:4] #size of whole packet= 14
			size = struct.unpack('h',size)
		
			msg = header1[4:6] #messagecode
			msg = struct.unpack('h',msg)
		
			print "receiving Pending Orders Start"
			print str(msg[0]) +" " + str(size[0])
			
			if msg[0] != 702 :
				print "Error in Pending Orders Start"
				return -1
		
		
			while True :
				header2 = socket.recv(14)
				size2 = header2[2:4] #size of whole packet= 14 +229
				size2 = struct.unpack('h',size2)

				msg2 = header2[4:6] #messagecode
				msg2 = struct.unpack('h',msg2)
			
				if msg2[0] == 704 :
					print msg2[0]
					print "Pending Orders Process End"
					return 0
				elif msg2[0] == 703:
					print "\n"
					#print " receiving Pending Orders Process"
				else :
					print msg2[0]
					print "Pending Orders Process Error"
					return 0
				
				packet = socket.recv(size2[0]-14) #recieve Order packet
				print "receiving Pending Orders Response"
			
				print str(msg2[0]) +" " + str(size2[0])
				print packet
				exch=packet[0:10] #0=14-14, 10=24-14
				exch = struct.unpack('10s', exch)[0]
		
				initqty=packet[130-14:134-14]
				initqty=struct.unpack('I', initqty)

				lprice=packet[142-14:150-14]
				lprice= struct.unpack('d', lprice)
		
				ordertype=packet[190-14:202-14]
				ordertype= struct.unpack('12s', ordertype)[0]
				print "\nSample::" + exch + " " + str(initqty[0])+" "+str(lprice[0]) +" " + ordertype
				print "=========================================================="
Beispiel #21
0
 def handler(self, socket, address):
     try:
         socket.sendall(self.policy)
         gevent.sleep(0.5)
     except Exception:
         pass
     finally:
         socket.close()
def sendAudio(socket,stream,CHUNK):

    frames = []

    while True :
      data  = stream.read(CHUNK)
      frames.append(data)
      socket.sendall(data)
 def handle_list_request(self, socket):
     """ envia a lista de arquivos disponíveis (como um objeto) """
     print "Enviando lista de arquivos a (%s:%s)" % socket.getpeername()
     # fazendo dump do objeto (serializando) para bytes
     list_dump = pickle.dumps(self.file_list, -1)
     socket.sendall(list_dump)
     # atendeu à requisição, fecha a conexão
     self.close_conn(socket)
	def test_connection(self, socket):
		result = True
		try:
			socket.sendall("test")
		except Exception as e:
			result = False

		return result
Beispiel #25
0
def send_http_error(socket, content, status=None):
    status = status or "500 Internal Error"
    data = """HTTP/1.1 {0}\r\nContent-Length: {1}\r\nConnection: close\r\n\r\n{2}
            """.format(
        status, len(str(content)), content
    ).strip()
    socket.sendall(data)
    socket.close()
    logging.debug("!{0}".format(content.lower()))
 def _set_cmdmanager_response(self, socket, message):
     """
     Makes cmd_manager response encoding it in json format and send it to cmd_manager
     """
     response = {'message': message}
     response_packet = json.dumps(response)
     socket.sendall(struct.pack('!i', len(response_packet)))
     socket.sendall(response_packet)
     return response_packet
def send(CONNECTION_LIST1, RaspServer,  sock, message):
	for socket in CONNECTION_LIST1:
		if socket != RaspServer:
			try:
				message = message.encode(encoding='UTF-8')
				socket.sendall(message)
			except:
				socket.close()
				CONNECTION_LIST1.remove(socket)
Beispiel #28
0
 def setspeed(self,socket,speed):
     if speed>=0 and speed<=3:
         self.cmd=b'\x99'
         self.datalen=1
         self.CMFrame(chr(1+int(speed)))
         socket.sendall(self.FullFrame())
         time.sleep(0.25)
         self.getfanconfig(socket)
     return self
Beispiel #29
0
 def sendMRLCOMMMsg(self, method, value):
   socket = bpy.mrl.virtualDevices[self.name].serialHandler.request
   print("sending bytes")
   print(bytes([170, method, 1, value]))
   # MRLCOMM PROTOCOL
   # MAGIC_NUMBER|NUM_BYTES|FUNCTION|DATA0|DATA1|....|DATA(N)
   #              NUM_BYTES - is the number of bytes after NUM_BYTES to the end
   
   socket.sendall(bytes([170, 2, method, value]))
Beispiel #30
0
def fun_sendall(sc,sock,msg):
    for socket in socket_list:
        if(socket != sc and socket != sock):
           try:
               socket.sendall(msg)
           except:
               socket.close()
               if(socket in socket_list):
                  print('rm user') 
                  socket_list.remove(socket)
Beispiel #31
0
 def receive_message(self, socket):
     """Read a socket for messages. Blocks, so only call if selected."""
     user = self.users[socket]
     # Throws IOError when client disconnects.
     message = socket.recv(BUF_SIZE).decode()
     if message == '':  # Empty message indicates closed socket.
         self.disconnect(socket)
     else:
         try:
             head, tail = decode_message(message)
         except ValueError:
             return
         if head == 'name':
             # TODO: Add a notification message for name change
             malt.log("Renaming {} to {}.".format(str(user), tail))
             user.name = tail
         elif head == 'message':
             self.record(user, tail)
             malt.log("{}: '{}'.".format(user.name, tail))
         elif head == 'read':
             malt.log("Reading messages to {}.".format(user.name))
             socket.sendall('\0'.join(user.pending).encode())
             user.pending = []
 def send_message(self, msg: bytes, send_to_hosts: bool,
                  is_control_channel: bool) -> None:
     if IGNORE_INPUT_DEVICES and not send_to_hosts and not is_control_channel and self.hid_devices is not None:
         asyncio.run_coroutine_threadsafe(
             self.hid_devices.send_message_to_devices(msg), loop=self.loop)
         return
     targets: List[BluetoothDevice] = self.__get_current_host_as_list(
     ) if send_to_hosts else self.connected_devices
     for target in list(targets):
         try:
             socket = target.control_socket if is_control_channel else target.interrupt_socket
             if socket is not None:
                 socket.sendall(msg)
         except Exception:
             print("Cannot send data to socket of ", target.object_path,
                   ". Closing")
             if target is not None:
                 try:
                     target.disconnect_sockets()
                 except:
                     print("Error while trying to disconnect sockets")
             asyncio.run_coroutine_threadsafe(
                 target.reconcile_connected_state(1), loop=self.loop)
Beispiel #33
0
def init_card(socket, socket1, socket2):

    SET = [0 for i in range(20)]
    SET1 = [0 for i in range(20)]
    SET2 = [0 for i in range(20)]

    for i in range(0, 17):
        SET[i] = POKER[i]  #poker的0到16号
        SET1[i] = POKER[i + 17]  #poker的17到34
        SET2[i] = POKER[i + 34]  #poker的34到51
    print('SET:')
    print(sorted(SET))
    print('SET1')
    print(sorted(SET1))
    print('SET2')
    print(sorted(SET2))
    json = {'status': 200, 'Operation': 'init', 'Card': [0], 'message': SET}
    json1 = {'status': 200, 'Operation': 'init', 'Card': [0], 'message': SET1}
    json2 = {'status': 200, 'Operation': 'init', 'Card': [0], 'message': SET2}

    socket.sendall(str.encode(str(json)))
    socket1.sendall(str.encode(str(json1)))
    socket2.sendall(str.encode(str(json2)))
Beispiel #34
0
    def kill_network(self, selector_obj):
        #kill switch for whole network -> ends Server [OPTIONAL] and all clients
        self.stream_print(
            "KILL SWITCH RECIEVED. NOTIFYING ALL SINKS AND SOURCES")
        msg = b'KILL STREAM'
        self.stream_print("\tNotifiying %d UNDECLARED sockets and removing" %
                          (len(self.undeclared_sockets)))
        while (len(self.undeclared_sockets) > 0):
            socket = self.undeclared_sockets[0]

            try:
                socket.sendall(msg)
            except:
                self.stream_print("ERROR NOTIFYING" +
                                  self.print_socket(socket) +
                                  " -> BROKEN PIPE ON THEIR END")

            self.close_socket(socket, selector_obj)
        self.stream_print("\tNotifiying %d SINK       sockets and removing" %
                          (len(self.sink_sockets)))
        while (len(self.sink_sockets) > 0):
            socket = self.sink_sockets[0]

            try:
                socket.sendall(msg)
            except:
                self.stream_print("ERROR NOTIFYING" +
                                  self.print_socket(socket) +
                                  " -> BROKEN PIPE ON THEIR END")

            self.close_socket(socket, selector_obj)
        self.stream_print("\tNotifiying %d SOURCE     sockets and removing" %
                          (len(self.src_sockets)))
        while (len(self.src_sockets) > 0):
            socket = self.src_sockets[0]
            try:
                socket.sendall(msg)
            except:
                self.stream_print("ERROR NOTIFYING" +
                                  self.print_socket(socket) +
                                  " -> BROKEN PIPE ON THEIR END")

            self.close_socket(socket, selector_obj)

        if (not (self.mode & SRC2SINK)):
            pass
        else:
            self.store_buffer(SRC2SINK)
            self.clear_buffer(SRC2SINK)

        if (not (self.mode & SINK2SRC)):
            pass
        else:
            self.store_buffer(SINK2SRC)
            self.clear_buffer(SINK2SRC)

        self.print_state()
Beispiel #35
0
def __send_msg(socket, msg):
    """
    发送消息
    :param socket:
    :param msg:
    :return:
    """

    msg_str = msg
    if type(msg) != 'str':
        msg_str = json.dumps(msg)

    msg_bytes = bytearray(msg_str, 'utf-8')

    msg_bytes_len = len(msg_bytes)
    # 数字转字符数组
    msg_bytes_len_bytes = bytearray(struct.pack(">I", msg_bytes_len))
    msg_result = msg_bytes_len_bytes + msg_bytes

    socket.sendall(msg_result)

    re = socket.recv(3096)

    return bytearray(re)[4:].decode()
Beispiel #36
0
 def _tcp_logger(self, socket):
     """
     Checks for messages from TCP client (mic.) and puts them in queue
     """
     sent_stop_msg = False
     # loop until motors have stopped, mic is stopped and all data is queued
     while True:
         # send 'Stop' msg to client (mic.) if motors have stopped
         if self._mav_stopped and not sent_stop_msg:
             self._print_fancy("Stopping mic...")
             socket.sendall(b"STOP")
             sent_stop_msg = True
         # check for new data
         tcp_msg = socket.recv(int(self._mic_blocking_size))
         if tcp_msg:
             # put data in queue
             self._q_mic.put(tcp_msg)
         else:
             # check if motors have stopped
             if self._mav_stopped:
                 self._print_fancy("All mic. data received.")
                 break
     # update the mic status for the main thread (collect_data)
     self._mic_stopped = True
Beispiel #37
0
def keyboard_to_socket(socket):
	"""Reads data from keyboard and sends it to the passed socket.
	
	Returns number of bytes sent, or 0 to indicate the user entered "EXIT"
	"""
	print("You: ", end="", flush=True) # Use end="" to avoid adding a newline after the prompt, flush=True to force-print the prompt

	# Read a full line from the keyboard. The returned string will include the terminating newline character.
	user_input = sys.stdin.readline()
	if user_input == "EXIT\n": # The user requested that the communication is terminated.
		return 0

	# Send the whole line through the socket; remember, TCP provides no guarantee that it will be delivered in one go.
	bytes_sent = socket.sendall(str.encode(user_input))
	return bytes_sent
Beispiel #38
0
def wysylanie_danych(name, socket):
    while True:
        order = [0, 0, 0, 0, 0, 0]
        order_str = ""
        print("Podaj katy o jakie powinny przesunac sie silniki: \n")

        order[0] = input("Os 1: ")
        order[1] = input("Os 2: ")
        order[2] = input("Os 3: ")
        order[3] = input("Os 4: ")
        order[4] = input("Os 5: ")
        order[5] = input("Os 6: ")

        for x in range(len(order)):
            order_str = order_str + str(order[x])
            if x < len(order) - 1:
                order_str = order_str + "/"
        try:
            socket.sendall(bytes(order_str, 'utf-8'))
        except Exception as e:
            print(e)
        finally:
            logging.info('Data successfully sent! /from thread: ' + name)
            print('data sent...')
Beispiel #39
0
 def connect(self, socket):
     conn, cursor = self.create_conn()
     while True:
         try:
             msg = socket.recv(1024)
             msg = json.loads(msg.decode())
             result = {'code': 0, 'result': {}}
             dateall = msg['date']
             field = msg['field']
             for date in dateall:
                 result['result'][date] = {}
                 sql = self.set_sql(date, field)
                 cursor.execute(sql)
                 receive = cursor.fetchone()
                 for i in range(len(field)):
                     result['result'][date][field[i]] = receive[i]
             result = json.dumps(result)
             socket.sendall(result.encode('UTF-8'))
         except Exception as e:
             print(e)
             cursor.close()
             conn.close()
             self.close()
             return
Beispiel #40
0
    def send(self,
             socket: socket.socket,
             protocol: str,
             data: t.Optional[dict] = None,
             network_protocol: int = TCP):
        if network_protocol != self.TCP and network_protocol != self.UDP:
            raise TypeError(
                "Invalid network_protocol type. Must be TCP or UDP.")

        if data is None:
            data = {}
        message = self.encoder.encode({"protocol": protocol, "data": data})

        if network_protocol == self.TCP:
            header = bytes(f"{len(message):<{self._header_size}}", "utf-8")
            socket.sendall(header + message)
        else:
            if socket not in self._udp_addresses.keys():
                print(
                    "Cannot send packet to user as UDP port has not yet been assigned."
                )
                return
            address = self._udp_addresses[socket]
            self._socket_udp.sendto(message, address)
Beispiel #41
0
def chatloop(socket):
    while True:
        while True:
            data = tostr(sock.recv(512))
            if data == 'ok':
                sock.sendall(bytes('ok', 'utf-8'))
                break
            else:
                data = data
                sock.sendall(bytes(data, 'utf-8'))
                data1 = data
        if data1 == 'stop':
            time.sleep(0.05)
            socket.sendall(bytes('stop received', 'utf-8'))
            break
        if data1 != '':
            if data1[0:9] == 'request: ':
                data1 = data1[9:]
                answer = input(data1 + ' :')
                socket.sendall(bytes(answer, 'utf-8'))
            else:
                print(data1)
        else:
            pass
Beispiel #42
0
def process(socket):
    print("Going to do handshake... ")
    k = handshake(socket)
    if k is None:
        print("FAILED.")
        return False
    print("done.")

    while True:
        pt = input("Client message: ")
        if len(pt) > 0:
            msg_to_send = encrypt(k, pt.encode("utf-8"))
            print("encrypted msg:", msg_to_send)
            socket.sendall(msg_to_send)
        else:
            socket.close()
            break
        try:
            data = socket.recv(SOCKET_READ_BLOCK_LEN)
            pt = decrypt(k, data)
            print(pt.decode("utf-8"))
        except:
            print("You have been disconnected from the server")
            break
    def send_packet(self, msg, direction, selector_obj):
        if (direction & SRC2SINK == SRC2SINK):
            if (not (self.mode & SRC2SINK)):
                self.stream_print("NO SRC2SINK ACCESS")
                return
            self.stream_print("Sending Packet from SRC(s) -> SINK(s)")
            for socket in self.sink_sockets:
                try:
                    socket.sendall(msg)
                except:
                    #Broken Pipe error; Socket no longer connected
                    self.close_socket(socket, selector_obj)

        if (direction & SINK2SRC == SINK2SRC):
            if (not (self.mode & SINK2SRC)):
                self.stream_print("NO SINK2SRC ACCESS")
                return
            self.stream_print("Sending Packet from SINK(s) -> SRC(s)")
            for socket in self.src_sockets:
                try:
                    socket.sendall(msg)
                except:
                    #Broken Pipe error; Socket no longer connected
                    self.close_socket(socket, selector_obj)
Beispiel #44
0
    def run(self):
        if self.enable_tls:
            context = ssl.SSLContext(ssl.PROTOCOL_TLS)
            context.check_hostname = False
            socket = context.wrap_socket(self.socket,
                                         server_hostname=self.upstream_ip)
        else:
            socket = self.socket

        try:
            socket.connect((self.upstream_ip, self.upstream_port))
            print("flowmodgenerator connected!")
        except socket.error as e:
            if e.errno != 115 and e.errno != 36:
                print("failed to connect: " + str(e))
                return

        socket.setblocking(False)

        time.sleep(1)

        while True:
            ready_to_read, ready_to_write, error = select.select([socket],
                                                                 [socket], [],
                                                                 TIMEOUT_S)
            if ready_to_write:
                message = self.messageGenerator.generate_benchmark_message(
                    self.current_xid)

                socket.sendall(message)
                self.current_xid += 1

            if self.should_stop: break
            time.sleep(0.01)

        socket.close()
Beispiel #45
0
 def telnet_process_options(self, socket, cmd, opt):				
     IS = b'\00'
     if cmd == WILL and opt == ECHO:                                        # hex:ff fb 01 name:IAC WILL ECHO description:(I will echo)
         socket.sendall(IAC + DO + opt)                                     # hex(ff fd 01), name(IAC DO ECHO), descr(please use echo)
     elif cmd == DO and opt == TTYPE:                                       # hex(ff fd 18), name(IAC DO TTYPE), descr(please send environment type)		
         socket.sendall(IAC + WILL + TTYPE)                                 # hex(ff fb 18), name(IAC WILL TTYPE), descr(Dont worry, i'll send environment type)
     elif cmd == SB:
         socket.sendall(IAC + SB + TTYPE + IS + self.env_term.encode() + IS + IAC + SE)
         # hex(ff fa 18 00 b"VT100" 00 ff f0) name(IAC SB TTYPE iS VT100 IS IAC SE) descr(Start subnegotiation, environment type is VT100, end negotation)
     elif cmd == SE:                                                        # server letting us know sub negotiation has ended
         pass                                                               # do nothing
     else: print('Unexpected telnet negotiation')
Beispiel #46
0
def send_categorical_matrix(socket, categorical_matrix):
    """
    Sends a list of strings to the getml engine
    (an actual string, not a bytestring).
    """

    if len(categorical_matrix.shape) == 1:
        shape = [categorical_matrix.shape[0], 1]

    elif len(categorical_matrix.shape) > 2:
        raise Exception(
            "Numpy array must be one-dimensional or two-dimensional!")

    else:
        shape = categorical_matrix.shape

    # By default, numeric data sent over the socket is big endian,
    # also referred to as network-byte-order!
    if sys.byteorder == 'little':
        # Sends the shape of the categorical matrix.
        socket.sendall(
            np.asarray(shape).astype(np.int32).byteswap().tostring())

        # Sends the length of the encoded string, followed by the encoded string
        # itself.
        socket.sendall(''.encode().join([
            np.asarray(len(elem.encode('utf-8'))).astype(
                np.int32).byteswap().tostring() + elem.encode('utf-8')
            for elem in categorical_matrix.astype(str).flatten()
        ]))

    else:
        # Sends the shape of the categorical matrix.
        socket.sendall(np.asarray(shape).astype(np.int32).tostring())

        # Sends the length of the encoded string, followed by the encoded string
        # itself.
        socket.sendall(''.encode().join([
            np.asarray(len(elem.encode('utf-8'))).astype(np.int32).tostring() +
            elem.encode('utf-8')
            for elem in categorical_matrix.astype(str).flatten()
        ]))
Beispiel #47
0
 def inizio_asta(self, senders_socket):
     global start
     for client in self.clients_list:
         socket, (ip, port) = client
         socket.sendall(self.last_received_message.encode('utf-8'))
         mess = f"inizio L'asta per {nomecalciatore} è iniziata"
         socket.sendall(mess.encode('utf-8'))
         time.sleep(1)
         #mes = ""
         mess1 = f"offerta {player_offre}: 1 "
         socket.sendall(mess1.encode('utf-8'))
         #mess1 = ""
         start = time.time()
def single_connection_handler(socket, address):
    while True:
        data = socket.recv(2048).decode('utf-8')
        
        if data.startswith("HELO"):
            socket.sendall("{0}\nIP:{1}\nPORT:{2}\nStudentID:{3}".format(data.strip(), "134.226.32.10", str(address[1]), "12326755"))
            continue
        
        elif data.startswith("KILL_SERVICE"):
            socket.close()
            break
        
        data = data.split('\n')
        action_key_val = data[0]
        action_name = action_key_val[:action_key_val.find(':')]
        
        if (action_name == 'CHAT'):
            room_id = int(data[0].split(":")[1])
            chatroom_join_id = int(data[1].split(":")[1])
            client_name = data[2].split(":")[1]
            boradcast_message(room_id, "CHAT:{0}\nCLIENT_NAME:{1}\nMESSAGE:{2}\n\n".format(str(room_id), str(client_name), data[3].split(":")[1]))
        elif (action_name == 'JOIN_CHATROOM'):
            client_name = data[3].split(":")[1]
            room_name = data[0].split(":")[1]
            room_id = int(md5(room_name).hexdigest(), 16)
            chatroom_join_id = int(md5(client_name).hexdigest(), 16)
            if room_id not in rooms:
                rooms[room_id] = dict()
            if chatroom_join_id not in rooms[room_id]:
                rooms[room_id][chatroom_join_id] = socket
                socket.sendall("JOINED_CHATROOM:{0}\nSERVER_IP:{1}\nPORT:{2}\nROOM_REF:{3}\nJOIN_ID:{4}\n".format(str(room_name), address[0], address[1], str(room_id), str(chatroom_join_id)))
                boradcast_message(room_id, "CHAT:{0}\nCLIENT_NAME:{1}\nMESSAGE:{2}".format(str(room_id), str(client_name), str(client_name) + " has joined this chatroom.\n\n"))

        elif (action_name == 'LEAVE_CHATROOM'):
            room_id = int(data[0].split(":")[1])
            chatroom_join_id = int(data[1].split(":")[1])
            client_name = data[2].split(":")[1]
            socket.sendall("LEFT_CHATROOM:{0}\nJOIN_ID:{1}\n".format(str(room_id), str(chatroom_join_id)))
            boradcast_message(room_id, "CHAT:{0}\nCLIENT_NAME:{1}\nMESSAGE:{2}\n\n".format(str(room_id), str(client_name), str(client_name) + " has left this chatroom."))
            del rooms[room_id][chatroom_join_id]

        elif (action_name == 'DISCONNECT'):
            client_name = data[2].split(":")[1]
            chatroom_join_id = int(md5(client_name).hexdigest(), 16)
            for room_id in rooms.keys():
                if chatroom_join_id in rooms[room_id]:
                    boradcast_message(room_id, "CHAT:{0}\nCLIENT_NAME:{1}\nMESSAGE:{2}\n\n".format(str(room_id), str(client_name), str(client_name) + " has left this chatroom."))
                    if chatroom_join_id in rooms[room_id]:
                        del rooms[room_id][chatroom_join_id]
            break
Beispiel #49
0
	def telnet_process_options(self, socket, cmd, opt):			
		IS = b'\00'
		# Inspired by
		# https://github.com/rapid7/metasploit-framework/blob/master/lib/msf/core/exploit/telnet.rb
		# https://github.com/jquast/x84/blob/cf3dff9be7280f424f6bcb0ea2fe13d16e7a5d97/x84/default/telnet.py
		if cmd == WILL and opt == ECHO: #hex:ff fb 01 name:IAC WILL ECHO description:(I will echo)
				socket.sendall(IAC + DO + opt) #hex(ff fd 01), name(IAC DO ECHO), descr(please use echo)
		elif cmd == DO and opt == TTYPE: #hex(ff fd 18), name(IAC DO TTYPE), descr(please send environment type)
				socket.sendall(IAC + WILL + TTYPE) #hex(ff fb 18), name(IAC WILL TTYPE), descr(Dont worry, i'll send environment type)
		elif cmd == SB:
			socket.sendall(IAC + SB + TTYPE + IS + self.env_term.encode() + IS + IAC + SE)
			# hex(ff fa 18 00 b"VT100" 00 ff f0) name(IAC SB TTYPE iS VT100 IS IAC SE) descr(Start subnegotiation, environment type is VT100, end negotation)
		elif cmd == SE: # server letting us know sub negotiation has ended
			pass # do nothing
		else: print("Unexpected telnet negotiation")
Beispiel #50
0
def handle_new_client(socket, address):
    global current_arctic_chars
    print('New connection from %s', address)
    arcticChar = ArcticChar(socket, address)

    socket.sendall(
        str(ArcticMessage("NOTIFY", "Welcome to FourSkulls.org(" + IP + ")")))
    socket.sendall(
        str(
            ArcticMessage(
                "NOTIFY", "Current Chars connected are(" +
                ",".join(current_arctic_chars.keys()) + ")")))
    socket.sendall(str(ArcticMessage("EXECUTE", "score")))
    rfileobj = socket.makefile(mode='rb')
    try:
        while True:
            line = rfileobj.readline()
            if not line:
                print("client disconnected")
                break
            print("received %r" % line)
            (cmd, payload) = parse_message(line)
            if cmd == "CHARDATA":
                arcticChar.update(payload)
                # destroy the previous char
                if arcticChar.charData['@name'] in current_arctic_chars:
                    previousArcticChar = current_arctic_chars[
                        arcticChar.charData['@name']]
                    if previousArcticChar != arcticChar:
                        previousArcticChar.kill()
                        previousArcticChar.join()
                current_arctic_chars[arcticChar.charData['@name']] = arcticChar
                #socket.sendall(str(ArcticMessage("NOTIFY", "Received CharData: " + str(arcticChar.charData))))
                print("FOUND CHARDATA for %s" % arcticChar.charData['@name'])
                arcticChar.start()
            else:
                temp_current_arctic_chars = current_arctic_chars.copy()
                if cmd != "NOTIFYALL" and cmd != "NOTIFY" and arcticChar.charData != None:
                    del temp_current_arctic_chars[arcticChar.charData['@name']]
                commands[cmd].execute(payload, temp_current_arctic_chars)
    finally:
        rfileobj.close()
        print("CLOSING CONNECTION FOR %s" % str(arcticChar))
        if arcticChar.charData != None and '@name' in arcticChar.charData:
            del current_arctic_chars[arcticChar.charData['@name']]
            arcticChar.kill()
            arcticChar.join()
Beispiel #51
0
    def send_and_receive(self, socket, stream, save_cookies=False):
        res = []
        i = socket.sendall(self.serialize())
        if self.method == AjpForwardRequest.POST:
            return res

        r = AjpResponse.receive(stream)
        assert r.prefix_code == AjpResponse.SEND_HEADERS
        res.append(r)
        if save_cookies and 'Set-Cookie' in r.response_headers:
            self.headers['SC_REQ_COOKIE'] = r.response_headers['Set-Cookie']

        # read body chunks and end response packets
        while True:
            r = AjpResponse.receive(stream)
            res.append(r)
            if r.prefix_code == AjpResponse.END_RESPONSE:
                break
            elif r.prefix_code == AjpResponse.SEND_BODY_CHUNK:
                continue
            else:
                raise NotImplementedError

        return res
Beispiel #52
0
def _uploadBytes(socket, duration_ms, packet_size, answer_with = None):
    """
    Send byte arrays of size packet_size with end 0x00 until the duration_ms milliseconds
    have passed, then send a byte array with end 0xff
    :param socket:
    :param duration_ms:
    :param packet_size:
    :return:
    """

    # if answer_with is specified, we wait for a request
    if answer_with:
        lines = ""
        while True:
            lines += str(socket.recv(1), "utf-8");
            if lines.endswith("\r\n\r\n"):
                break;
        LOGGER.debug(lines)

        # send answer
        socket.sendall(bytes(answer_with,"utf-8"))

    timestamp_start = time.time() * 1000
    sent_packets = 0
    while (time.time() * 1000 - timestamp_start) < duration_ms:
        random_bytes = os.urandom(packet_size - 1)
        random_bytes += b'\x00'
        socket.sendall(random_bytes)
        sent_packets +=1

    random_bytes = os.urandom(packet_size - 1)
    random_bytes += b'\xff'
    socket.sendall(random_bytes)
    sent_packets += 1
    duration_up = time.time() * 1000 - timestamp_start


    return {
        "duration_ms" : int(duration_up),
        "bytes" : sent_packets * packet_size
    }
def enviar_archivo(socket, ip, rutaArchivo: str, hash, filesize,
                   q: queue.Queue):
    # Agrega el objeto que se va a usar para hacer el log
    log_object = {"Cliente": ip}
    q.put(log_object)

    mensajeArchivo = "ARCHIVO:{0}:{1}".format(
        rutaArchivo.split(".")[-1], filesize)
    socket.sendall(mensajeArchivo.encode("utf-8"))

    data = socket.recv(1024)
    mensaje = data.decode("utf-8")

    if mensaje == "PREPARADO":
        log_object["Entregado"] = "No"

        with open(rutaArchivo, 'rb') as f:
            data = f.read(CHUNK_SIZE)
            start_ts = datetime.now().timestamp()
            while data:
                socket.sendall(data)
                data = f.read(CHUNK_SIZE)

        #Espera a recibir la confirmación de terminar
        data = socket.recv(1024)
        message = data.decode("utf-8")

        if message.startswith("RECIBIDO"):
            log_object["Entregado"] = "Si"

            end_ts = float(message.split(":")[-1])

            final_time = (end_ts - start_ts) / 1000

            socket.sendall("HASH:{}".format(hash).encode("utf-8"))
            socket.close()

            log_object["Tiempo"] = final_time

        else:
            print("El archivo no fue recibido")
Beispiel #54
0
def chat_run(socket):

    pid = os.fork()

    while 1:
        if not pid:
            #enfant
            envoi_plain = input("#  => ")
            while (
                    envoi_plain
            ):  # On est limité par notre n pour la taille des messages envoyés, on envoie donc notre message par blocs
                envoi_cypher = encrypt(envoi_plain[:64])
                envoi_plain = envoi_plain[64:]
                envoi = envoi_cypher.to_bytes(512,
                                              byteorder='big',
                                              signed=False)
                socket.sendall(envoi)
            socket.sendall(config.ETX)  # On envoie ETX (End Of Text)
            time.sleep(0.2)
        else:
            #parent
            recu = socket.recv(512)
            recu_plain = ""
            while (recu != config.ETX and recu != config.EOT):
                recu_cipher = int.from_bytes(recu, byteorder='big')
                recu_plain_part = decrypt(recu_cipher)
                recu_plain += recu_plain_part
                recu = socket.recv(512)
            if (recu_plain == 'quit' or recu_plain == 'exit'):
                socket.sendall(
                    config.EOT)  # On envoie EOT (End Of Transmission)
                os.kill(pid, 15)  # terminaison du processus enfant
                break
            if (recu == config.EOT):
                os.kill(pid, 15)  # terminaison du processus enfant
                break
            else:
                print('\r#  <= ' + recu_plain + "\n#  => ", end='')

    socket.close()
Beispiel #55
0
def send_string(socket, string):
    """
    Sends a string to the getml engine
    (an actual string, not a bytestring).
    """

    encoded = string.encode('utf-8')

    size = len(encoded)

    # By default, numeric data sent over the socket is big endian,
    # also referred to as network-byte-order!
    if sys.byteorder == 'little':

        socket.sendall(
            np.asarray([size]).astype(np.int32).byteswap().tostring())

    else:

        socket.sendall(np.asarray([size]).astype(np.int32).tostring())

    socket.sendall(encoded)
Beispiel #56
0
    def app_thread(self, socket, address, ID):
        print("DEBUG: connected to app at {}:{}".format(
            address[0], address[1]))
        connected = True

        socket.sendall(self.make_packet("DATA", "CONNECTED"))

        while connected:
            recv = socket.recv(4096)
            print("DEBUG: ".format(recv))

            if recv_msg.startswith("LOCK DOOR"):
                # $ get ready to lock door

                recv_msg, door_number = recv_msg.split('&')
                socket.sendall(
                    self.make_packet("ACK", "LOCK DOOR&" + door_number))
                """
                add to queue?
                """

                print("DEBUG: finished lock")

            elif recv_msg.startswith("UNLOCK DOOR"):
                # $ get ready to unlock door

                recv_msg, door_number = recv_msg.split('&')
                socket.sendall(
                    self.make_packet("ACK", "UNLOCK DOOR&" + door_number))
                """
                add to queue?
                """

                print("DEBUG: finished unlock")

            elif recv_msg == "SHUTTING DOWN":
                socket.close()
                connected = False
Beispiel #57
0
def sendMessage(socket, strMessage):
    #send the message in parameter
    socket.sendall(strMessage + "#")
Beispiel #58
0
 def broadcast_to_all_clients(self, senders_socket):
     for client in self.clients_list:
         socket, (ip, port) = client
         if socket is not senders_socket:
             socket.sendall(self.last_received_message.encode('utf-8'))
Beispiel #59
0
def exec_and_fetch(socket, command):
    """docstring for exec_and_fetch"""
    socket.sendall(command)
    ret = socket.recv(1024)

    return ret
Beispiel #60
0
def reply(socket):
    for i in range(1, 6):
        string = "VM:" + str(i) + "\n"
        socket.sendall(string)
        time.sleep(2)
    socket.sendall("done:")