src files and vars.mk to debug makefile

Author: randyxu

src/a.out

@@ -0,0 +1,15 @@
+#ifndef _BLUBLU_H_
+#define _BLUBLU_H_
+
+/* Head files */
+
+/* Marcos, Types*/
+
+
+/* Persistent state for the robust I/O (Rio) package */
+
+/* Globals*/
+
+/* Functions*/
+
+#endif /* _BLUBLU_H_*/

src/blublu.h

@@ -0,0 +1,30 @@
+#include <stdlib.h>
+#include "epoll.h"
+#include <stdio.h>
+#include "error.h"
+struct epoll_event *events;
+
+int epoll_create(int flags) {
+    int fd = epoll_create1(flags);
+
+    events = (struct epoll_event *)malloc(sizeof(struct epoll_event) * MAXEVENTS);
+    return fd;
+}
+
+void epoll_add(int epfd, int fd, struct epoll_event *event) {
+
+    epoll_ctl(epfd, EPOLL_CTL_ADD, fd, event);
+    return;
+}
+
+void epoll_mod(int epfd, int fd, struct epoll_event *event) {
+    epoll_ctl(epfd, EPOLL_CTL_MOD, fd, event);
+    return;
+}
+
+void epoll_del(int epfd, int fd, struct epoll_event *event) {
+    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, event);
+	return;
+}
+
+

src/epoll.c

@@ -0,0 +1,16 @@
+#ifndef _EPOLL_H_
+#define _EPOLL_H
+
+#include <sys/epoll.h>
+
+#define MAXEVENTS 1024
+
+extern struct epoll_event *events;
+
+int epoll_create(int flags);
+void epoll_add(int epfd, int fs, struct epoll_event *event);
+void epoll_mod(int epfd, int fs, struct epoll_event *event);
+void epoll_del(int epfd, int fs, struct epoll_event *event);
+//int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
+
+#endif

src/epoll.h

@@ -0,0 +1,20 @@
+/*******************************
+  print error information
+  Reference: CSAPP
+********************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "error.h"
+
+void unix_error(char *msg) /* Unix-style error */
+{
+	fprintf(stderr, "%s: %s\n", msg, strerror(errno));
+    exit(0);
+}
+
+void posix_error(int code, char *msg) /* Posix-style error */
+{
+    fprintf(stderr, "%s: %s\n", msg, strerror(code));
+    exit(0);
+}

src/error.c

@@ -0,0 +1,10 @@
+#ifndef _ERROR_H_
+#define _ERROR_H_
+
+#include <errno.h>
+void unix_error(char *msg);
+void posix_error(int code, char *msg);
+//void dns_error(char *msg);
+//void app_error(char *msg);
+
+#endif

src/error.h

@@ -0,0 +1,74 @@
+/*
+ * event_loop
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "blublu.h"
+#include "socket.h"
+#include "rio.h"
+#include "epoll.h"
+#include "error.h"
+
+int main(int argc, char *argv[])
+{
+	int epfd;
+	int listenfd, connfd;
+	int n, i;	
+	socklen_t addrlen;	
+	struct sockaddr_in clientaddr;
+	struct epoll_event event;
+
+	printf("Welcome to BluBlu!\n");
+	
+	addrlen = sizeof(clientaddr);
+	listenfd = Open_listenfd(8080);
+	make_socket_nblk(listenfd);
+	epfd = epoll_create(0);	
+printf("epfd = %d, listen fd = %d.\n", epfd, listenfd);
+	event.data.fd = listenfd;
+	event.events = EPOLLIN | EPOLLET;
+
+	epoll_add(epfd, listenfd, &event);
+
+	while (1) {
+        n = epoll_wait(epfd, events, MAXEVENTS, -1);
+
+        for (i = 0; i < n; i++) {
+        	if ((events[i].events & EPOLLERR) ||
+		        (events[i].events & EPOLLHUP) ||
+		        (!(events[i].events & EPOLLIN))) {
+				/* An error has occured on this fd, or the socket is not ready for reading */
+			    unix_error( "epoll error");
+			    close (events[i].data.fd);
+			    continue;
+			} else if (events[i].data.fd == listenfd) {
+				/* liseten fd */
+				connfd = Accept(listenfd, (SA *)&clientaddr, &addrlen);
+				if (connfd < 0)
+					break; /* errno == EAGAIN) || (errno == EWOULDBLOCK) || other error, anyway, we break.*/
+				else {
+					/* handle new connection*/
+					make_socket_nblk(listenfd);
+					event.data.fd = listenfd;
+					event.events = EPOLLIN | EPOLLET;
+					epoll_add(epfd, listenfd, &event);
+					/* TODO: handling*/
+				}
+				continue;
+			} else {
+				/* connected fd */
+				/* read data and provide http service*/
+				/* serve_client(client_fd)*/
+
+				continue;
+			}
+
+		}
+
+	}
+	free (events);
+    close (listenfd);
+
+	return 0;
+}

src/main.c

@@ -0,0 +1,187 @@
+/******************************************************************
+	rio package - robust I/O functions
+	Reference: CSAPP
+ ******************************************************************/
+
+#include <unistd.h>
+#include <string.h>
+#include "rio.h" 
+#include "error.h"
+/* 
+ * rio_readn - robustly read n bytes (unbuffered)
+ */
+ssize_t rio_readn(int fd, void *usrbuf, size_t n) 
+{
+    size_t nleft = n;
+    ssize_t nread;
+    char *bufp = usrbuf;
+
+    while (nleft > 0) {
+		if ((nread = read(fd, (void *)bufp, nleft)) < 0) {
+		    if (errno == EINTR) /* Interrupted by sig handler return */
+				nread = 0;      /* and call read() again */
+		    else
+				return -1;      /* errno set by read() */ 
+		} 
+		else if (nread == 0)
+		    break;              /* EOF */
+		nleft -= nread;
+		bufp += nread;
+    }
+    return (n - nleft);         /* return >= 0 */
+}
+
+/*
+ * rio_writen - robustly write n bytes (unbuffered)
+ */
+ssize_t rio_writen(int fd, void *usrbuf, size_t n) 
+{
+    size_t nleft = n;
+    ssize_t nwritten;
+    char *bufp = usrbuf;
+
+    while (nleft > 0) {
+		if ((nwritten = write(fd, bufp, nleft)) <= 0) {
+		    if (errno == EINTR)  /* Interrupted by sig handler return */
+				nwritten = 0;    /* and call write() again */
+		    else
+				return -1;       /* errno set by write() */
+		}
+		nleft -= nwritten;
+		bufp += nwritten;
+    }
+    return n;
+}
+
+
+/* 
+ * rio_read - This is a wrapper for the Unix read() function that
+ *    transfers min(n, rio_cnt) bytes from an internal buffer to a user
+ *    buffer, where n is the number of bytes requested by the user and
+ *    rio_cnt is the number of unread bytes in the internal buffer. On
+ *    entry, rio_read() refills the internal buffer via a call to
+ *    read() if the internal buffer is empty.
+ */
+static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
+{
+    int cnt;
+
+    while (rp->rio_cnt <= 0) {  /* Refill if buf is empty */
+		rp->rio_cnt = read(rp->rio_fd, rp->rio_buf, sizeof(rp->rio_buf));
+		if (rp->rio_cnt < 0) {
+		    if (errno != EINTR) /* Interrupted by sig handler return */
+				return -1;
+		}
+		else if (rp->rio_cnt == 0)  /* EOF */
+		    return 0;
+		else 
+		    rp->rio_bufptr = rp->rio_buf; /* Reset buffer ptr */
+	    }
+
+    /* Copy min(n, rp->rio_cnt) bytes from internal buf to user buf */
+    cnt = n;          
+    if (rp->rio_cnt < n)   
+		cnt = rp->rio_cnt;
+    memcpy(usrbuf, rp->rio_bufptr, cnt);
+    rp->rio_bufptr += cnt;
+    rp->rio_cnt -= cnt;
+    return cnt;
+}
+
+/*
+ * rio_readinitb - Associate a descriptor with a read buffer and reset buffer
+ */
+void rio_readinitb(rio_t *rp, int fd) 
+{
+    rp->rio_fd = fd;  
+    rp->rio_cnt = 0;  
+    rp->rio_bufptr = rp->rio_buf;
+}
+
+/*
+ * rio_readnb - Robustly read n bytes (buffered)
+ */
+ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n) 
+{
+    size_t nleft = n;
+    ssize_t nread;
+    char *bufp = usrbuf;
+				    
+    while (nleft > 0) {
+		if ((nread = rio_read(rp, bufp, nleft)) < 0) 
+            return -1;          /* errno set by read() */ 
+		else if (nread == 0)
+		    break;              /* EOF */
+		nleft -= nread;
+		bufp += nread;
+    }
+    return (n - nleft);         /* return >= 0 */
+}
+
+/* 
+ * rio_readlineb - robustly read a text line (buffered)
+ */
+ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen) 
+{
+    int n, rc;
+    char c, *bufp = usrbuf;
+
+    for (n = 1; n < maxlen; n++) { 
+        if ((rc = rio_read(rp, &c, 1)) == 1) {
+		    *bufp++ = c;
+		    if (c == '\n') {
+                n++;
+	     		break;
+            }
+		} else if (rc == 0) {
+		    if (n == 1)
+				return 0; /* EOF, no data read */
+		    else
+				break;    /* EOF, some data was read */
+		} else
+		    return -1;	  /* Error */
+    }
+    *bufp = 0;
+    return n-1;
+}
+
+/**********************************
+ * Wrappers for robust I/O routines
+ **********************************/
+ssize_t Rio_readn(int fd, void *ptr, size_t nbytes) 
+{
+    ssize_t n;
+		  
+    if ((n = rio_readn(fd, ptr, nbytes)) < 0)
+		unix_error("Rio_readn error");
+    return n;
+}
+
+void Rio_writen(int fd, void *usrbuf, size_t n) 
+{
+    if (rio_writen(fd, usrbuf, n) != n)
+		unix_error("Rio_writen error");
+}
+
+void Rio_readinitb(rio_t *rp, int fd)
+{
+    rio_readinitb(rp, fd);
+} 
+
+ssize_t Rio_readnb(rio_t *rp, void *usrbuf, size_t n) 
+{
+    ssize_t rc;
+
+    if ((rc = rio_readnb(rp, usrbuf, n)) < 0)
+		unix_error("Rio_readnb error");
+    return rc;
+}
+
+ssize_t Rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen) 
+{
+    ssize_t rc;
+
+    if ((rc = rio_readlineb(rp, usrbuf, maxlen)) < 0)
+		unix_error("Rio_readlineb error");
+    return rc;
+} 

src/rio.c

@@ -0,0 +1,27 @@
+#ifndef _RIO_H_
+#define _RIO_H
+
+#define RIO_BUFSIZE 8192
+
+typedef struct {
+    int rio_fd;                /* Descriptor for this internal buf */
+    int rio_cnt;               /* Unread bytes in internal buf */
+    char *rio_bufptr;          /* Next unread byte in internal buf */
+    char rio_buf[RIO_BUFSIZE]; /* Internal buffer */
+} rio_t;
+
+
+ssize_t rio_readn(int fd, void *usrbuf, size_t n);
+ssize_t rio_writen(int fd, void *usrbuf, size_t n);
+void rio_readinitb(rio_t *rp, int fd); 
+ssize_t	rio_readnb(rio_t *rp, void *usrbuf, size_t n);
+ssize_t	rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
+
+/* Wrappers for Rio package */
+ssize_t Rio_readn(int fd, void *usrbuf, size_t n);
+void Rio_writen(int fd, void *usrbuf, size_t n);
+void Rio_readinitb(rio_t *rp, int fd); 
+ssize_t Rio_readnb(rio_t *rp, void *usrbuf, size_t n);
+ssize_t Rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
+
+#endif