def receive(sock):
hBuffer = MessageUtil.recvFromBuffer(sock, 16)
header = Header(hBuffer)
bBuffer = MessageUtil.recvFromBuffer(sock, header.BODYLEN)
body = MessageUtil.getBodyType(header, bBuffer)
msg = Message()
msg.Header = header
msg.Body = body
return msg
def receive(sock):
totalRecv = 0
sizeToRead = 16 # 헤더의 크기
hBuffer = bytes() # 헤더 버퍼
# 헤더 읽기
# 첫 반복문에서는 스트림으로부터 메세지 헤더의 경계를 끊어냅니다.
while sizeToRead > 0:
buffer = sock.recv(sizeToRead)
if not buffer:
return None
hBuffer += buffer
totalRecv += len(buffer)
sizeToRead -= len(buffer)
header = Header(hBuffer)
totalRecv = 0
bBuffer = bytes()
sizeToRead = header.BODYLEN
# 첫 반복문에서 얻은 헤더는 본문의 길이를 뽑아내어 그 길이만큼 다시 스트림으로부터 본문을 읽습니다.
while sizeToRead > 0:
buffer = sock.recv(sizeToRead)
if not buffer:
return None
bBuffer += buffer
totalRecv += len(buffer)
sizeToRead -= len(buffer)
body = None
if header.MSGTYPE == message.REQ_FILE_SEND:
body = BodyRequest(bBuffer)
elif header.MSGTYPE == message.REP_FILE_SEND:
body = BodyResponse(bBuffer)
elif header.MSGTYPE == message.FILE_SEND_DATA:
body = BodyData(bBuffer)
elif header.MSGTYPE == message.FILE_SEND_RES:
body = BodyResult(bBuffer)
else:
raise Exception("Unkonwn MSGTYPE : {0}".format(header.MSGTYPE))
msg = Message()
msg.Header = header
msg.Body = body
return msg
def receive(sock):
totalRecv = 0
sizeToRead = 16 # Header Size
hBuffer = bytes() # Header Buffer
# Read Header
while sizeToRead > 0: # In the first loop, the boundary of the message header is cut from the stream.
buffer = sock.recv(sizeToRead)
if len(buffer) == 0:
return None
hBuffer += buffer
totalRecv += len(buffer)
sizeToRead -= len(buffer)
header = Header(hBuffer)
totalRecv = 0
bBuffer = bytes()
sizeToRead = header.BODYLEN
while sizeToRead > 0: # Find out the length of the text in the header got from the first loop and read it back from the stream as long as it is.
buffer = sock.recv(sizeToRead)
if len(buffer) == 0:
return None
bBuffer += buffer
totalRecv += len(buffer)
sizeToRead -= len(buffer)
body = None
if header.MSGTYPE == message.REQ_FILE_SEND:
body = BodyRequest(bBuffer)
elif header.MSGTYPE == message.REP_FILE_SEND:
body = BodyResponse(bBuffer)
elif header.MSGTYPE == message.FILE_SEND_DATA:
body = BodyData(bBuffer)
elif header.MSGTYPE == message.FILE_SEND_RES:
body = BodyResult(bBuffer)
else:
raise Exception(
"Unknown MSGTYPE : {0}".
format(header.MSGTYPE))
msg = Message()
msg.Header = header
msg.Body = body
return msg
def receive(sock):
totalRecv = 0
sizeToRead = 12 # 헤더의 크기
hBuffer = bytes() # 헤더 버퍼
# 헤더 읽기
while sizeToRead > 0: # 첫 반복문에서는 스트림으로부터 메세지 헤더의 경계를 끊어낸다.
buffer = sock.recv(sizeToRead)
print("header ", buffer)
if len(buffer) == 0:
return None
hBuffer += buffer
totalRecv += len(buffer)
sizeToRead -= len(buffer)
header = Header(hBuffer)
totalRecv = 0
bBuffer = bytes()
sizeToRead = header.BODYLEN
while sizeToRead > 0: # 첫 반복문에서 얻은 헤더에서 본문의 길이를 뽑아내어 그 길이만큼 다시 스트림으로부터 본문을 읽는다.
buffer = sock.recv(sizeToRead)
print("body : ", buffer, sizeToRead)
if len(buffer) == 0:
return None
bBuffer += buffer
totalRecv += len(buffer)
sizeToRead -= len(buffer)
body = None
if header.MSGTYPE == 3:
body = RREQ(bBuffer)
# elif header.MSGTYPE == message.REP_FILE_SEND:
# body = BodyResponse(bBuffer)
# elif header.MSGTYPE == message.FILE_SEND_DATA:
# body = BodyData(bBuffer)
# elif header.MSGTYPE == message.FILE_SEND_RES:
# body = BodyResult(bBuffer)
else:
raise Exception("Unknown MSGTYPE : {0}".format(header.MSGTYPE))
msg = Message()
msg.Header = header
msg.Body = body
return msg
def receive(sock):
totalRecv = 0
sizeToRead = 16 # 헤더의 크기
hBuffer = bytes() # 헤더 버퍼
# 헤더 읽기
while sizeToRead > 0:
buffer = sock.recv(sizeToRead)
if len(buffer) == 0:
return None
hBuffer += buffer
totalRecv += len(buffer)
sizeToRead -= len(buffer)
header = Header(hBuffer)
totalRecv = 0
bBuffer = bytes()
sizeToRead = header.BODYLEN
while sizeToRead > 0:
buffer = sock.recv(sizeToRead)
if len(buffer) == 0:
return None
bBuffer += buffer
totalRecv += len(buffer)
sizeToRead -= len(buffer)
body = None
if header.MSGTYPE == message.REQ_FILE_SEND:
body = BodyRequest(bBuffer)
elif header.MSGTYPE == message.REP_FILE_SEND:
body = BodyResponse(bBuffer)
elif header.MSGTYPE == message.FILE_SEND_DATA:
body = BodyData(bBuffer)
elif header.MSGTYPE == message.FILE_SEND_RES:
body = BodyResult(bBuffer)
else:
raise Exception("Unknown MSGTYPE : {0}".format(header.MSGTYPE))
msg = Message()
msg.Header = header
msg.Body = body
return msg
def handle(self):
print("클라이언트 접속 : {0}".format(self.client_address[0]))
print()
client = self.request
while (True):
reqMsg = MessageUtil.receive(
client) #클라이언트가 보내온 파일 전송 요청 메세지를 수신한다.
if reqMsg is None:
print("전송 요청이 없습니다.")
return
if reqMsg.Header.MSGTYPE != message.REQ_FILE_SEND:
print("파일 전송 요청이 아닙니다...")
return
reqBody = BodyRequest(None)
print("파일 업로드 요청이 왔습니다.")
# 나는 무조건 수락
rspMsg = Message()
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.ACCEPTED
rspMsg.Header = Header(None)
msgId = 0
rspMsg.Header.MSGID = msgId
msgId = msgId + 1
rspMsg.Header.MSGTYPE = message.REP_FILE_SEND
rspMsg.Header.BODYLEN = rspMsg.Body.GetSize()
rspMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rspMsg.Header.LASTMSG = message.LASTMSG
rspMsg.Header.SEQ = 0
MessageUtil.send(client, rspMsg) # 클라이언트에게 '승낙' 응답을 보낸다.
print("파일 전송을 시작합니다...")
fileSize = reqMsg.Body.FILESIZE
fileName = reqMsg.Body.FILENAME
recvFileSize = 0
with open(os.path.join(upload_dir, fileName),
'wb') as file: # 업로드 받을 파일을 생성한다.
dataMsgId = -1
prevSeq = 0
while True:
reqMsg = MessageUtil.receive(client)
if reqMsg == None:
break
print("#", end='')
if reqMsg.Header.MSGTYPE != message.FILE_SEND_DATA:
break
if dataMsgId == -1:
dataMsgId = reqMsg.Header.MSGID
elif dataMsgId != reqMsg.Header.MSGID:
break
if prevSeq != reqMsg.Header.SEQ: # 메세지 순서가 어긋나면 전송을 중단한다.
print("{0}, {1}".format(prevSeq, reqMsg.Header.SEQ))
break
prevSeq += 1
recvFileSize += reqMsg.Body.GetSize(
) # 전송받은 파일의 일부를 담고 있는 bytes 객체를 서버에서 생성한 파일에 기록한다.
file.write(reqMsg.Body.GetBytes())
if reqMsg.Header.LASTMSG == message.LASTMSG: # 마지막 메세지만 반복문을 빠져나온다.
break
file.close()
print()
print("수신 파일 크기 : {0} bytes".format(recvFileSize))
rstMsg = Message()
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.SUCCESS
rstMsg.Header = Header(None)
rstMsg.Header.MSGID = msgId
msgId += 1
rstMsg.Header.MSGTYPE = message.FILE_SEND_RES
rstMsg.Header.BODYLEN = rstMsg.Body.GetSize()
rstMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rstMsg.Header.LASTMSG = message.LASTMSG
rstMsg.Header.SEQ = 0
if fileSize == recvFileSize: # 파일 전송 요청에 담겨온 파일 크기와 실제로 받은 파일의 크기를 비교하여 같으면 성공 메세지를 보낸다.
MessageUtil.send(client, rstMsg) # 전송 성공 메세지 보내기
else:
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.FAIL
MessageUtil.send(client,
rstMsg) # 파일 크기에 이상이 있다면 실패 메세지를 보낸다.
print("파일 전송을 마쳤습니다.")
print()
def handle(self):
print("클라이언트 접속 : {0}".format(self.client_address[0]))
client = self.request # client socket
reqMsg = MessageUtil.receive(client)
if reqMsg.Header.MSGTYPE != message.REQ_FILE_SEND:
client.close()
return
reqBody = BodyRequest(None)
print("File Upload reqest. Accept? (yes/no)")
answer = sys.stdin.readline()
#Accepted Message
rspMsg = Message()
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID #reqId -> resId
rspMsg.Body.RESPONSE = message.ACCEPTED
rspMsg.Header = Header(None)
msgId = 0
rspMsg.Header.MSGID = msgId
msgId = msgId + 1
rspMsg.Header.MSGTYPE = message.REP_FILE_SEND
rspMsg.Header.BODYLEN = rspMsg.Body.GetSize()
rspMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rspMsg.Header.LASTMSG = message.LASTMSG
rspMsg.Header.SEQ = 0
if answer.strip() == "yes":
MessageUtil.send(client, rspMsg)
else:
#Denied Message
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = rspMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.DENIED
MessageUtil.send(client, rspMsg)
client.close()
return
#Start file transfer
print("Transfering file..")
fileSize = reqMsg.Body.FILESIZE
fileName = reqMsg.Body.FILENAME
recvFileSize = 0
with open(upload_dir + "\\" + fileName, 'wb') as file:
dataMsgId = -1
prevSeq = 0
while True:
reqMsg = MessageUtil.receive(client)
if reqMsg == None:
break
print('#', end='')
if reqMsg.Header.MSGTYPE != message.FILE_SEND_DATA:
break
if dataMsgId == -1:
dataMsgId = reqMsg.Header.MSGID # reqId
elif dataMsgId != reqMsg.Header.MSGID:
break
# break if Message Sequence broken
if prevSeq != reqMsg.Header.SEQ:
print("{0}, {1}".format(prevSeq, reqMsg.Header.SEQ))
break
prevSeq += 1
#from receive server
recvFileSize += reqMsg.Body.GetSize()
file.write(reqMsg.Body.GetBytes())
#Exit loop if last message
if reqMsg.Header.LASTMSG == message.LASTMSG:
break
print()
print("Received File size : {0} bytes".format(recvFileSize))
#result message
rstMsg = Message()
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.SUCCESS
rstMsg.Header = Header(None)
rstMsg.Header.MSGID = msgId
msgId += 1
rstMsg.Header.MSGTYPE = message.FILE_SEND_RES
rstMsg.Header.BODYLEN = rstMsg.Body.GetSize()
rstMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rstMsg.Header.LASTMSG = message.LASTMSG
rstMsg.Header.SEQ = 0
if fileSize == recvFileSize:
MessageUtil.send(client, rstMsg)
else:
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.FAIL
MessageUtil.send(client, rstMsg)
print("Finished file transfer.")
client.close()
try:
print("서버:{0}/{1}".format(serverIp, serverPort))
sock.connect((serverIp, serverPort))
msgId = 0
reqMsg = Message()
filesize = os.path.getsize(filepath)
reqMsg.Body = BodyRequest(None)
reqMsg.Body.FILESIZE = filesize
reqMsg.Body.FILENAME = filepath[filepath.rindex('\\') + 1:]
msgId += 1
reqMsg.Header = Header(None)
reqMsg.Header.MSGID = msgId
reqMsg.Header.MSGTYPE = message.REQ_FILE_SEND
reqMsg.Header.BODYLEN = reqMsg.Body.GetSize()
reqMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
reqMsg.Header.LASTMSG = message.LASTMSG
reqMsg.Header.SEQ = 0
MessageUtil.send(sock, reqMsg)
rspMsg = MessageUtil.receive(sock)
if rspMsg.Header.MSGTYPE != message.REP_FILE_SEND:
print("정상적인 서버 응답이 아닙니다.{0}".format(rspMsg.Header.MSGTYTPE))
exit(0)
if rspMsg.Body.RESPONSE == message.DENIED:
def handle(self):
print("클라이언트 접속 : {0}".format(self.client_address[0]))
client = self.request # client socket
#클라이언트가 보내온 파일 전송 요청 메시지를 수신합니다.
reqMsg = MessageUtil.receive(client)
if reqMsg.Header.MSGTYPE != message.REQ_FILE_SEND:
client.close()
return
reqBody = BodyRequest(None)
print(
"파일 업로드 요청이 왔습니다. 수락하시겠습니까? yes/no")
answer = sys.stdin.readline()
rspMsg = Message()
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.ACCEPTED
rspMsg.Header = Header(None)
msgId = 0
rspMsg.Header.MSGID = msgId
msgId = msgId + 1
rspMsg.Header.MSGTYPE = message.REP_FILE_SEND
rspMsg.Header.BODYLEN = rspMsg.Body.GetSize()
rspMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rspMsg.Header.LASTMSG = message.LASTMSG
rspMsg.Header.SEQ = 0
if answer.strip() != "yes": #yes가 아닌 답을 입력하면 '거부'응답
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.DENIED
MessageUtil.send(client, rspMsg)
client.close()
return
else: #yes면 '승락'응답
MessageUtil.send(client, rspMsg)
print("파일 전송을 시작합니다...")
fileSize = reqMsg.Body.FILESIZE
fileName = reqMsg.Body.FILENAME
recvFileSize = 0
#업로드받을 파일을 생성합니다.
with open(upload_dir + "\\" + fileName, 'wb') as file:
dataMsgId = -1
prevSeq = 0
while True:
reqMsg = MessageUtil.receive(client)
if reqMsg == None:
break
print("#", end='')
if reqMsg.Header.MSGTYPE != message.FILE_SEND_DATA:
break
if dataMsgId == -1:
dataMsgId = reqMsg.Header.MSGID
elif dataMsgId != reqMsg.Header.MSGID:
break
if prevSeq != reqMsg.Header.SEQ: #메시지 순서가 어긋나면 중단.
print("{0}, {1}".format(prevSeq, reqMsg.Header.SEQ))
break
prevSeq += 1
#전송받은 파일의 일부를 담고 있는 bytes객체를
#서버에서 생성한 파일에 기록합니다.
recvFileSize += reqMsg.Body.GetSize()
file.write(reqMsg.Body.GetBytes())
#마지막 메시지면 반복문을 빠져나옴.
if reqMsg.Header.LASTMSG == message.LASTMSG:
break
file.close()
print()
print("수신 파일 크기 : {0} bytes".format(recvFileSize))
rstMsg = Message()
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.SUCCESS
rstMsg.Header = Header(None)
rstMsg.Header.MSGID = msgId
msgId += 1
rstMsg.Header.MSGTYPE = message.FILE_SEND_RES
rstMsg.Header.BODYLEN = rstMsg.Body.GetSize()
rstMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rstMsg.Header.LASTMSG = message.LASTMSG
rstMsg.Header.SEQ = 0
#파일 전송 요청에 담겨온 파일 크기와 실제 크기를 비교하여 같으면 성공.
if fileSize == recvFileSize:
MessageUtil.send(client, rstMsg)
else: #파일 크기에 이상이 있다면 실패 메시지를 보냅니다.
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.FAIL
MessageUtil.send(client, rstMsg)
print("파일 전송을 마쳤습니다.")
client.close()
def handle(self):
print('클라이언트 접속 : {0}'.format(self.client_address[0]))
client = self.request # client socket
# 클라이언트가 보내온 파일 전송 요청 메세지를 수신합니다.
reqMsg = MessageUtil.receive(client)
if reqMsg.Header.MSGTYPE != message.REQ_FILE_SEND:
client.close()
return
reqBody = BodyRequest(None)
print('파일 업로드 요청이 왔습니다. 수락하시겠습니까? yse/no')
answer = sys.stdin.readline()
rspMsg = Message()
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.ACCEPTED
rspMsg.Header = Header(None)
msgId = 0
rspMsg.Header.MSGID = msgId
msgId = msgId + 1
rspMsg.Header.MSGTYPE = message.REP_FILE_SEND
rspMsg.Header.BODYLEN = rspMsg.Body.GetSize()
rspMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rspMsg.Header.LASTMSG = message.LASTMSG
rspMsg.Header.SEQ = 0
if answer.strip() != 'yes':
# 사용자가 'yes'가 아닌 답을 입력하면 클라이언트에게 '거부' 응답을 보냅니다.
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.DENIED
MessageUtil.send(client, rspMsg)
client.close()
return
else:
# 물론 'yes'를 입력하면 클라이언트에게 '승낙' 응답을 보냅니다.
MessageUtil.send(client, rspMsg)
print('파일 전송을 시작합니다.')
fileSize = reqMsg.Body.FILESIZE
fileName = reqMsg.Body.FILENAME
recvFileSize = 0
with open(upload_dir + '\\' + fileName, 'wb') as file:
dataMsgId = -1
prevSeq = 0
while True:
reqMsg = MessageUtil.receive(client)
if reqMsg == None:
break
print('#', end='')
if reqMsg.Header.MSGTYPE != message.FILE_SEND_DATA:
break
if dataMsgId == -1:
dataMsgId = reqMsg.Header.MSGID
elif dataMsgId != reqMsg.Header.MSGID:
break
if prevSeq != reqMsg.Header.SEQ:
# 메세지 순서가 어긋나면 전송 중단
print('{0}, {1]'.format(prevSeq, reqMsg.Header.SEQ))
break
prevSeq += 1
# 전송받은 파일의 일부를 담고 있는 bytes 객체를 서버에서 생성한 파일에 기록합니다.
recvFileSize += reqMsg.Body.GetSize()
file.write(reqMsg.Body.GetBytes())
# 마지막 메세지면 반복문을 빠져나옵니다.
if reqMsg.Header.LASTMSG == message.LASTMSG:
break
file.close()
print()
print('수신 파일 크기 : {0} bytes'.format(recvFileSize))
rstMsg = Message()
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.SUCCESS
rstMsg.Header = Header(None)
rstMsg.Header.MSGID = msgId
msgId += 1
rstMsg.Header.MSGTYPE = message.FILE_SEND_RES
rstMsg.Header.BODYLEN = rstMsg.Body.GetSize()
rstMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rstMsg.Header.LASTMSG = message.LASTMSG
rstMsg.Header.SEQ = 0
if fileSize == recvFileSize:
# 파일 전송 요청에 담겨온 파일 크기와 실제로 받은 파일의 크기를 비교하여 같으면 성공 메세지를 보냅니다.
MessageUtil.send(client, rstMsg)
else:
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.FAIL
#파일 크기에 이상이 있다면 실패 메세지를 보냅니다.
MessageUtil.send(client, rstMsg)
print('파일 전송을 마쳤습니다.')
client.close()
def handle(self):
ex.textLog.append('[-] Client Connection: {0}'.format(self.client_address[0]))
ex.textLog.moveCursor(QTextCursor.End)
client = self.request # client socket
reqMsg = MessageUtil.receive(client) # Receive a file transfer request message sent by the client.
if reqMsg.Header.MSGTYPE != message.REQ_FILE_SEND:
client.close()
return
reqBody = BodyRequest(None)
print("Do you want to accept? (yes / no):")
answer = sys.stdin.readline()
rspMsg = Message()
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.ACCEPTED
rspMsg.Header = Header(None)
msgId = 0
rspMsg.Header.MSGID = msgId
msgId = msgId + 1
rspMsg.Header.MSGTYPE = message.REP_FILE_SEND
rspMsg.Header.BODYLEN = rspMsg.Body.GetSize()
rspMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rspMsg.Header.LASTMSG = message.LASTMSG
rspMsg.Header.SEQ = 0
if answer.strip() != "yes": # If 'yes' is not entered, send a 'reject' answer to the client.
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.DENIED
MessageUtil.send(client, rspMsg)
client.close()
return
else:
MessageUtil.send(client, rspMsg) # Sends a "Accept" answer to the client when 'Yes' is entered.
ex.textLog.append('Start file request...')
ex.textLog.moveCursor(QTextCursor.End)
fileSize = reqMsg.Body.FILESIZE
fileName = reqMsg.Body.FILENAME
recvFileSize = 0
with open(upload_dir + "\\" + fileName, 'wb') as file: # Create an upload file.
fragmentedCnt = 0
dataMsgId = -1
prevSeq = 0
while True:
reqMsg = MessageUtil.receive(client)
if reqMsg == None:
break
if reqMsg.Header.MSGTYPE != message.FILE_SEND_DATA:
break
if dataMsgId == -1:
dataMsgId = reqMsg.Header.MSGID
elif dataMsgId != reqMsg.Header.MSGID:
break
if prevSeq != reqMsg.Header.SEQ: # Stop the if the message goes out of order.
ex.textLog.append('{0}, {1}\n'.format(prevSeq, reqMsg.Header.SEQ))
ex.textLog.moveCursor(QTextCursor.End)
break
fragmentedCnt += 1
prevSeq += 1
recvFileSize += reqMsg.Body.GetSize() # Record the byte object some of the transferred files in a file created by the server.
file.write(reqMsg.Body.GetBytes())
if reqMsg.Header.LASTMSG == message.LASTMSG: # The last message is out of the loop.
break
ex.textLog.append('')
file.close()
ex.textLog.append('# Fragmented count: {0}'.format(fragmentedCnt))
ex.textLog.moveCursor(QTextCursor.End)
ex.textLog.append('Receive file size : {0} bytes\n'.format(recvFileSize))
ex.textLog.moveCursor(QTextCursor.End)
rstMsg = Message()
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.SUCCESS
rstMsg.Header = Header(None)
rstMsg.Header.MSGID = msgId
msgId += 1
rstMsg.Header.MSGTYPE = message.FILE_SEND_RES
rstMsg.Header.BODYLEN = rstMsg.Body.GetSize()
rstMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rstMsg.Header.LASTMSG = message.LASTMSG
rstMsg.Header.SEQ = 0
if fileSize == recvFileSize: # Compare the size of the file in the file transfer request with \
MessageUtil.send(client, rstMsg) # the size of the file actually received and send a success message if.
else:
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.FAIL
MessageUtil.send(client, rstMsg) # If there is a problem with the file size, send a failure message.
ex.textLog.append('File transfer complete.\n')
ex.textLog.moveCursor(QTextCursor.End)
client.close()
def clientStart(self, bindIP, bindPort, bindpath):
global CHUNK_SIZE
startIP = bindIP
startPort = bindPort
startPath = bindpath
sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM) # Create a TCP socket
try:
self.textLog.append('[-] Server: {0}:{1}\n'.format(
startIP, startPort))
self.textLog.moveCursor(QTextCursor.End)
sock.connect((startIP, startPort)) # Accept Connection Request
msgId = 0
reqMsg = Message()
filesize = os.path.getsize(startPath)
reqMsg.Body = BodyRequest(None)
reqMsg.Body.FILESIZE = filesize
reqMsg.Body.FILENAME = os.path.basename(startPath)
msgId += 1
reqMsg.Header = Header(None)
reqMsg.Header.MSGID = msgId
reqMsg.Header.MSGTYPE = message.REQ_FILE_SEND
reqMsg.Header.BODYLEN = reqMsg.Body.GetSize()
reqMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
reqMsg.Header.LASTMSG = message.LASTMSG
reqMsg.Header.SEQ = 0
MessageUtil.send(
sock, reqMsg
) # Connect to the server, the client sends a file transfer request message.
rspMsg = MessageUtil.receive(
sock) # Receive a response from the server
if rspMsg.Header.MSGTYPE != message.REP_FILE_SEND:
self.textLog.append(
'This is not a normal server response.\n{0}\n'.format(
rspMsg.Header.MSGTYPE))
self.textLog.moveCursor(QTextCursor.End)
exit(0)
if rspMsg.Body.RESPONSE == message.DENIED:
self.textLog.append('The server refused to send the file.\n')
self.textLog.moveCursor(QTextCursor.End)
exit(0)
with open(
os.path.relpath(startPath), 'rb'
) as file: # Prepare to open the file and send it to the server.
totalRead = 0
msgSeq = 0 # ushort
fragmented = 0 # byte
fragmentedCnt = 0
if filesize < CHUNK_SIZE:
fragmented = message.NOT_FRAGMENTED
else:
fragmented = message.FRAGMENTED
while totalRead < filesize:
rbytes = file.read(CHUNK_SIZE)
totalRead += len(rbytes)
fileMsg = Message()
fileMsg.Body = BodyData(
rbytes) # Send the file to the server
# in a 0x03 message before the transfer is complete.
header = Header(None)
header.MSGID = msgId
header.MSGTYPE = message.FILE_SEND_DATA
header.BODYLEN = fileMsg.Body.GetSize()
header.FRAGMENTED = fragmented
if totalRead < filesize:
header.LASTMSG = message.NOT_LASTMSG
else:
header.LASTMSG = message.LASTMSG
header.SEQ = msgSeq
msgSeq += 1
fragmentedCnt += 1
fileMsg.Header = header
MessageUtil.send(sock, fileMsg)
self.textLog.append(
'# Fragmented count: {0}'.format(fragmentedCnt))
self.textLog.moveCursor(QTextCursor.End)
rstMsg = MessageUtil.receive(
sock) # Get a receive to see if it's been sent properly
result = rstMsg.Body
self.textLog.append('File Receive Success: {0}\n'.format(
result.RESULT == message.SUCCESS))
self.textLog.moveCursor(QTextCursor.End)
except Exception as err:
self.textLog.append('Exception has occurred.\n{0}\n'.format(err))
self.textLog.moveCursor(QTextCursor.End)
sock.close()
self.textLog.append('The client finished.\n')
self.textLog.moveCursor(QTextCursor.End)
def handle(self):
print("connect client : {0}".format(self.client_address[0]))
client = self.request # client socket
reqMsg = MessageUtil.receive(client)
if reqMsg.Header.MSGTYPE != message.REP_FILE_SEND:
client.close()
return
reqBody = BodyRequest(None)
print("Request File Upload...., Can you sure? (yes / no)")
answer = sys.stdin.readline()
rspMsg = Message()
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.ACCEPTED
rspMsg.Header = Header(None)
msgId = 0
rspMsg.Header.MSGID = msgId
msgId = msgId + 1
rspMsg.Header.MSGTYPE = message.REP_FILE_SEND
rspMsg.Header.BODYLEN = rspMsg.Body.GetSize()
rspMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rspMsg.Header.LASTMSG = message.LASTMSG
rspMsg.Header.SEQ = 0
if answer.strip() != "yes":
rspMsg.Body = BodyResponse(None)
rspMsg.Body = reqMsg.Header.MSGID
rspMsg.RESPONSE = message.DENIED
MessageUtil.send(client, rspMsg)
client.close()
return
else:
MessageUtil.send(client, rspMsg)
print("starting send file.....")
fileSize = reqMsg.Body.FILESIZE
fileName = reqMsg.Body.FILENAME
recvFileSize = 0
with open(upload_dir + "\\" + fileName, 'wb') as file:
dataMsgId = -1
prevSeq = 0
while True:
reqMsg = MessageUtil.receive(client)
if reqMsg == None:
break
print("#", end='')
if reqMsg.Header.MSGTYPE != message.FILE_SEND_DATA:
break
if dataMsgId == -1:
dataMsgId = reqMsg.Header.MSGID
elif dataMsgId != reqMsg.Header.MSGID:
break
if prevSeq != reqMsg.Header.SEQ:
print("{0}, {1}".format(prevSeq, reqMsg.Header.SEQ))
break
prevSeq += 1
recvFileSize += reqMsg.Body.GetSize()
file.write(reqMsg.Body.GetBytes())
if reqMsg.Header.LASTMSG == message.LASTMSG:
break
file.close()
print()
print("received file size :{0} bytes".format(recvFileSize))
rstMsg = Message()
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MGSID
rstMsg.Body.RESULT = message.SUCCESS
rstMsg.Header = Header(None)
rstMsg.Header.MGSID = msgId
msgId += 1
rstMsg.Header.MSGTYPE = message.FILE_SEND_RES
rstMsg.Header.BODYLEN = rstMsg.Body.GetSize()
rstMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rstMsg.Header.LASTMSG = message.LASTMSG
rstMsg.Header.SEQ = 0
if fileSize == recvFileSize:
MessageUtil.send(client, rstMsg)
else:
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.FAIL
MessageUtil.send(client, rstMsg)
print("finished send file.....")
client.close()
def sendImage():
filepath = "/home/pi/ABO2/image.jpg"
#서버와 연결된 소켓 객체 생성
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
#서버 연결 요청
sock.connect(("192.168.0.57", 8080))
#요청메시지 생성
requestMsg = Message()
filesize = os.path.getsize(filepath)
#요청메시지 바디 생성 - 파일전송요청 객체 생성
requestMsg.Body = BodyRequest(None)
requestMsg.Body.FILESIZE = filesize
requestMsg.Body.FILENAME = filepath[filepath.rindex("/")+1:]
#요청메시지 헤더 생성
requestMsg.Header = Header(None)
requestMsg.Header.MSGID = 1
requestMsg.Header.MSGTYPE = message.REQ_FILE_SEND
requestMsg.Header.BODYLEN = requestMsg.Body.GetSize()
requestMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
requestMsg.Header.LASTMSG = message.LASTMSG
requestMsg.Header.SEQ = 0
#요청메시지 전송
MessageUtil.send(sock, requestMsg)
#응답메시지 읽기
responseMsg = MessageUtil.receive(sock)
if responseMsg.Header.MSGTYPE != message.REP_FILE_SEND: #파일응답코드가 아니면 종료
exit(0)
if responseMsg.Body.RESPONSE ==message.DENIED: #서버가 거부하면 종료
exit(0)
#파일 읽기
with open(filepath, "rb") as file:
totalsize = 0
msgSEQ = 0
fragmented = 0
if filesize < 4096: #메시지분할여부 - 4096바이트 이상이면 분할
fragmented = message.NOT_FRAGMENTED
else:
fragmented = message.FRAGMENTED
while totalsize<filesize:
readBytes = file.read(4096)
totalsize += len(readBytes)
#파일전송메시지 생성
fileMsg = Message()
#파일전송메시지 바디 생성 - 파일전송데이터 객체 생성
fileMsg.Body = BodyData(readBytes)
#파일전송메시지 헤더 생성
fileMsg.Header = Header(None)
fileMsg.Header.MSGID = 2
fileMsg.Header.MSGTYPE = message.FILE_SEND_DATA
fileMsg.Header.BODYLEN = fileMsg.Body.GetSize()
fileMsg.Header.FRAGMENTED = fragmented
fileMsg.Header.SEQ = msgSEQ
if totalsize < filesize:
fileMsg.Header.LASTMSG = message.NOT_LASTMSG
else:
fileMsg.Header.LASTMSG = message.LASTMSG
msgSEQ += 1 #메시지 번호 1증가
print("#", end="")
#파일전송메시지 전송
MessageUtil.send(sock, fileMsg)
#//end while
#파일닫기
file.close()
#//end with open
print()
golobal resultM
resultM = str(sock.recv(1024), "utf-8")
#결과메시지 읽기
resultMsg = MessageUtil.receive(sock)
result = resultMsg.Body
print("파일 전송 성공 : {0}".format(result.RESULT==message.SUCCESS))
except Exception as err:
print("예외발생 : "+err, end="")
#소켓닫기
sock.close()
print("클라이언트를 종료합니다.")
return resultM
totalRead = 0
msgSeq = 0 #ushort
fragmented = 0 #byte
if filesize < CHUNK_SIZE:
fragmented = message.NOT_FRAGMENTED
else:
fragmented = message.FRAGMENTED
while totalRead < filesize:
rbytes = file.read(CHUNK_SIZE)
totalRead += len(rbytes)
fileMsg = Message()
fileMsg.Body = BodyData(rbytes)
header = Header(None)
header.MSGID = msgId
header.MSGTYPE = message.FILE_SEND_DATA
header.BODYLEN = fileMsg.Body.GetSize()
header.FRAGMENTED = fragmented
if totalRead < filesize:
header.LASTMSG = message.NOT_LASTMSG
else:
header.LASTMSG = message.LASTMSG
header.SEQ = msgSeq
msgSeq += 1
fileMsg.Header = header
print("#", end = '')
def handle(self):
print("클라이언트 : {0} 접속".format(self.client_address[0]))
#클라이언트와 연결된 소켓 객체 생성
sock = self.request
#클라이언트로부터 Message(header+body)를 읽는다
#요청메시지 읽기
requestMsg = MessageUtil.receive(sock)
if requestMsg.Header.MSGTYPE != message.REQ_FILE_SEND: #message.REQ_FILE_SEND : message모듈의 REQ_FILE_SEND변수
client.close()
return
#요청메시지 - 파일전송요청 객체 생성
bodyRequest = BodyRequest(None)
#응답메시지 생성
responseMsg = Message()
#응답메시지 바디 생성 - 파일전송응답 객체 생성
responseMsg.Body = BodyResponse(None)
responseMsg.Body.MSGID = requestMsg.Header.MSGID
responseMsg.Body.RESPONSE = message.ACCEPTED
#응답메시지 헤더 생성
responseMsg.Header = Header(None)
responseMsg.Header.MSGID = 1
responseMsg.Header.MSGTYPE = message.REP_FILE_SEND
responseMsg.Header.BODYLEN = responseMsg.Body.GetSize()
responseMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
responseMsg.Header.LASTMSG = message.LASTMSG
responseMsg.Header.SEQ = 0
#응답메시지 전송
MessageUtil.send(sock, responseMsg)
print("파일 전송을 시작합니다..")
#요청메시지에서 파일크기와 파일명을 가져온다
fileSize = requestMsg.Body.FILESIZE
fileName = requestMsg.Body.FILENAME
#읽어들인 파일크기
receiveFileSize = 0
#파일쓰기
with open(uploadDir + "/" + fileName, "wb") as file:
receiveMSGID = -1
previousSEQ = 0
while True:
#파일전송메시지 읽기
receiveMsg = MessageUtil.receive(sock)
if receiveMsg == None: #receiveMsg가 none이거나 파일전송데이터 타입이 아니면 종료
break
if receiveMsg.Header.MSGTYPE != message.FILE_SEND_DATA:
break
if receiveMSGID == -1: #MSGID가 다르면 종료
receiveMSGID = receiveMsg.Header.MSGID
elif receiveMSGID != receiveMsg.Header.MSGID:
break
if previousSEQ != receiveMsg.Header.SEQ: #SEQ(메시지 파편 번호)순서가 틀려지면 종료
print("{0} , {1}".format(previousSEQ,
receiveMsg.Header.SEQ))
break
print("#", end="")
previousSEQ += 1
#파일쓰기
file.write(receiveMsg.Body.GetBytes())
receiveFileSize += receiveMsg.Body.GetSize()
#마시막 메시지이면 종료
if receiveMsg.Header.LASTMSG == message.LASTMSG:
break
#//end - while
#파일닫기
file.close()
#//end - with open
print()
print("수신된 파일 크기 : {0} bytes".format(receiveFileSize))
#수신결과메시지 생성
resultMsg = Message()
#수신결과메시지 바디 생성 - 파일수신결과 객체 생성
resultMsg.Body = BodyResult(None)
resultMsg.Body.MSGID = requestMsg.Header.MSGID
resultMsg.Body.RESULT = message.SUCCESS
#수신결과메시지 헤더 생성
resultMsg.Header = Header(None)
resultMsg.Header.MSGID = 2
resultMsg.Header.MSGTYPE = message.FILE_SEND_RES
resultMsg.Header.BODYLEN = resultMsg.Body.GetSize()
resultMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
resultMsg.Header.LASTMSG = message.LASTMSG
resultMsg.Header.SEQ = 0
#수신받은 파일크기와 헤더의 파일크기정보가 같으면 성공
if fileSize == receiveFileSize:
resultM = label_image.deduction()
sock.sendall(resultM.encode())
MessageUtil.send(sock, resultMsg) #수신결과메시지 전송
else:
resultMsg.Body = BodyResult(None)
resultMsg.Body.MSGID = reqMsg.Header.MSGID
resultMsg.Body.RESULT = message.FAIL
MessageUtil.send(client, rstMsg) #수신결과메시지 전송
print("파일 전송을 마쳤습니다.")
#소켓닫기
sock.close()
from message_body import RREQ
from message_header import Header
from message import Message
import sys
from test3 import RREQ2
reqMessage = Message()
body = RREQ("0x35bB94eB7DDce99DEbf7e482Fb9f30203Ba32DC0",
"0x35bB94eB7DDce99DEbf7e482Fb9f30203Ba32DC0",
"0x35bB94eB7DDce99DEbf7e482Fb9f30203Ba32DC0", 100, [
"0x35bB94eB7DDce99DEbf7e482Fb9f30203Ba32DC0",
"0x35bB94eB7DDce99DEbf7e482Fb9f30203Ba32DC0"
], [100, 200])
bodyLen = sys.getsizeof(body)
print("bodyLen :", bodyLen)
header = Header(5, 3, bodyLen)
reqMessage.Body = body
reqMessage.Header = header
byte = reqMessage.GetBytes()
print(sys.getsizeof(byte))
def handle(self):
print("클라이언트 접속 : {0}".format(self.client_address[0]))
client = self.request
reqMsg = MessageUtil.receive(client)
if reqMsg.Header.MSGTYPE != message.REQ_FILE_SEND:
client.close()
return
reqBody = BodyRequest(None)
print("파일 업로드 요청이 왔습니다. 수락하시겠습니까? yes/no")
answer = sys.stdin.readline()
rspMsg = Message()
rspMsg.Body = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.ACCEPTED
rspMsg.Header = Header(None)
msgId = 0
rspMsg.Header.MSGID = msgId
msgId = msgId + 1
rspMsg.Header.MSGTYPE = message.REP_FILE_SEND
rspMsg.Header.BODYLEN = rspMsg.Body.GetSize()
rspMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rspMsg.Header.LASTMSG = message.LASTMSG
rspMsg.Header.SEQ = 0
if answer.strip() != "yes":
rspMsg.Bodyy = BodyResponse(None)
rspMsg.Body.MSGID = reqMsg.Header.MSGID
rspMsg.Body.RESPONSE = message.DENIED
MessageUtil.send(client, rspMsg)
client.close()
return
else:
MessageUtil.send(client, rspMsg)
print("파일 전송을 시작합니다...")
fileSize = reqMsg.Body.FILESIZE
fileName = reqMsg.Body.FIILENAME
recvFileSize = 0
with open(upload_dir + "\\" + fileName, 'wb') as file:
dataMsgId = -1
prevSeq = 0
while True:
reqMsg = MessageUtil.receive(client)
if reqMsg == None:
break
print("#", end='')
if reqMsg.Header.MSGTYTPE != message.FILE_SEND_DATA:
break
if dataMsgId == -1:
dataMsgId = reqMsg.Header.MSGID
elif dataMsgId != reqMsg.Header.MSGID:
break
if prevSeq != reqMsg.Header.SEQ:
print("{0}, {1}".format(prevSeq, reqMsg.Header.SEQ))
break
prevSeq += 1
recvFileSize += reqMsg.Body.GetSize()
file.write(reqMsg.Body.GetBytes())
if reqMsg.Header.LASTMSG == message.LASTMSG:
break
file.close()
print()
print("수신 파일 크기 : {0} bytes".format(recvFileSize))
rstMsg = message()
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.SUCCESS
rstMsg.Header = Header(None)
rstMsg.Header.MSGID = msgId
msgId += 1
rstMsg.Header.MSGTYPE = message.FILE_SEND_RES
rstMsg.Header.BODYLEN = rstMsg.Body.GetSize()
rstMsg.Header.FRAGMENTED = message.NOT_FRAGMENTED
rstMsg.Header.LASTMSG = message.LSTMSG
rstMsg.Header.SEQ = 0
if fileSize == recvFileSize:
MessageUtil.send(client, rstMsg)
else:
rstMsg.Body = BodyResult(None)
rstMsg.Body.MSGID = reqMsg.Header.MSGID
rstMsg.Body.RESULT = message.FAIL
MessageUtil.send(client, rstMsg)
print("파일 전송을 마쳤습니다.")
client.close()