3600recv.c

/*
 * CS3600, Spring 2013
 * Project 4 Starter Code
 * (c) 2013 Alan Mislove
 *
 */

#include <math.h>
#include <ctype.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "3600sendrecv.h"

// all sequence numbers prior to and inlcuding this
// number have been received
int last_rec = -1;

int main() {
  /**
   * I've included some basic code for opening a UDP socket in C, 
   * binding to a empheral port, printing out the port number.
   * 
   * I've also included a very simple transport protocol that simply
   * acknowledges every received packet.  It has a header, but does
   * not do any error handling (i.e., it does not have sequence 
   * numbers, timeouts, retries, a "window"). You will
   * need to fill in many of the details, but this should be enough to
   * get you started.
   */

  // first, open a UDP socket  
  int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

  // next, construct the local port
  struct sockaddr_in out;
  out.sin_family = AF_INET;
  out.sin_port = htons(0);
  out.sin_addr.s_addr = htonl(INADDR_ANY);

  if (bind(sock, (struct sockaddr *) &out, sizeof(out))) {
    perror("bind");
    exit(1);
  }

  struct sockaddr_in tmp;
  int len = sizeof(tmp);
  if (getsockname(sock, (struct sockaddr *) &tmp, (socklen_t *) &len)) {
    perror("getsockname");
    exit(1);
  }

  mylog("[bound] %d\n", ntohs(tmp.sin_port));

  // wait for incoming packets
  struct sockaddr_in in;
  socklen_t in_len = sizeof(in);

  // construct the socket set
  fd_set socks;

  // construct the timeout
  struct timeval t;
  t.tv_sec = 30;
  t.tv_usec = 0;

  // TODO: Buffer should be window size
  // our receive buffer
  int buf_len = 1500;
  void* buf = malloc(buf_len);

  // TODO: Send ack with sequence id for proper packet
  // TODO: will need to put packets in the correct order

  // wait to receive, or for a timeout
  while (1) {
    FD_ZERO(&socks);
    FD_SET(sock, &socks);

    if (select(sock + 1, &socks, NULL, NULL, &t)) {
      int received;
      if ((received = recvfrom(sock, buf, buf_len, 0, (struct sockaddr *) &in, (socklen_t *) &in_len)) < 0) {
        perror("recvfrom");
        exit(1);
      }

//      dump_packet(buf, received);

      header *myheader = get_header(buf);
      char *data = get_data(buf);
  
      if (myheader->magic == MAGIC) {
        // Check to see if it the next one we are expecting
        if (myheader->sequence == (last_rec + 1)) {
          last_rec++;
          write(1, data, myheader->length);

          mylog("[recv data] %d (%d) %s\n", myheader->sequence, myheader->length, "ACCEPTED (in-order)");
          mylog("[send ack] %d\n", myheader->sequence + myheader->length);

          header *responseheader = make_header(myheader->sequence + myheader->length, 0, myheader->eof, 1);
        
          if (sendto(sock, responseheader, sizeof(header), 0, (struct sockaddr *) &in, (socklen_t) sizeof(in)) < 0) {
            perror("sendto");
            exit(1);
          }

          if (myheader->eof) {
            mylog("[recv eof]\n");
            mylog("[completed]\n");
            exit(0);
          }
        }
      }
      else {
        mylog("[recv corrupted packet]\n");
      }
    }    
    else {
      mylog("[error] timeout occurred\n");
      exit(1);
    }
  }

  return 0;
}