ppppeer.c

A peer-to-peer file sharing system under UNIX environment.

            rio_readinitb(&rio0, connfd);

            while((n = rio_readlineb(&rio0, buffer, MAXLINE)) != 0) 
            {
                filelist = fopen("./peerlist", "r");
                buffer[strlen(buffer)-1] = '\0';
                
                // Look up the key words in the peerlist 
                while (fgets(buffer1, MAXLINE, filelist) != NULL)    
                {

                    if ((token = strchr(buffer1, ':'))!=NULL)
                    {                    
                        token[0] = '\0';     
                        token++;                   

                        j = 0;
                        while(buffer[j])
                        {
                            buffer[j] = tolower(buffer[j]);
                            j++;
                        }                    

                        j = 0;
                        while(buffer1[j])
                        {
                            buffer1[j]= tolower(buffer1[j]);
                            j++;
                        }
                   
                        if (!strcmp(buffer,buffer1))
                        {
                            printf("I have the file with key words '%s' which he wants!\n", buffer1);
                            fflush(stdout);

                            token[strlen(token)-2] = '\0';

                            // open the local file
                            if (stat(token, &sbuf) < 0)
                            {
                                printf("Error:file is removed\n");
                            }
                            else
                            {
                                // Send the file to remote client 
                                srcfd = open(token,O_RDONLY,0);
                                filebuffer = mmap(0, sbuf.st_size, PROT_READ,
                                    MAP_PRIVATE, srcfd, 0);
                                close(srcfd);
                                rio_writen(connfd, token, strlen(token));
                                rio_writen(connfd, "\n", 1);
                                rio_writen(connfd, filebuffer, sbuf.st_size);
                                munmap(filebuffer, sbuf.st_size);
                                rio_writen(connfd,"\n.\n",3);
                            }
                        } 
                    }
                }
                fclose(filelist);
                rio_writen(connfd,".\n",2);
                printf("Successfully sending the file to client!\n");
            } 
           close(connfd);
        }
    }
    exit(0);
}

/*
 * Add the new file entry to the remote server
 */
void add_entry(char* host, int port, char* title)
{
    int clientfd;
    char buf[MAXLINE];
    rio_t rio;
    char *portstr;

    clientfd = open_clientfd(host, port);
    rio_readinitb(&rio, clientfd);

    rio_writen(clientfd, "ADD ENTRY\n", 10);
    rio_writen(clientfd, title,strlen(title));
    rio_writen(clientfd, ":",1);
    rio_writen(clientfd, localhost,strlen(localhost));
    portstr = (char *)malloc(7);
    sprintf(portstr, ":%d", myport);    
    rio_writen(clientfd, portstr,strlen(portstr));
    rio_writen(clientfd, "\n.\n", 3);

    while(rio_readlineb(&rio, buf, MAXLINE))
    {                    
        if (strcmp(buf, "SUCCESS\n") == 0) 
        {
            fflush(stdout);
            break;
        }
    }
    close(clientfd);      
    printf("ADD ENTRY:%s %s %d completed.\n",title,localhost,myport);
}

/*
 * Add the new file entry to peerlist.
 */
void add_myfile(char* title, char *filename)
{
    FILE *filelist;
    char inputstring[MAXLINE];
    char *portstr;
    char buf[MAXLINE];

    strcpy(inputstring, title);
    strcat(inputstring, ":");
    strcat(inputstring, filename);
    strcat(inputstring, "\n");

    filelist = fopen("./peerlist", "a");
    if (filelist == NULL)
    {
        printf("Error:can't open peerlist.\n");
        exit(1);
    }
    
    fputs(inputstring, filelist);
    fclose(filelist);
}

/* 
 * Deregister the file entries from the indexing server
 * before exits.
 */
void deregister(char *host, int port)
{
    int clientfd;
    char buf[MAXLINE];
    rio_t rio;
    char *portstr;

    clientfd = open_clientfd(host, port);
    rio_readinitb(&rio, clientfd);

    rio_writen(clientfd, "DEREGISTER\n", 11);
    rio_writen(clientfd, localhost,strlen(localhost));
    portstr = (char *)malloc(7);
    sprintf(portstr, " %d", myport);    
    rio_writen(clientfd, portstr,strlen(portstr));
    rio_writen(clientfd, "\n.\n", 3);
    while(rio_readlineb(&rio, buf, MAXLINE))
    {                    
        if (strcmp(buf, "SUCCESS\n") == 0) 
        {
            printf("Deregister from the indexing server succeeds.\n");
            fflush(stdout);
            break;
        }
    }
    close(clientfd);     
}

/* 
 * Connect to the indexing server.
 */
int open_clientfd(char *hostname, int port) 
{
    int clientfd;
    struct hostent *hp;
    struct sockaddr_in serveraddr;

    clientfd = socket(AF_INET, SOCK_STREAM, 0);

    hp = gethostbyname(hostname);
    bzero((char *) &serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    bcopy((char *)hp->h_addr, 
	  (char *)&serveraddr.sin_addr.s_addr, hp->h_length);
    serveraddr.sin_port = htons(port);

    connect(clientfd, (SA *) &serveraddr, sizeof(serveraddr));
  
    return clientfd;
}

/*
 * Listen for clients.
 */ 
int open_listenfd(int port)
{
    int listenfd, optval = 1;
    struct sockaddr_in serveraddr;

    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        return -1;
    
    if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR,
        (const void *)&optval, sizeof(int)) < 0)
	return -1;
    
    bzero((char *)&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons((unsigned short)port);

    if(bind(listenfd, (SA *)&serveraddr, sizeof(serveraddr)) < 0)
        return -1;

    if(listen(listenfd, LISTENQ) < 0)
        return -1;

    return listenfd;
}

/*
 * Get the local host IP address
 */
char* getLocalIP()
{ 
   register int fd, intrface, retn = 0; 
   struct ifreq buf[MAXINTERFACES]; 
   struct arpreq arp; 
   struct ifconf ifc; 
   char* ip;

   if ((fd = socket (AF_INET, SOCK_DGRAM, 0)) >= 0) { 
      ifc.ifc_len = sizeof buf; 
      ifc.ifc_buf = (caddr_t) buf; 
      if (!ioctl (fd, SIOCGIFCONF, (char *) &ifc)) 
      { 
         intrface = ifc.ifc_len / sizeof (struct ifreq); 
         intrface--;
         if (!(ioctl (fd, SIOCGIFADDR, (char *) &buf[intrface]))) 
         { 
             ip = (char *)inet_ntoa(((struct sockaddr_in*)(&buf[intrface].ifr_addr))->sin_addr); 
         }  
      }
   }
   close(fd);
   return ip; 
} 

/* The Rio package - robust I/O functions */

/*
 * 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, 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;       /* errorno set by write() */
	}
	nleft -= nwritten;
	bufp += nwritten;
    }
    return n;
}

/* 
 * rio_read - This is a wrapper for the Unix read() function.
 */
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) {
	    if (errno == EINTR) /* interrupted by sig handler return */
		nread = 0;      /* 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_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')
		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;
}