home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume14 / 3bconnect / ftp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-05-08  |  6.9 KB  |  279 lines
  1. /*
  2.  * ftp.c: the 'file transfer' protocols.
  3.  * Sliding-window protocol with selective retransmit.
  4.  */
  5. #include "ni.h"
  6.  
  7. #include "ftp.h"
  8.  
  9. extern char *sys_errlist[];
  10. int debug;
  11.  
  12. #define NULL 0
  13. #define slotno(num) ((num) % WINDOW)
  14.  
  15. struct request buffer[WINDOW];
  16. struct request *packet[WINDOW];
  17. int retry = 0;
  18. sequence_t lower, upper, num;
  19.  
  20. wakeup(){
  21.     signal(SIGALRM, wakeup);
  22. } 
  23. /*
  24.  * ftpout: send the file to the indicated host.
  25.  */
  26. ftpout(f, addr)
  27. char *addr;
  28. {
  29.     struct request ackreq, *ack = &ackreq;
  30.     register struct request *r;
  31.     register int n;
  32.     int i, eof = 0;
  33.     lower = upper = num = 0;
  34.     retry = 0;
  35.     for(i=0;i<WINDOW;i++) packet[i] = NULL;
  36.     wakeup();
  37.     while(1) {
  38. /*
  39.  * If the window is not sent, send another packet.
  40.  * If last packet was null, then all data has been sent.
  41.  */
  42.         while(!fullwindow(lower, upper) && !eof) {
  43.              num = upper++;
  44.              r = &buffer[slotno(num)];
  45.              packet[slotno(num)] = r;
  46.             r->r_sequence = num;
  47.             n = read(f, r->r_data, sizeof r->r_data);
  48. /*
  49.  * read error causes premature EOF
  50.  */
  51.             if(n == -1) n = 0;
  52.             if(debug) 
  53.                 printf("Sending packet %d\n", r->r_sequence);
  54. /*
  55.  * Reset the counter for ack timeouts, then send out the block
  56.  */
  57.             retry = 0;
  58.             send(r, n, DATA, addr);
  59.             if(n == 0) eof = 1;
  60.         }
  61. /* 
  62.  * We have to wait for an ACK from the other end ...
  63.  * If it's an ACK, then the sequence field determines which packet is OK
  64.  * If it's a NACK, then the data is a list of packets which 
  65.  * must have got lost somewhere. so we re-transmit them.
  66.  */
  67.         if(debug) printf("Window full - waiting for ack\n");
  68.          alarm(TRANSIT);
  69.         recv(ack);
  70.         alarm(0);
  71.         switch(ack->r_type) {
  72. /*
  73.  * ACK - mark the packet as sent (delete pointer).
  74.  * Move lower bound of window up as far as possible.
  75.  */
  76.         case ACCEPT:
  77.             if(debug)
  78.                 printf("Got ack on packet %d\n", ack->r_sequence);
  79.             release(ack->r_sequence);
  80.             break;
  81.         case REJECT:
  82.             if(debug)
  83.                 printf("Got reject (ack packet %d)\n", ack->r_sequence);
  84.             release(ack->r_sequence);
  85.             for(i=0;i<ack->r_size;i++) {
  86.                 if(debug) 
  87.                     printf("\tpacket %d\n", ack->r_data[i]);
  88.                 r = packet[slotno(ack->r_data[i])];
  89.                 if(inwindow(ack->r_data[i], lower, upper))
  90.                     send(r, r->r_size, DATA, addr);
  91.             }
  92.             break;
  93. /*
  94.  * Timeout waiting for ACK - retransmit all the outstanding packets.
  95.  */
  96.         case UNDEFINED:
  97.             printf("Timeout\n");
  98.             if(retry++ > MAXRETRY) {
  99.                 printf("Too many timeouts - ftp abort\n");
  100.                 n = sprintf(ack->r_data, "Too many timeouts");
  101.                 send(ack, n, TERMINATE, addr);
  102.                 exit(0);
  103.             }
  104.             for(i=0;i<WINDOW;i++) if(packet[i])
  105.                 send(packet[i], packet[i]->r_size, DATA, addr);
  106.             break;
  107.          default:
  108.             printf("Illegal ack type %d\n", ack->r_type);
  109.         } /* end switch */
  110. /*
  111.  * If we've transmitted all the data, and got acks back for all the packets
  112.  * then the transfer is complete.
  113.  */
  114.          if(eof && debug) 
  115.              printf("EOF - waiting to clear %d - %d\n", lower, upper);
  116.         if(eof && (upper == lower)) return(1);
  117.     } /* end data loop */
  118. }
  119. /*
  120.  * ftpin: recv data, plonk in file.
  121.  * Packet with data size 0 ends file transmission.
  122.  */
  123. ftpin(f, addr, kb)
  124. char *addr;
  125. long *kb;            /* data size received */
  126. {
  127.     register struct request *r;
  128.     long count = 0;
  129.     int i, eof = 0;
  130.     struct request ackreq, *ack = &ackreq;
  131.     register int n;
  132.     sequence_t slot, datablock, last, diskblock = 0;
  133.     lower = num = 0;
  134.     upper = WINDOW - 1;
  135.     datablock = 0;
  136.     for(i=0;i<WINDOW;i++) packet[i] = NULL;
  137.     while(1) {
  138. /*
  139.  * Zero received buffer space, so we know what has got here
  140.  */
  141.         retry = 0;
  142.         if(debug) 
  143.             printf("Waiting for %d - %d, using buffer %d\n", 
  144.                 lower, lower + WINDOW, slotno(datablock));
  145.         r = &buffer[slotno(datablock++)];    /* get a buffer */
  146.         recv(r);
  147.         switch(r->r_type) {
  148. /*
  149.  * Normal data - fix in the correct place
  150.  * If we missed packets in the sequence, ask for them again.
  151.  */
  152.         case DATA:
  153.             upper = lower + WINDOW - 1;
  154.             if(debug) printf("Received packet %d, size %d\n", 
  155.                 r->r_sequence, r->r_size);
  156. /*
  157.  * incoming packet not within our current window. The ack for a previous
  158.  * packet must have got lost - send it again!
  159.  * If the packet doesn't seem to fit anywhere, complain!
  160.  */
  161.             if(!inwindow(r->r_sequence, lower, upper)) {
  162.                 if(inwindow(r->r_sequence, lower - WINDOW, lower)) {
  163.                     ack->r_sequence = r->r_sequence;
  164.                     send(ack, 0, ACCEPT, addr);
  165.                 }
  166.                 else {
  167.                     if(debug) printf("packet %d out of bounds %d - %d\n",
  168.                     r->r_sequence, lower, upper);
  169.                     n = sprintf(ack->r_data, "protocol violation: packet %d arrived in window %d - %d\n",
  170.                         r->r_sequence, lower, upper);
  171.                     send(ack, n, TERMINATE, addr);
  172.                     exit(0);
  173.                 }
  174.                 datablock--;
  175.                 continue;        /* out of window */
  176.             }
  177.             slot = slotno(r->r_sequence);
  178.             if(packet[slot]) {
  179.                 if(debug) printf("Duplicate - ignored\n");
  180.                 datablock--;
  181.                 continue;    /* duplicate */
  182.             }
  183.             packet[slot] = r;
  184.             count += r->r_size;
  185. /*
  186.  * Check for eof, and send ack for this packet.
  187.  */
  188.             if(r->r_size == 0) {
  189.                 eof = 1;
  190.                 last = r->r_sequence;
  191.             }
  192.             ack->r_sequence = r->r_sequence;
  193.             send(ack, 0, ACCEPT, addr);
  194. /*
  195.  * Write as many packets as possible.
  196.  */
  197.              while(r = packet[slotno(lower)]) {
  198.                  if(debug) 
  199.                     printf("Packet %d written to disk\n", r->r_sequence);
  200.                 if(r->r_sequence != diskblock++) {
  201.                     printf("Bug detected! data block %d written as disk block %d\n",
  202.                         r->r_sequence, datablock - 1);
  203.                     n = sprintf(ack->r_data, "data block sequence error");
  204.                     send(ack, n, TERMINATE, addr);
  205.                     exit(1);
  206.                 }
  207.                  if(write(f, r->r_data, r->r_size) != r_size) {
  208.                      perror("write error");
  209.                      n = sprintf(ack->r_data, "write error: %s",
  210.                          sys_errlist[errno]);
  211.                      send(ack, n, TERMINATE, addr);
  212.                      exit(1);
  213.                  }
  214.                  packet[slotno(lower)] = NULL;
  215.                  lower++;
  216.              }
  217.             break;
  218.         default:
  219.             printf("Illegal ftp packet %d\n", r->r_type);
  220.         }    /* end switch */
  221.         if(eof && (lower == (last + 1))) {
  222.             *kb = count;
  223.             return(1);
  224.         }
  225.     } /* end data loop */
  226. }
  227. /*
  228.  * Check if 'num' falls between lbound and ubound
  229.  */
  230. inwindow(number, lbound, ubound)
  231. sequence_t number, lbound, ubound;
  232. {
  233.     while(1) {
  234.         if(number == lbound) return(1);
  235.         if(lbound == ubound) return(0);
  236.         else lbound++;
  237.     }
  238. }
  239. /*
  240.  * retransmit: we were looking for packet 'last', but got packet 'this'
  241.  * Ask for retransmit of intervening packets - this also acks packet 'this'
  242.  */
  243. retransmit(last, this, ack, addr)
  244. sequence_t last, this;
  245. register struct request *ack;
  246. char *addr;
  247. {
  248.     int j, n = 0;
  249.     for(j=0;j<WINDOW;j++) if(packet[j] == NULL)
  250.         ack->r_data[n++] = (sequence_t) lower + j;
  251.     ack->r_sequence = this;
  252.     send(ack, n, REJECT, addr);
  253. }
  254. /*
  255.  * release: mark packet 'n' as being succesfully received.
  256.  * Move lower bound of window up, if possible.
  257.  */
  258. release(n)
  259. sequence_t n;
  260. {
  261.     packet[slotno(n)] = NULL;
  262.     while(packet[slotno(lower)] == NULL) {
  263.         lower++;
  264.         if(lower == upper) break;
  265.     }
  266.     if(debug) printf("Packet %d released - lbound now %d\n", n, lower);
  267. }
  268. /*
  269.  * fullwindow: if distance between lower and upper is >= WINDOW
  270.  */
  271. fullwindow(lower, upper)
  272. register sequence_t lower, upper;
  273. {
  274.     register int n = 0;
  275.     while(lower++ != upper) n++;
  276.     if(n >= WINDOW) return(1);
  277.     return(0);
  278. }
  279.