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 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 _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(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)
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 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)
