def rdt_send(clientAddr, data):
  global TO_SEND_SEQ
  global SEND_BUF
  global SEND_BUF_SEQ
  global TIMER
  global EXPIRED
  TIMER = threading.Timer(TIMER_SET, timerHandler)
  TIMER.start()
  print 'TIMER should start'
  endSignal = 1
  checkpoint = 0
  while 1:
    if len(SEND_BUF_SEQ) < N:
      m = prepareDatagram(TO_SEND_SEQ, data)
      if not m:
        if endSignal == 1:
          endSignal = 0
          m = util.buildHeader(TO_SEND_SEQ, 'END', 2)
          m += 'END'
        elif len(SEND_BUF_SEQ) == 0:
          break
        else:
          checkpoint = 1

      if checkpoint == 0:
        try:
          THREAD_LOCK.acquire()
          s.sendto(m, clientAddr)
          SEND_BUF.append(m)
          SEND_BUF_SEQ.append(TO_SEND_SEQ)
          # print "TO_SEND_SEQ: " + str(TO_SEND_SEQ)
          TO_SEND_SEQ = TO_SEND_SEQ + 1
          # time.sleep(0.01)
          THREAD_LOCK.release()
        except socket.error, msg:
          print 'Error Code : ' + str(msg[0]) + ' Message ' + msg[1]
          sys.exit()
          
    if EXPIRED == 1 and len(SEND_BUF) > 0:
      # print "waiting to resend all..."
      print "Time Out, sequence number = " + str(SEND_BUF_SEQ[0]*MSS)
      THREAD_LOCK.acquire()
      TIMER.cancel()
      # TIMER.join()
      THREAD_LOCK.release()
      THREAD_LOCK.acquire()
      # print "SEND_BUF_SEQ: " + str(SEND_BUF_SEQ)
      for m in SEND_BUF:
        # errno, seq_no, dataText = util.parseDatagram(m, 0) 
        # print "IN RESEND" + str(seq_no)
        s.sendto(m, clientAddr)
      # print "SEND_BUF ALL SENT!!"
      THREAD_LOCK.release()
      EXPIRED = 0
      THREAD_LOCK.acquire()
      TIMER = threading.Timer(TIMER_SET, timerHandler)
      TIMER.start()
      THREAD_LOCK.release()
def rdt_send(clientAddr, data):
    global TO_SEND_SEQ
    global SEND_BUF
    global SEND_BUF_SEQ
    global TIMER
    global EXPIRED
    TIMER = threading.Timer(TIMER_SET, timerHandler)
    TIMER.start()
    print "TIMER should start"
    endSignal = 1
    checkpoint = 0
    while 1:
        if len(SEND_BUF_SEQ) < N:
            m = prepareDatagram(TO_SEND_SEQ, data)
            if not m:
                if endSignal == 1:
                    endSignal = 0
                    m = util.buildHeader(TO_SEND_SEQ, "END", 2)
                    m += "END"
                elif len(SEND_BUF_SEQ) == 0:
                    break
                else:
                    checkpoint = 1

            if checkpoint == 0:
                try:
                    THREAD_LOCK.acquire()
                    s.sendto(m, clientAddr)
                    SEND_BUF.append(m)
                    SEND_BUF_SEQ.append(TO_SEND_SEQ)
                    # print "TO_SEND_SEQ: " + str(TO_SEND_SEQ)
                    TO_SEND_SEQ = TO_SEND_SEQ + 1
                    # time.sleep(0.01)
                    THREAD_LOCK.release()
                except socket.error, msg:
                    print "Error Code : " + str(msg[0]) + " Message " + msg[1]
                    sys.exit()

        if EXPIRED == 1 and len(SEND_BUF) > 0:
            # print "waiting to resend all..."
            print "Time Out, sequence number = " + str(SEND_BUF_SEQ[0] * MSS)
            THREAD_LOCK.acquire()
            TIMER.cancel()
            # TIMER.join()
            THREAD_LOCK.release()
            THREAD_LOCK.acquire()
            # print "SEND_BUF_SEQ: " + str(SEND_BUF_SEQ)
            for m in SEND_BUF:
                # errno, seq_no, dataText = util.parseDatagram(m, 0)
                # print "IN RESEND" + str(seq_no)
                s.sendto(m, clientAddr)
            # print "SEND_BUF ALL SENT!!"
            THREAD_LOCK.release()
            EXPIRED = 0
            THREAD_LOCK.acquire()
            TIMER = threading.Timer(TIMER_SET, timerHandler)
            TIMER.start()
            THREAD_LOCK.release()
def prepareDatagram(seq_no, data):
  startIndex = seq_no * MSS
  content = data[startIndex:startIndex+MSS]
  
  if not content: return None

  # print "seq_no: " + str(seq_no)
  hdr = util.buildHeader(seq_no, content, 0)
  return hdr + content
def prepareDatagram(seq_no, data):
    startIndex = seq_no * MSS
    content = data[startIndex : startIndex + MSS]

    if not content:
        return None

    # print "seq_no: " + str(seq_no)
    hdr = util.buildHeader(seq_no, content, 0)
    return hdr + content
def FTPReceiver(s, p=0.05):
  global P                  # Probability of packet loss
  P = p
  
  # Initialize the Sequence number
  lastSEQNO = -1
  max_seq_no = -1
  firstTime = True
  MSS = 0
  oldSEQNO = -1
  buffer=""

 
  while 1:
    packet = s.recvfrom(1100)
    data = packet[0]
    serverAddr = packet[1]

    if not data:
      continue

    if firstTime:
      MSS = len(data) - 64
      firstTime = False

    # Simulate a random drop process
    randomNum = random.random()
    # print randomNum
    if randomNum <= P:
      if oldSEQNO != lastSEQNO:
        oldSEQNO = lastSEQNO
        print "Packet loss, sequence num = " + str((lastSEQNO + 1) * MSS)
      continue

    errno, seq_no, dataText = util.parseDatagram(data, 0) 
    # print "SEQ_NO:" + str(seq_no)
    # print "LAST_ACK:" + str(lastSEQNO)
    if seq_no > max_seq_no:
      max_seq_no = seq_no
    if errno == 0:
      if seq_no == lastSEQNO + 1:
        lastSEQNO = seq_no
        buffer+=dataText
      reply = util.buildHeader(lastSEQNO+1, '', 1)
      s.sendto(reply, serverAddr)
    elif errno == 1:
      print "Unmatched checksum, datagram is corrupted"
      break
    elif errno == 2:
      print "Unmatched indicator, datagram is corrupted"
      break
    else:
      if seq_no == lastSEQNO + 1:
        lastSEQNO = seq_no
      reply = util.buildHeader(lastSEQNO+1, '', 3)
      s.sendto(reply, serverAddr)
      if max_seq_no == lastSEQNO:
        print "Transfer finished!"
        print "SEQ_NO "+str((lastSEQNO+1)*MSS)+ " is sent!"
        break
  s.close()
  return buffer
예제 #6
0
def FTPReceiver(s, p=0.05):
    global P  # Probability of packet loss
    P = p

    # Initialize the Sequence number
    lastSEQNO = -1
    max_seq_no = -1
    firstTime = True
    MSS = 0
    oldSEQNO = -1
    buffer = ""

    while 1:
        packet = s.recvfrom(1100)
        data = packet[0]
        serverAddr = packet[1]

        if not data:
            continue

        if firstTime:
            MSS = len(data) - 64
            firstTime = False

        # Simulate a random drop process
        randomNum = random.random()
        # print randomNum
        if randomNum <= P:
            if oldSEQNO != lastSEQNO:
                oldSEQNO = lastSEQNO
                print "Packet loss, sequence num = " + str(
                    (lastSEQNO + 1) * MSS)
            continue

        errno, seq_no, dataText = util.parseDatagram(data, 0)
        # print "SEQ_NO:" + str(seq_no)
        # print "LAST_ACK:" + str(lastSEQNO)
        if seq_no > max_seq_no:
            max_seq_no = seq_no
        if errno == 0:
            if seq_no == lastSEQNO + 1:
                lastSEQNO = seq_no
                buffer += dataText
            reply = util.buildHeader(lastSEQNO + 1, '', 1)
            s.sendto(reply, serverAddr)
        elif errno == 1:
            print "Unmatched checksum, datagram is corrupted"
            break
        elif errno == 2:
            print "Unmatched indicator, datagram is corrupted"
            break
        else:
            if seq_no == lastSEQNO + 1:
                lastSEQNO = seq_no
            reply = util.buildHeader(lastSEQNO + 1, '', 3)
            s.sendto(reply, serverAddr)
            if max_seq_no == lastSEQNO:
                print "Transfer finished!"
                print "SEQ_NO " + str((lastSEQNO + 1) * MSS) + " is sent!"
                break
    s.close()
    return buffer