test4.c

this gives details of the network programming

// Netprog 2002 HW1 submission test program
// This code tests layer 4
//

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>    // read() and write() prototypes are here
//------------------------------------------------------------------
// Sample layer 1 implementation based on a unix pipe.
//

int readfd,writefd;
int generror=0;
int writecount=0;

void init_l1(void) {
  static int first=1;
  int fds[2];

  if (! first) {
    close(readfd);
    close(writefd);
  } else {
    first=0;
  }

  writecount=0;

  if (pipe(fds)==-1) {
    printf("ERROR: Can't create pipe \n");
    exit(1);
  }
  readfd = fds[0];
  writefd = fds[1];
}






// sample l1_read just calls read on stdin
int l1_read( char *b) {

  if (generror==1) {
    return(-1);
    
  } else {
    if (read(readfd,b,1)!=1) 
      return(-1);
    else
      return(1);
  }
}

// sample l1_write just calls write to stdout
int l1_write(char b) {
  writecount++;
  if (generror==2) {
    return(-1);
  } else {
    if ((generror==3) && (writecount==10)) {
      // modify only the 10th byte
      //  (aiming for the middle of the message)
      b++;
    }
    if (write(writefd,&b,1)!=1) 
      return(-1);
    else
      return(1);
  }
}


int l2_read(char *s, int max) {
  int i;
  char buf[10];
  int len;

  // read the length as 3 ASCII digits
  for (i=0;i<3;i++) {
    if (l1_read(buf+i)==-1) {
      return(-1);
    }
  }
  //convert string to int
  buf[3]=0;
  len = atoi(buf);

  // make sure the message is not too large
  if (len>max) {
    return(-1);
  }
  // now read that many bytes
  for (i=0;i<len;i++) {
    if (l1_read(s+i)==-1) {
      return(-1);
    }
  }
  // everything seems OK
  return(len);

}

int l2_write(char *s, int n) {
  int i;
  char buf[10];

  if ((n>999)||(n<0)) return(-1);

  // first send the length as 3 ASCII digits
  sprintf(buf,"%03d",n);
  for (i=0;i<3;i++) {
    if (l1_write(buf[i])!=1) {
      return(-1);
    }
  }

  // now send the buffer
  for (i=0;i<n;i++) {
    if (l1_write(s[i])!=1) {
      return(-1);
    }
  }
  
  // everything seems fine - return n
  return(n);
}


int l3_read(char *s, int max) {
  char *buff;
  int len;
  char cksum;
  int i;

  buff = (char *) malloc (max+1);
  len  = l2_read(buff,max+1);
  if (len==-1) {
    // error!
    free(buff);
    return(-1);
  }

  cksum=0;
  // calculate the checksum
  for (i=0;i<len-1;i++) {
    s[i] = buff[i];
    cksum+=s[i];
  }

  if (cksum == buff[len-1]) {
    free(buff);
    return(len-1);
  } else {
    free(buff);
    return(-1);
  }
}

int l3_write(char *s, int n) {
  char cksum;
  char *buf;
  int i;
  int retval;

  buf = (char *) malloc(n+1);
  cksum=0;
  for (i=0;i<n;i++) {
    cksum+=s[i];
    buf[i]=s[i];
  }
  buf[n]=cksum;
  retval = l2_write(buf,n+1);
  free(buf);
  if (retval==n+1) {
    return(n);
  } else {
    return(-1);
  }
}










  









//------------------------------------------------------------------
// layer 4 prototypes

int l4_write(char *, int , char *, int );
int l4_read(char *, int *, char *, int *);

char *names[] = { "firstname", "2", "\r\n", "12345678901234567890123245555" };
char *vals[] = { "blah","\t\t\t\t\t\t\t\t\"","$%^&*(()!!!","1" };
	
int num = sizeof(names)/sizeof(char *);

int main(int argc,char **argv) {
  char namebuf[1001];
  char valuebuf[1001];
  char longbuf[3000];
  int namelen;
  int valuelen;
  int i;

  init_l1();

  for (i=0;i<num;i++) {
    printf("l4 test %d: ",i);

    if (l4_write(names[i],strlen(names[i])+1, vals[i],strlen(vals[i])+1) == -1) {
      printf("Reported error at l4_write\n");
      init_l1();
    } else {
      namelen = valuelen = 101;
      if (l4_read(namebuf,&namelen,valuebuf,&valuelen)==-1) {
	printf("Reported error at l4_read\n");
	init_l1();
      }

      if ((namelen==strlen(names[i])+1) && (strcmp(names[i],namebuf)==0) &&
	  (valuelen==strlen(vals[i])+1) && (strcmp(vals[i],valuebuf)==0)) {
	printf(" OK\n");
      } else {
	printf("invalid length or value\n");
	init_l1();
      }
    }
  }

  init_l1();

  // try binary messages
  for (i=0;i<2000;i++) 
    longbuf[i]=i%256;

  printf("l4 binary test : ");

  if (l4_write(longbuf,400,longbuf,500) == -1) {
    printf("Reported error at l4_write\n");
  } else {
    namelen = valuelen = 1000;
    if (l4_read(namebuf,&namelen,valuebuf,&valuelen)==-1) {
      printf("Reported error at l4_read\n");
    } else {
      if ((namelen==400) && (memcmp(namebuf,longbuf,400)==0) &&
	  (valuelen==500) && (memcmp(valuebuf,longbuf,500)==0)) {
	printf(" OK\n");
      } else {
	printf("Invalid value received\n");
      }
    }
  }

  init_l1();
  generror=1;

  printf("l4 forced read error test : ");

  if (l4_write(longbuf,400,longbuf,500) == -1) {
    printf("Reported error at l4_write - should be read error\n");
  } else {
    namelen = valuelen = 1000;
    if (l4_read(namebuf,&namelen,valuebuf,&valuelen)==-1) {
      printf("OK\n");
    } else {
      printf("No error detected (should be one)\n");
    }
  }

  init_l1();
  generror=2;

  printf("l4 forced write error test : ");

  if (l4_write(longbuf,400,longbuf,500) == -1) {
    printf("OK\n");
  } else {
    printf("No error detected (should be one)\n");
  }
  return(0);  
}