def recv_from(self, socket): # Write into this buffer from socket, return number of bytes written if self.read_pos == self.write_pos and self.full_state is READ: return 0 if self.write_pos < self.read_pos: num = socket.recv_into(self.buf[self.write_pos:self.read_pos]) self.write_pos += num else: num = socket.recv_into(self.buf[self.write_pos:]) self.write_pos = (self.write_pos + num) % len(self.buf) if self.write_pos == self.read_pos: self.full_state = READ return num
def recv_from(self, socket): # Write into this buffer from socket, return number of bytes written if self.read_pos == self.write_pos and self.full_state is READ: return 0 if self.write_pos < self.read_pos: num = socket.recv_into(self.buf[self.write_pos : self.read_pos]) self.write_pos += num else: num = socket.recv_into(self.buf[self.write_pos :]) self.write_pos = (self.write_pos + num) % len(self.buf) if self.write_pos == self.read_pos: self.full_state = READ return num
def socket_read(socket): buffer = bytearray(b' ' * 256) nbytes = socket.recv_into(buffer, 256) if nbytes == 0: # empty message return message = '' while nbytes != 0: try: # index() raises when it can't find the character i = buffer[:nbytes].index('\0') message += str(buffer[:i]) # discard past delimiter break except ValueError: # haven't reached end yet message += str(buffer) nbytes = socket.recv_into(buffer, 256) return message
def recvJson(socket): '''Receive a JSON string via socket and covert it back to original object Parameters ---------- socket : socket Network socket. Returns ------- object An object sent from the other end of socket connection. ''' buffer = socket.recv(4) jsonLength = struct.unpack("!i", buffer)[0] # Reference: https://stackoverflow.com/a/15964489/9798310 buffer = bytearray(jsonLength) view = memoryview(buffer) while jsonLength: nbytes = socket.recv_into(view, jsonLength) view = view[nbytes:] jsonLength -= nbytes jsonString = buffer.decode("utf-8") return json.loads(jsonString)
def _recv(socket): # read the length of the data, letter by letter until we reach EOL length_str = '' char = socket.recv(1) while char != '\n': length_str += char char = socket.recv(1) total = int(length_str) # use a memoryview to receive the data chunk by chunk efficiently view = memoryview(bytearray(total)) next_offset = 0 while total - next_offset > 0: recv_size = socket.recv_into(view[next_offset:], total - next_offset) next_offset += recv_size try: deserialized = json.loads(view.tobytes()) except TypeError as e: print( 'Error: {0}. You can only send JSON-serializable data'.format( e)) except ValueError as e: print( 'Error: {0}. You can only send JSON-serializable data'.format( e)) return deserialized
def receiveJson(socket): # read the length of the data, letter by letter until we reach EOL length_str = '' char = socket.recv(1).decode('utf_8') if not char: #If the socket is closed, return None return None while char != '\n': length_str += char char = socket.recv(1).decode('utf_8') total = int(length_str) # use a memoryview to receive the data chunk by chunk efficiently view = memoryview(bytearray(total)) next_offset = 0 while total - next_offset > 0: recv_size = socket.recv_into(view[next_offset:], total - next_offset) next_offset += recv_size try: deserialized = json.loads(view.tobytes()) except (TypeError, ValueError): raise Exception('Data received was not in JSON format') plain_text = decrypt(deserialized, COM_PASSWORD) return plain_text.decode("utf-8")
def readBlock(socket, blockLength): # use a memoryview to receive the data chunk by chunk efficiently view = memoryview(bytearray(blockLength)) next_offset = 0 while blockLength - next_offset > 0: recv_size = socket.recv_into(view[next_offset:], blockLength - next_offset) next_offset += recv_size return view.tobytes()
def receive_all(socket, amount): buffer = bytearray(amount) view = memoryview(buffer) while amount > 0: received = socket.recv_into(view[-amount:]) if not received: break amount -= received return buffer
def __DoHanshake(socket): import hashlib, array random = bytearray(16) socket.recv_into(random, 16) #Receive first 16 "Hello" random bytes random = __Xor(random); #Do a Xor with "CCcam" string to the hello bytes sha1 = hashlib.sha1() sha1.update(random) sha1digest = array.array('B', sha1.digest()) #Create a sha1 hash with the xor hello bytes sha1hash = __FillArray(bytearray(20), sha1digest) recvblock.Init(sha1hash, 20) #initialize the receive handler recvblock.Decrypt(random, 16) sendblock.Init(random, 16) #initialize the send handler sendblock.Decrypt(sha1hash, 20) rcount = __SendMessage(sha1hash, 20, socket) #Send the a crypted sha1hash!
def recv_into(viewable, socket): """ Receive from socket into viewable object. :param viewable: viewable object :param socket: source socket :return: None """ view = memoryview(viewable) while len(view): nrecv = socket.recv_into(view) view = view[nrecv:]
def DoHanshake(socket): import hashlib, array, CriptoBlock random = bytearray(16) socket.recv_into(random, 16) #Receive first 16 "Hello" random bytes print "Hello bytes: " + random random = CriptoBlock.Xor(random); #Do a Xor with "CCcam" string to the hello bytes sha1 = hashlib.sha1() sha1.update(random) sha1digest = array.array('B', sha1.digest()) #Create a sha1 hash with the xor hello bytes sha1hash = FillArray(bytearray(20), sha1digest) recvblock.Init(sha1hash, 20) #initialize the receive handler recvblock.Decrypt(random, 16) sendblock.Init(random, 16) #initialize the send handler sendblock.Decrypt(sha1hash, 20) rcount = SendMessage(sha1hash, 20, socket) #Send the a crypted sha1hash!
def receive_socket_data(socket): to_read = 24 data = bytearray(to_read) data_view = memoryview(data) while to_read: try: bytes_read = socket.recv_into(data_view, to_read) except ConnectionResetError: return None data_view = data_view[bytes_read:] to_read -= bytes_read return data
def recvJson(socket): buffer = socket.recv(4) jsonLength = struct.unpack("!i", buffer)[0] # Reference: https://stackoverflow.com/a/15964489/9798310 buffer = bytearray(jsonLength) view = memoryview(buffer) while jsonLength: nbytes = socket.recv_into(view, jsonLength) view = view[nbytes:] jsonLength -= nbytes jsonString = buffer.decode("utf-8") return json.loads(jsonString)
def _recv(socket): # read the length of the data, letter by letter until we reach EOL length_str = '' char = socket.recv(1) while char != '\n': length_str += char char = socket.recv(1) total = int(length_str) # use a memoryview to receive the data chunk by chunk efficiently view = memoryview(bytearray(total)) next_offset = 0 while total - next_offset > 0: recv_size = socket.recv_into(view[next_offset:], total - next_offset) next_offset += recv_size deserialized = json.loads(view.tobytes()) return deserialized
def recvall(socket, n): """ Read exactly n bytes from a socket """ data = bytearray(n) window = memoryview(data) while len(window): try: read = socket.recv_into(window) if read == 0: raise EOFError('unexpected end of file') window = window[read:] except InterruptedError: continue # TODO would be nice if this could be done without a copy (not that it # makes any real difference) return bytes(data)
def _recv(socket): # read the length of the data, letter by letter until we reach EOL size = socket.recv(LENGTH_LENGTH) total = int(size.decode('utf-8')) # use a memoryview to receive the data chunk by chunk efficiently view = memoryview(bytearray(total)) next_offset = 0 while total - next_offset > 0: recv_size = socket.recv_into(view[next_offset:], total - next_offset) next_offset += recv_size try: deserialized = json.loads(view.tobytes().decode('utf-8')) except (TypeError, ValueError) as e: raise Exception('Data received was not in JSON format') return deserialized
def _Get(socket): strLen = "" char = Decode(socket.recv(1)) while char != '\n': strLen += char char = Decode(socket.recv(1)) total = int(strLen) view = memoryview(bytearray(total)) nextOffset = 0 while total - nextOffset > 0: recvSize = socket.recv_into(view[nextOffset:], total - nextOffset) nextOffset += recvSize try: deserialised = json.loads(Decode(view.tobytes())) except (TypeError, ValueError): raise Exception('Data received was not in JSON format') return deserialised
def _recv(socket): # read the length of the data, letter by letter until we reach EOL length_str = '' char = socket.recv(1) while char != '\n': length_str += char char = socket.recv(1) total = int(length_str) # use a memoryview to receive the data chunk by chunk efficiently view = memoryview(bytearray(total)) next_offset = 0 while total - next_offset > 0: recv_size = socket.recv_into(view[next_offset:], total - next_offset) next_offset += recv_size try: deserialized = json.loads(view.tobytes()) except (TypeError, ValueError), e: raise Exception('Data received was not in JSON format')
def recvJson(socket): """ This method is used to receive a json from socket :param (object)socket """ buffer = socket.recv(4) if buffer: print('recieved') jsonLength = struct.unpack("!i", buffer)[0] # Reference: https://stackoverflow.com/a/15964489/9798310 buffer = bytearray(jsonLength) view = memoryview(buffer) while jsonLength: nbytes = socket.recv_into(view, jsonLength) view = view[nbytes:] jsonLength -= nbytes jsonString = buffer.decode("utf-8") return json.loads(jsonString)
def recvJson(self,socket): """ Parameters ------- socket : str takes in user information through the socket. """ buffer = socket.recv(4) jsonLength = struct.unpack("!i", buffer)[0] # Reference: https://stackoverflow.com/a/15964489/9798310 buffer = bytearray(jsonLength) view = memoryview(buffer) while jsonLength: nbytes = socket.recv_into(view, jsonLength) view = view[nbytes:] jsonLength -= nbytes jsonString = buffer.decode("utf-8") return json.loads(jsonString)
def recvJson(socket): ''' Receives the json file containing object information. :type socket: socket :param socket: The socket used for data transmission :return: A decoded json of the data received. ''' buffer = socket.recv(4) jsonLength = struct.unpack("!i", buffer)[0] # Reference: https://stackoverflow.com/a/15964489/9798310 buffer = bytearray(jsonLength) view = memoryview(buffer) while jsonLength: nbytes = socket.recv_into(view, jsonLength) view = view[nbytes:] jsonLength -= nbytes jsonString = buffer.decode("utf-8") return json.loads(jsonString)
def _recv(socket): # Change to non-blocking: test if socket readable, else return. rlist, wlist, elist = select.select([socket], [], [], 0) if [rlist, wlist, elist] == [ [], [], [] ]: return None # read the length of the data, letter by letter until we reach EOL length_str = '' char = socket.recv(1) while char != '\n': length_str += char char = socket.recv(1) total = int(length_str) # use a memoryview to receive the data chunk by chunk efficiently view = memoryview(bytearray(total)) next_offset = 0 while total - next_offset > 0: recv_size = socket.recv_into(view[next_offset:], total - next_offset) next_offset += recv_size try: deserialized = json.loads(view.tobytes()) except (TypeError, ValueError), e: raise Exception('Data received was not in JSON format')
def recv_into(self, buffer, nbytes=None, flags=0): if buffer and (nbytes is None): nbytes = len(buffer) elif nbytes is None: nbytes = 1024 if self._sslobj: if flags != 0: raise ValueError( "non-zero flags not allowed in calls to recv_into() on %s" % self.__class__) while True: try: tmp_buffer = self.read(nbytes) v = len(tmp_buffer) buffer[:v] = tmp_buffer return v except SSL.WantReadError: if self.timeout == 0.0: raise self._wait(self._read_event) continue else: return socket.recv_into(self, buffer, nbytes, flags)
def _recv(self, socket): # read the length of the data length_str = '' char = socket.recv(1) #raise the exception if the client is diconnect if not char: raise ClientDisconnectionError() #接收字串長度值 char = char.decode() while char != '\n': length_str += char char = socket.recv(1) char = char.decode() total = int(length_str) # use a memoryview to receive the data chunk by chunk view = memoryview( bytearray(total) ) #bytearray(total) create the bytearray that has enough space for the recieved message next_offset = 0 while total - next_offset > 0: recv_size = socket.recv_into(view[next_offset:], total - next_offset) next_offset += recv_size try: # the recieve data from the view.tobytes() is the byte string (the received data from the socket is the byte string) # because in python3, the string is the utf8 string or unicode string, we need to decode the byte string b_msg = view.tobytes() # b_msg: byte string msg = b_msg.decode() # decoding utf-8 # transfer the jason string to the dictionary type. deserialized = json.loads(msg) # deserialized: dict except (TypeError, ValueError): raise Exception('Data received was not in JSON format') return deserialized
def recvJson(socket): """ Receives a JSON object via socket and returns it as a dictionary. Args: socket (socket): The socket to send data through. Returns: Dictionary object generated from received JSON data. """ buffer = socket.recv(4) jsonLength = struct.unpack("!i", buffer)[0] # Reference: https://stackoverflow.com/a/15964489/9798310 buffer = bytearray(jsonLength) view = memoryview(buffer) while jsonLength: nbytes = socket.recv_into(view, jsonLength) view = view[nbytes:] jsonLength -= nbytes jsonString = buffer.decode("utf-8") return json.loads(jsonString)