The second project of CSE530 Network Programming

Author: SOYJUN

Makefile

@@ -0,0 +1,50 @@
+CC := gcc
+
+LIBS := -lresolv -lnsl -lpthread -lm\
+	../stevens_code/libunp.a\
+
+FLAGS := -g -O2
+
+CFLAGS := ${FLAGS} -I../stevens_code/lib
+
+all: client server test get_ifi_info_plus.o rtt.o serv_send.o serv_recv.o cli_send.o cli_recv.o 
+
+test: 	test.o 
+	${CC} ${FLAGS} -o test test.o ${LIBS}
+server.o: server.c
+	${CC} ${CFLAGS} -c server.c
+
+server: server.o get_ifi_info_plus.o rtt.o serv_send.o serv_recv.o
+	${CC} ${FLAGS} -o server server.o get_ifi_info_plus.o rtt.o serv_send.o serv_recv.o ${LIBS}
+server.o: server.c
+	${CC} ${CFLAGS} -c server.c
+
+
+client:	client.o get_ifi_info_plus.o rtt.o cli_send.o cli_recv.o
+	${CC} ${FLAGS} -o client client.o get_ifi_info_plus.o rtt.o cli_send.o cli_recv.o ${LIBS}
+client.o: client.c
+	${CC} ${CFLAGS} -c client.c
+
+
+get_ifi_info_plus.o: get_ifi_info_plus.c
+	${CC} ${CFLAGS} -c get_ifi_info_plus.c
+
+rtt.o:  rtt.c
+	${CC} ${CFLAGS} -c rtt.c
+
+data_send.o: serv_send.c
+	${CC} ${CFLAGS} -c serv_send.c
+
+data_recv.o: serv_recv.c
+	${CC} ${CFLAGS} -c serv_recv.c
+
+cli_send.o: cli_send.c
+	${CC} ${CFLAGS} -c cli_send.c
+
+cli_recv.o: cli_recv.c
+	${CC} ${CFLAGS} -c cli_recv.c
+
+
+clean:
+	rm test test.o client client.o server server.o get_ifi_info_plus.o rtt.o serv_send.o serv_recv.o cli_send.o cli_recv.o
+

README

@@ -0,0 +1,7 @@
+Copyright (c) 2013-2015 by Jun Zeng. <[email protected]> <[email protected]>
+All rights reserved.
+
+Based on Steven Codes' library. UNIX Network Programming, Volume 1, Third Edition.
+
+Unrestricted rights are granted to instructors and students of CSE530 class in Fall 2014
+at Stony Brook University.

ReadMe

@@ -0,0 +1,28 @@
+YIGONG WANG    SBU-ID:109973706
+JUN	ZENG	   SBU-ID:109811026
+
+
+1. 	The modifications to ensure that only unicast addresses are bound:
+	Use a loop to build up the socket and bound to the IP address the function get_ifi_info_plus(professor given) return except the first loopback address.
+
+ 	Our implementation of the array of structures described above:
+ 	Store the socket file description, the IP address and network mask returned from the given function into the servIF and cliIF structure. Then the subnet address is got by the binary and operation of IP address and the relative network mask. 
+
+2. 	The details of our modifications to the code of Section 22.5:
+	1> The parameters in struct rtt_info have set to int except rtt_base;
+	2> All the multiply and divide operation have changed into binary operation;
+	3> The return value of rtt_start is divided by 1000;
+	4> RTT_RXTMIN is set to 1000 msec, RTT_RXTMAX is set to 3000 msec and RTT_MAXNREXMT is set to 12;
+	5> All the second parameters have been changed into millisecond;
+	6> rtt_timeout passes its value through the function rtt_minmax, after doubling the RTO.
+
+
+3. 	The TCP mechanisms we implemented:
+	When the transmittion starts, the conjection window size(cwin) is set to 1, and ssthresh is set to be equal to the cwin. Then every time a successful transmittion, cwin doubles. When the sender loses its datagram and receives the duplicate ack from the receiver, the cwin and ssthresh both divide half. If there is no ack received, the cwin is set to 1 and the ssthresh divides half. If then it is successful to transmit the datagrams, cwin is set to be equal to ssthresh. When the cwin bigger than ssthresh, it changes from double increasing into linear increasing. After the sender time out 12 times, it judges that the receiver is shut down.
+
+
+4.	Sender notifying receiver of the last datagram:
+	Add one more parameter-fin into the hdr structure, and set it as 0 when the file stream has not reached the end. When the file stream is read to the end, fin is set to 1 and pass to the client with the hdr structure to notify receiver that this is the last datagram.
+
+	Clean closing: 
+	After send to the server with the last ack, the client uses a recvmsg and the rtt mechanism to keep listen for the retransmitted datagram for a certain time. Here we set the time as 15 seconds. Then after 15 seconds, the recvmsg times out and the client closes.

aa.c

@@ -0,0 +1,77 @@
+/* include dgsendrecv1 */
+#include    "unprtt.h"
+#include    <setjmp.h>
+
+#define CLI_TIMEOUT 8000
+#define RTT_DEBUG
+
+static int  rttinit = 0;
+static struct msghdr    msgrecv;   /* assumed init to 0 */
+static struct hdr {
+    uint32_t  seq;    /* sequence # */
+    uint32_t  ts;     /* timestamp when sent */
+    uint32_t  fin;    /* mark when file eof */
+} recvhdr;
+
+static void sig_alrm(int signo);
+static sigjmp_buf   jmpbuf;
+
+struct hdr cli_recv(int fd, void *inbuff, size_t inbytes)
+{
+    ssize_t         n;
+    struct iovec    iovrecv[2];
+    struct rtt_info   rttinfo;
+
+
+    msgrecv.msg_name = NULL;
+    msgrecv.msg_namelen = 0;
+    msgrecv.msg_iov = iovrecv;
+    msgrecv.msg_iovlen = 2;
+    iovrecv[0].iov_base = &recvhdr;
+    iovrecv[0].iov_len = sizeof(struct hdr);
+    iovrecv[1].iov_base = inbuff;
+    iovrecv[1].iov_len = inbytes;
+
+    rttinfo.rtt_rto = CLI_TIMEOUT; //8 sec time out
+
+    if (rttinit == 0) {
+        rtt_init(&rttinfo);     /* first time we're called */
+        rttinit = 1;
+        rtt_d_flag = 1;
+    }
+
+    Signal(SIGALRM, sig_alrm);
+    rtt_newpack(&rttinfo);      /* initialize for this packet */
+
+    alarm(rtt_start(&rttinfo)/1000); /* calc timeout value & start timer */
+
+//#ifdef  RTT_DEBUG
+    rtt_debug(&rttinfo);
+//#endif
+
+    if (sigsetjmp(jmpbuf, 1) != 0) {
+            err_msg("cli_recv: no response from server, giving up");
+            rttinit = 0;    /* reinit in case we're called again */
+            errno = ETIMEDOUT;
+            err_sys("[ERROR]: Timeout");
+            return recvhdr;
+    }
+
+    n = Recvmsg(fd, &msgrecv, 0);
+    if (n < sizeof(struct hdr)){
+        err_sys("[ERROR]: Received packet incomplete");
+    }
+
+    printf("Length: %d\n", (int)n);
+    //printf("BUFFER: %s\n", (char *)iovrecv[1].iov_base);
+    printf("SEQ NUM: %u\n", recvhdr.seq);
+    printf("IS FIN: %u\n", recvhdr.fin);
+    alarm(0);           /* stop SIGALRM timer */
+    return(recvhdr); /* return size of received datagram */
+}
+
+static void sig_alrm(int signo)
+{
+    siglongjmp(jmpbuf, 1);
+}
+

cli_recv.c

@@ -0,0 +1,36 @@
+#include	"unprtt.h"
+#include	<setjmp.h>
+
+#define	RTT_DEBUG
+
+static struct msghdr	msgsend;	/* assumed init to 0 */
+static struct hdr {
+  	uint32_t	seq;	/* sequence # */
+  	uint32_t	ts;		/* timestamp when sent */
+  	uint32_t	fin;	/* mark when file eof */
+} sendhdr;
+
+ssize_t cli_send(int fd, uint32_t seq_num, uint32_t timestamp, void *outbuff, size_t outbytes)
+{
+	ssize_t			n;
+	struct iovec	iovsend[2];
+
+	sendhdr.seq = seq_num;
+	sendhdr.ts = timestamp;
+	sendhdr.fin = 0;
+
+	msgsend.msg_iov = iovsend;
+	msgsend.msg_iovlen = 2;
+
+	iovsend[0].iov_base = &sendhdr;
+	iovsend[0].iov_len = sizeof(struct hdr);
+	iovsend[1].iov_base = outbuff;
+	iovsend[1].iov_len = outbytes;
+
+	if (sendmsg(fd, &msgsend, 0)<0){
+		err_sys("[ERROR:] Send packet error");
+		return(-1);
+	}
+
+	return(0);
+}