예제 #1
0
    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
예제 #2
0
    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
예제 #3
0
    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
예제 #4
0
    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
예제 #5
0
    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
예제 #7
0
    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()
예제 #8
0
    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()
예제 #9
0
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]))
        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()
예제 #11
0
    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()
예제 #12
0
파일: client.py 프로젝트: HyeonTae/CanC
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
예제 #13
0
    serverIp   = sys.argv[1]
    serverPort = 5425
    filepath   = sys.argv[2]
    
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        
    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)
예제 #14
0
    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()
예제 #15
0
    serverIp = sys.argv[1]
    serverPort = 5425
    filepath = sys.argv[2]

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    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)
예제 #16
0
    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()
예제 #17
0
    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)
예제 #18
0
    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()
예제 #19
0
    serverIp = sys.argv[1]
    serverPort = 5425
    filepath = sys.argv[2]

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # TCP 소켓을 생성한다.

    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 = os.path.basename(filepath)

        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)  # 그리고 서버의 응답을 받는다.
예제 #20
0
    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":
            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)

            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

                    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()
예제 #21
0
    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()